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ć)
   

Zmienne instancji

1. Można wykorzystać 4 aces modifiers
2. Może być final
3. Może być transient
4. Nie może być: synchronized,abstract, native, strictfp,
5. Nie może być static, bo wtedy staje sie zmienną klasy

char- przytowanie

    public void absMethod() {
        char c =65000; // dodatnie 0-65535
        short s = 6500;
        
        c=s; //zonk : possible lost , chodzi o ujemne!
        s=c; //jak wyżej 
        
        byte b=0;
        
        s=b; //ok
        c=b; //possible lost a presicion bo ujemne!!
        
    }

Kwestia ustraty znaku!, Char ma tylko dodatnie!

Spis ważnych

1. Dostępność memberów -SCJP book , page 39
2. Gdy metoda w base throw Exception - SCJHP book,page 108
   
3. hashcode a equals , SCJP book, page 554

Podstawy cz.2

1. Do protected nie odnosimy się przez .
2. Dla klas w innych pakietach do protected członków można dostać się tylko
   przez dziedziczenie
3. Do protected member dostaniemy się z klasy z tego samoego pakietu!!!
4. Zmienne lokalne są bez modyfikatorów dostępu
5. W zmiennych lokalnych można uzywać final
6. Protected= package + subclass throught inheritance
7. Klasa nie bastrakcyjna z choć 1 metodą abstract jest illegal!!
8. Klasa abstrakcyjna nie musi mieć abstrakcyjnych metod!.
9. Pierwsza nie abstrakcyjna klasa musi implementować wszystkie metody abstrakcyjne z superclass.
10. static + abstract method are illegal!
11. Oznaczenie synchronized stodujemy tylko do metod i bloków kodu!
12. Native tylko dla metod! ( deklaracja jak metody anstrakcyjne)
    
13. strictfp tylko dla klas i metod ( nie dla zmiennych!!!! )
14. Varargs: void method(int... x) {}
15. Varargs musi być ostatnim marametrem!
16. Varargs=> 0 lub wiele
17. Jeżeli przed konstruktorem damy void to jest traktowany jako metoda.
18. Konstruktor nie może być ani final ani static ani abstract!
19. Ile zajmuje boolean to zależy od sprzętu!.
20. Char i short zajmują 16 bitów.
21. Klasy abstrakcyjne mogą implemntować interfejsy!
22. Metod ,które są w interfejsie nie trzeba zapisywać w klasie abstrakcuyjnej, dopiero w pierwszej klasie konkretnej!!!
23. volatile tylko do zmiennych!
24. Jeżeli klasa nie jest public to nazwa nie musi pasować do nazwy pliku!!!
25. Metoda private nie może być overriden!!
26. throws jest dozwolone po sygnaturze metody abstrakcyjnej!!
27. może być synchronized łączone z final i modyfikatorami dostępu.
28. Klasa abstrakcyjna może rozszerzać klasę konkretną!!