Haczyki

1. 
   Metoda o identycznej nazwie jak konstruktor ( np z void)
2. Return char gdy metoda zwraca inta -> ok dozwolone
3. Zwracanie null kiedy powinniśmy zwracać prymitywa.
4. Do tablicy prowadzi referencja.
5. Jeżeli stworzyłeś konstruktor z argumentami to już nie ma tego domyślnego bez argumentów
6. Czy klasa abstrakcyjna ma konstruktor? -> Tak!
7. Czy interfejs ma konstrutor? -Nie!
8. Domyślny konstruktor ma taki sam access mod jak klasa!
9. W konstruktorze nei może być jednocześnie this(..) i super(..)
10. Metody static nie sa overriden lecz tylko po typie referencji!!


11. instanceof tylko dla rferencji i klasy z tego samego drzewa dziedziczenia !


12. long is illegal in switch statement!
13. null isntance of [jakakolwiek kalsa] => false !! ( także pośrednio)
14. [Dog object] instance of Cat => compilation error!
15. argument byte not passing to method(Long)
16. int x => wybierze Object x niż Integer... (var-arg)
17. List nie możesz dodać Dog or Cat !!
18. List poprawne!!
19. List oznacza każdy rodzaj Listy!!!
    

 //haczyki
 String[]  czyDozwolonyNull(){ return null; } //ok
 int[]  czyDozwolonyNullDlaPrymiTywa(){ return null; } //ok
}

abstract class CzykonstruktorMa {

 public CzykonstruktorMa() {
 }
}

class Konkret{
 int dupeczka;

 public Konkret() {  }

 /*To jest metoda a nie konstruktor!!!*/
 public void Konkret(){}

 public Konkret(int dupeczka) {
     Konkret();  //metoda e nie konstruktor
     this.dupeczka = dupeczka;
 }
}


class Base{
 int x; int y;

 public Base(int x, int y) {
     this.x = x; this.y = y;
 }
}

//!class Extended extends Base{ } zonk bo
//nie ma domyślnego konstruktora

/*Teraz jest ok*/
class Extended extends Base{

 public Extended(int x, int y) {
     super(x, y);
 }
}

Poliporfizm

Tylko metody sąwywoływane  dynamicznie ( po typie obiektu na który wskazuje  referencja)
Zmienne static i nonstatic nie są dynamicznie wybierane, wybieran są ząś po typie referencji!!
Overloading nie po typie referencji!!
Przy oveloading można dowolnie zmieniać modyfikator dostępu jak i zwracaną wartość.

instanceof

   @Test
   public void testInstanceOf() {

       //assertTrue(null instanceof  Object); false
       //assertTrue(null instanceof  String); false

       //!!assertTrue(int instanceof  Object); compilation Error
       //@assertTrue(String instanceof  Object); błąd kompilacji

       //primitives
       int x = 6;
       //assertTrue(x instanceof  Object); zonk :)
       /**
        * Wnioske:
        *   referencja instanceof Klasa
        */

        int[] tab ={1,2,3};
        assertTrue(tab instanceof Object); //ok
   }

1. 
   Pisane tylko małymi literami
2. Zasada: po lewej stronie referencja
3. Zasada: po proawej stronie Klasa Name
   

Zasady overriding

1. Lista argumentów musi dokładnie pasować. ( ?)
2. Taki sam zwracany typ lub subtyp!
3. Modyfikator dostępu nie może być bardziej restrykcyjny!
4. Modyfikator dostępu może być mniej restrykcyjny.
5. jeżeli klasy base i subclass są w tym samym pakiecie to można override metody nie oznaczone private lub final.
6. Jeżeli klasy base i subclass są w różnych pakietach to można override metody nie oznaczone final i oznaczone public lub protected!
7. Metoda nadpisująca może rzucać unchecked(runtime) wyjątkiem,jakimkolwiek.
8. metoda nadpisująca nie może rzucać wyjątkiem(checked) zupełnie nowym lub bardziej ogólnym od metody nadpisywanej!
9. metoda nadpisująca może rzucać wyjątkami mniej ogólnymi lub liczbebnością mniej
10. metoda nadpisująca nie musi throw jakiekokolwiek wyjątku!
11. Nie możeż nadpisywać metod finalnych.
12. Nie możesz nadpiywać metod static!
13. Jeżeli metoda nie może nie być dziedziczona to nie może być nadpisywana (np private method in base class)
14. 
    

public class Base {

    public void publicMethodInBase(){}
    public void methodWithException() throws Exception{}
    public void methodWithManyExceptions()throws IOException,NotSerializableException{}
    
    public int intReturnMethod(){return 1;}
    public void intArgMethod(int x){};
    
    
}


public class Subclass extends Base{

    /*Bardziej restrykcyjny mod dostępu !*/
    //!protected  void publicMethodInBase(){}
    
    @Override /*Ob bo wężwzy exception*/
    public void methodWithException() throws IOException{}
    
    /*Jest wiecej wyjątków ale węższe od Exception*/
    public void methodWithException() throws IOException,NotSerializableException{} 
    
    public void methodWithException() {} //ok, bo mniej wyjątków
    
    /*Zonk bo szerszy exception!!*/
    //!public void methodWithManyExceptions()throws Exception{}
    
    //!public long intReturnMethod(){return 1;} //zonk bo inny return!
    
    /*To nie overriding lecz overloading!*/
    public void intArgMethod(long x){};
}

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!!