Polimoryzm

public class Base {

    public static String _static="base_static";
    public String _inst="base_inst";

     public String publicMethod(){
         return "base_public_method";
     }
     private String privateMethod(){
         return "base_public_method";
     }
}

public class Subclass extends Base{

    public static String _static="subclass_static";
    public String _inst="subclass_inst";

     public  String publicMethod(){
         return "subclasss_public_method";
     }
}

 @Test
    public void testprzyslaniania(){
        
        Base base = new Base();
        prn(base._inst); //base_inst
        prn(base._static);//base_static
        prn(base.publicMethod());//base_public_method

        Subclass sub = new Subclass();
        prn(sub._inst);//subclass_inst
        prn(sub._static);//subclass_static
        prn(sub.publicMethod());//subclasss_public_method

        Base base_ref= sub;
        prn(base_ref._inst);//base_inst
        prn(base_ref._static);//base_static
        prn(base_ref.publicMethod());//subclasss_public_method

        Base base_base_cast=(Base)sub;
        prn(base_base_cast._inst);//base_inst
        prn(base_base_cast._static);//base_static
        prn(base_base_cast.publicMethod());//subclasss_public_method
        
          /**
         * Wnioski:
           * + dynamicznie (po typie obiektu) są tlko metody
           * + zmienne static / inst = są wybierane po typie referencji!
         */
    }

Extend - przykłady

Poniższe jest ok

interface Driver{}
interface Drivere extends Driver{}
abstract class AbsClass  implements Driver{}
class FirstConcreteclass extends AbsClass implements Driver{}
abstract class SecoundABstratClass extends FirstConcreteclass{}

Java nie sprawdza ,ze podwórnie klasa FirstConcreteclass implementuje Driver
i klasa bastrakcyjna może rozszerzać nie abstrakcyjną,

Enum

public enum ERozmiar {

    DUZY(100), SREDNI(10),
    MALY(1) {

        @Override
        public String getStringReprezent() {
            return "IAmMaly!!";
        }
    };

    /**
     * Wymagany jest konstruktor z intem
     * nie może być public!!!
     * wejdzie gdy Erozmiar roaz= Erozmia.DUZY
     */
    ERozmiar(int wybrany) {
        this.wybrany = wybrany;
    }
    private int wybrany;

    public int getWybrany() {
        return wybrany;
    }

    public String getStringReprezent() {
        return "otherThanMALY";
    }
}


public class ConcreteClass  {

    /**
     * maly,sredni,wielki są pub;ic staic final!!!!!
     */
    enum Rozmiary{ maly, SREDNI, WIELKI}


    @Test
    public void extendEnumTest(){
        ERozmiar rozDuzy =ERozmiar.DUZY;
        prn(rozDuzy.getStringReprezent());

        ERozmiar rozMaly =ERozmiar.MALY;
        prn(rozMaly.getStringReprezent());

        //results:
        //otherThanMALY
        //IAmMaly!!
    }

1. Niem oże być deklarowany lokalnie! ( w metodzie)
   
2. Wewnątrz klasy i owszem.!!!!!!!
3. Moga być deklarowane w osobnym pliku!
4. Dekalracja enuma poza klasą nie może być protected lub private!
5. Dekalracja enuma poza klasą może być default lub public!
6. Na końcu nie musi być średnika :D
7. Enum może mieć metody , zmienne swoje , konctruktor z intem!!
8. Jeżeli wydrukujemy to bedzie domyślenie drukowana anzwa enum np MALY
9. Kązdy enum ma static funkcje values , która zwraca tablicę elemtów enuma w kolejności.
10. Nie możesz wywołać konstruktora enuma bezpośrednio!!!
11. Element elumu może nadpisywać metody w tym enumie!!
    

Zmienne final

1. Raz zainicjalozowane nie mogą być zmieniane
2. Jeśli chodzi o ptymitywy to chodzi o vartość
3. Jeśli chodzi o Obiekt to nie wolno zmieniać referencji, zaś samo obiekt może być modyfikowany!.
4. Nie ma final obiektów, tylko final referencje!
5. Co do final klas- nie mogą być subklasowane
6. Co do final metod - nie mogą być overriden!
   

public class ConcreteClass  {

    final int x;
    
    public ConcreteClass() {
        x=10;
        //x=12; 2 raz nie wolno
    }
    
    @Test
    public void finalTest() {
   
       // x=12; tylko w KONSTRUKTORZE!   
        final int x_inside_method;
        x_inside_method=9;
       // x_inside_method++; nie wolno!! be be
    } 

Deklarowanie tablic

    @Test
    public void testTablicy(){
        //all correct
        int[] x;
        int y[];
        String[][] strinTab;
        String [] stringTable[];     
    }

1. Przy deklaracji nie używamy rozmiarów ( np int[5] tablica).

Zmienne lokalne

1. Nazywane takrze automatyczne,
2. Zmienne nie tylko są inicjalozowane ale także deklarowane wew. metody
3. Są niszczone kiedy wyjdziemy z metody!
4. Są na stosie
5. Jeżeli zmienną bedzie obiekt to i tak bedzie on na stercie!
6. Nie ma czegoś takiego jak obiekt lokalny , jest to tylko lokalna referencja do obiktu na stercie.
7. trzebą ją zasinicjalozować!!!! ( przed użyciem)
   
8. Może mieć taką samą nazwę jak zmienna instancji ( także static).
   

Porównanie modyfikatorów

1. Zmienne lokalne : final
2. Zmienne ( nie lokalne) : final, public, protected, private ,static, transient volatile
3. Metody: final, public, protected, private ,static, abstract, synchronized, strictpf, native
4. Klasa: hm... public, default, strictfp, abstract...( dodać)