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

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