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

Protected access

public class Parent {
    protected int i=14;
}

public class Child extends Parent {

    @Test
    public void  testProtectedAcess(){
        prn(i); // z superClass => OK działa

        Parent parent = new Parent();

        //zadziałała jak 2 klasy sa w tym samym pakiecie!
        prn(parent.i);

        
    }
}

• Trzeba się bacznie przypatrzeć!!

TODO

Przysłanianie metod, które są prywatne w klasie bazowej
Kiedy obiekty są dostępne dla GC! {scope ,wyjście z metod, różne!!!}

Interfejs

1. W pliku java może być kilka interfejsów!
   
2. Interfejs bez moted może być!
3. metody interfejsu nie mposiadają ciała!
4. Każda  metoda interfejsu musi być implementowana w klasie implementującej!
5. uwaga! Klasa abstrakcyjna może posiadać abstrakcjyjne jak i nie abstrakcyjne metody! 
6. Metoda int ok(); jest widziana jako public abstract ok()
7.  Interfejs może zawierać zmienne ,które są public, static final ( consts) !!
8. Nie może posiadać metod statycznych!
9. Nie może być oznaczony  jako final, strictfp lub native!!
10. Interfejs może extend  tylko  jedną lub kilka interfejsów!!
11. Interfejs nie może immplement czegoś!!
12. Każda metoda w interfejsie jest public i abstract!

1. 
   

//private interface Bouncable {} nie może być private
//protected interface Bouncable {}  // nie wolno
abstract interface Bouncable2{};
//public abstract interface dsd{} nie ładzia
public interface Bouncable{

    //test zmiennych
    int ok=1; //widziana jako public static final !!!!!!!!!!!!!!!
    //!int ok2; //musi być zainicjalozowana ( bo stała!!)

    //!protected int ok=2; nie wolno

    final int ok2=9; //ok
    static int ok3=12; //ok
    public int ok4=99; //ok

    public abstract  int ok(); //działa
    int ok2(); //UWAGA!! i tak jest widziana jako public abstract!!

    //!int ok3(){}; metody interfejsu nie mposiadają ciała!
    
    //test static
   //! static int metodaStatyczna(); nie może być STATIC!!
    
    //test final
    //!final void doSth();   niedozwolone
    //!private void doSth(); niedozwolone
    
} 

Pytania

1. Czy klasa abstrakcyjna może imlementować interfejs?
2. Klasa dziedzicząca z klasy abstrakcyjnej musi dziedziczyć wszytkie metody abstrakcyjne?
3. Czy się to skompiluje? final abstract class{}
4. Czy klasa abstrakcyjna musi mieć jakąkolwiek motedę lub zmienną ?

Klasa abstrakcyjna

abstract class Car{

private  double price;//ok
private final int x=5;//ok

private static int $=9; //ok

private static final int _=9; //ok

/*variable cannot be abstract*/
//public abstract int i;

/* klasa abstrakcyjna nie ma ciała!*/
// public abstract int getInt(){};

public abstract int getInt(); //ok

/*niedozwolona kombinacja*/
//!private abstract int getIntPriv(); //ok

protected  abstract int getIntPriv(); //ok
 abstract int getInt2(); //ok


 public int normalMethodWithBody(){ //ok

     byte b=9; //ok
     b=b++; //ok szok!!
    return b; //autmoatyczna promocja typów na szerszy :D
 }

}

• 
  
  
  Jeżeli klasa posiada choć 1 metodę abstract to cała klasa musi być abstract!>
• 
  
  Klasa dziedzicząca z klasy abstrakcyjnej musi dziedziczyć wszytkie metody abstrakcyjne!
  
  
  

Inkrementacja byte

byte x=7;
b++;  //ok
b=b++;//ok
b=(b+10); // promocja b+10 na inta , trzeba cast
b=(byte)(b+10); // ok

Co się stanie po b++ ?