Fundamentals of JaVa

---

Deklaracje i kontrola dostępu...

Kilka rad przy deklarowaniu zmiennych.

• Zmienne musza zaczyna¢ się od litery, podkreślenia "_", lub znaku waluty "£ $".
• Po pierwszym znaku zmienna może zawierać cyfry.
• Deklaracja zmiennych może mieć dowolną długość.
• Zmienna nie może być reprezentowana przez słowa kluczowe np. new
• Podążając za konstrukcją JavaBeans metody muszą używać tak zwanej zasady "camelCase" i w zależności od przeznaczenia metody musi się zaczynać od set, get, is, add lub remove.

Dozwolone deklaracje zmiennych::

1. int ___i;  
2.    int $a;  
3.    int a345;  
4.    int abc;  
5.    int bardzo_dl_nazwa;   

int ___i;
   int $a;
   int a345;
   int abc;
   int bardzo_dl_nazwa; 

Nie dozwolone:

1. int @abc;  
2.   int 2a;  
3.   int #b;  
4.   int no spaces;  
5.   Integer int;  

int @abc;
  int 2a;
  int #b;
  int no spaces;
  Integer int;

JavaBeans posługuje się szablonem który można mniej więcej opisać tak: Każda z tych metod musi być oznaczona jako public. Metody z przedrostkiem get, oznaczają pobranie wartość zmiennej, muszą zwracać zmienną tego samego typu którą reprezentują i nie mogą przyjmować argumentów. Metody z przedrostkiem set używane są do ustawiania wartości dla danej zmiennej, są typu void i metoda przyjmuje argument odpowiadający danej zmiennej. Metody zaczynające się z przedrostkiem is muszą zwracać typ boolowski i nie przyjmują żadnych argumentów. Metody z przedrostkiem add i remove przeznaczone są dla metod obsługujących zdarzenia. Metody te muszą być poprzedzone przedrostkiem add lub remove i podawać rodzaj nasłuchiwacza czyli np.addActionListener(). Metody te muszą również kończyć się słowem "Listener", jak i muszą przyjmować typ listener'a który ma zostać dodany lub i usunięty. Poniżej kilka przykładów pokaże co mam na myśli, prawidłowe:

1. public void setMyValue(int v)  
2.   public int getMyValue()  
3.   public boolean isMyStatus()  
4.   public void addMyListener(MyListener e)  
5.   public void removeMyListener(MyListener e)  

public void setMyValue(int v)
  public int getMyValue()
  public boolean isMyStatus()
  public void addMyListener(MyListener e)
  public void removeMyListener(MyListener e)

Teraz dla porównania kilka nie dozwolonych pozycji:

1. void setMyName(String name)  
2.   public void changeMyName(String name)  
3.   public void addThisListener(MyListener e)  

void setMyName(String name)
  public void changeMyName(String name)
  public void addThisListener(MyListener e)

Zasady deklaracji klas, pakietów i importów.

• plik z kodem źródłowym może mieć tylko jedną klasę publiczną public class NameClass.
• jeżeli plik z kodem źródłowym zawiera chociaż jedną klasę publiczną, nazwa pliku musi pasować do nazwy klasy public class A == A.java
• plik może zawierać tylko jedną deklaracje pakietu package, ale może zawierać wiele importów imports
• jeśli występuje deklaracja pakietu, musi ona być pierwszą linią kodu nie licząc komentarzy
• komenda imports musi występować pomiędzy deklaracja package, a deklaracją klasy class Name
• jeżeli plik nie zawiera polecenia package import musi być pierwszą komendą nie licząc komentarzy
• pakiet i importy tyczą się wszystkich klas zawartych w pliku
• plik może mieć więcej niż jedną niepubliczną klasę
• dla plików z klasą niepubliczną niema żadnych restrykcji z nazwą pliku

Modyfikatory dostępu klasy

• Są trzy modyfikatory dostępu public, protected i private
• Ale są cztery poziomy dostępu: public, protected, default i private
• Klasy mogą mieć tylko publiczny lub domyślny dostęp public class Name lub class Name
• Klasy z domyślnym dostępem mogą być widziane tylko przez klasy z tego samego pakietu
• Klasy z publicznym modyfikatorem dostępu widziane są przez wszystkie klasy ze wszystkich pakietów
• Widoczność klas obraca się w koło tego, co dany kod będzie mógł:
  • Utworzyć instancje innej klasy
  • Dziedziczyć lub też czy inne klasy będą mogły po niej dziedziczyć
  • Mieć dostęp do metod i zmiennych innej klasy.

Modyfikatory klas (bez dostępu)

• Klasy mogą również być określane za pomocą final, abstract lub stricfp
• Klasa nie może być zarazem final i abstract
• Klasa oznaczona jako final class nie może mieć podklas, inaczej nie można po niej dziedziczyć, automatycznie wszystkie metody i zmienne zawarte w klasie są również final
• Klasa abstrakcyjna nie może posiadać instancji, nie można utworzyć obiektu tej klasy
• Jeżeli klasa zawiera chociaż jedną deklaracje metody abstrakcyjnej, to klasa musi być deklarowana jako abstrakcyjna.
• Klasa abstrakcyjna może mieć zarówno nieabstrakcyjne metody jak i abstrakcyjne
• Pierwsza klasa nieabstrakcyjna która dziedziczy po klasach abstrakcyjnych musi mieć zaimplementowane wszystkie abstrakcyjne metody klas abstrakcyjnych

Poniżej przykład dziedziczenia po klasach abstrakcyjnych:

1. abstract class A{  
2.        abstract String print();  
3.   }  
4.   
5.   abstract class B extends A{  
6.       abstract int count(int a, int b);  
7.   }  
8.   
9.   class AB {  
10.      int count(int a, int b){  
11.          return a + b;  
12.      }  
13.    
14.      String print(){  
15.          return "is ok ;)";  
16.      }  
17.   }  

abstract class A{
       abstract String print();
  }

  abstract class B extends A{
      abstract int count(int a, int b);
  }

  class AB {
     int count(int a, int b){
         return a + b;
     }
 
     String print(){
         return "is ok ;)";
     }
  }

Implementacja interfejsów

• Interfejs jest pewnego rodzaju kontraktem zapewniającym co dana klasa musi robić, ale nic nie mówiącym w jaki sposób klasa ma to robić.
• Interfejs może być zaimplementowany przez jakąkolwiek klasę, i pozycja w hierarchii klasy nie ma znaczenia
• Interfejs jest jak czysta klasa abstrakcyjna ( wszystkie metody są abstrakcyjne ), interfejs jest abstrakcyjny bez znaczenia czy typujemy słowo abstract czy też nie.przed definicja interfejsu abstrac interface Bounceable { } == interface Bounceable { }
• Interfejs może zawierać tylko metody abstrakcyjne, konkretne metody są nie dozwolone
• Metody zawarte w interfejsie są domyślnie public abstract, deklaracja tych modyfikatorów jest opcjonalna.
• Interfejs może zawierać stałe zmienne które są domyślnie public, final, static
• Stałe mogą opcjonalnie zawierać te modyfikatory w dowolnej kombinacji.
• Klasa nie abstrakcyjna implementująca interfejs musi spełniać następujące warunki:
  • Musi zawierać konkretną implementacje metod zawartych w interfejsie.
  • Musi spełniać wszystkie zasady związane z nadpisywaniem metod zawartych w interfejsie
  • Nie może deklarować żadnych nowych wyjątków dla implementowanych metod
  • Nie może deklarować żadnych wyjątków, które są wyżej w hierarchii drzewa niż te wyjątki które są zdeklarowane w metodzie
  • Metody mogą deklarować runtime exception, nie zależnie od deklaracji zawartej w interfejsie
  • Metoda musi posiadać ten sam typ zwracający co deklaracja metody w interfejsie, dozwolone jest przykrywanie typu returnnp. metoda zwraca int możemy śmiało zwrócić short itp.
• Klasy implementujące interfejs mogą same być abstrakcyjne
• Klasa abstrakcyjna implementująca interfejs nie musi nadpisywać tych metod, ale pierwsza konkretna klasa tak
• Klasy mogą dziedziczyć tylko po jednej klasie, ale mogą za to implementować wiele interfejsów.
• Interfejs natomiast może dziedziczyć jeden lub więcej interfejsów
• Interfejsy nie mogą dziedziczyć po klasach, czy też implementować klasy lub inne interfejsy

Przykład nadpisywania metod w interfejsu, więcej będzie o tym pózniej:

1.     interface Ara {  
2.        // skladowe interfejsu zawsze sa public, static i final  
3.        public static final int x = 2;    
4.        // metody interfejsu zawsze sa public i abstract  
5.        public abstract int getA(int a);  
6.        int getB(int b);  
7.        int getC(int c) throws IOException;  
8.        int getD(int d);  
9.     }  
10.       
11.     class Kinder implements Ara{      
12.       
13.     // dozwolone runtime exception   
14.     public int getA(int a) throws RuntimeException{  
15.         return a;  
16.     }  
17.       
18.     //niemoze, metoda w interfejsie nie definuje wyjatku  
19.     public int getB(int b) throws Exception{   
20.         return b;  
21.     }  
22.       
23.     //niemozna wyjatek Exception jest wyzej w hierarchii  
24.     public int getC(int c) throws Exception{  
25.         return c;  
26.     }  
27.       
28.     // dozwolone  
29.     public int getD(int d) throws AbstractMethodError{  
30.         return d;  
31.     }  
32.   
33. }  

    interface Ara {
       // skladowe interfejsu zawsze sa public, static i final
       public static final int x = 2;  
       // metody interfejsu zawsze sa public i abstract
       public abstract int getA(int a);
       int getB(int b);
       int getC(int c) throws IOException;
       int getD(int d);
    }
    
    class Kinder implements Ara{    
    
    // dozwolone runtime exception 
    public int getA(int a) throws RuntimeException{
        return a;
    }
    
    //niemoze, metoda w interfejsie nie definuje wyjatku
    public int getB(int b) throws Exception{ 
        return b;
    }
    
    //niemozna wyjatek Exception jest wyzej w hierarchii
    public int getC(int c) throws Exception{
        return c;
    }
    
    // dozwolone
    public int getD(int d) throws AbstractMethodError{
        return d;
    }

}

Modyfikatory dostępu dla składowych klasy.

• Metody i zmienne klasowe znane są jako "members"
• Metody i zmienne klasowe używają wszystkich modyfikatorów dostępu: public, protected, default, private
• Dostęp do składowych klasy dostajemy na dwa sposoby:
  • Kod jednej klasy może mieć dostęp do zmiennych składowych innej klasy
  • Pod klasa może odziedziczyć składowe klasy poprzez dziedziczenie
• Jeśli klasa nie jest dostępna, składowe klasy również są niedostępne
• Określenie widzialności klasy jest ważniejsze niż widoczność zmiennych
• Składowe klasowe public są dostępne dla wszystkich innych klas, nawet tych z spoza pakietu.
• Jeśli zmienne składowe klasy są public to podklasa dziedziczy je, bez względu na pakiet
• Dostęp do zmiennych bez operatora dot "." oznacza, że muszą należeć do tej samej klasy.
• this. zawsze się odnosi do obecnie wykonywanego obiektu.
• this.addMethod ( ) oznacza dokładnie to samo co addMethod ( )
• Zmienne składowe z modyfikatorem dostępu private mogą być dostępne tylko dla tej samej klasy
• Zmienne składowe są niewidoczne dla podklas, więc nie mogą zostać odziedziczone
• Modyfikatory dostępu domyślny i protected różnią się tylko jeśli chodzi o podklasy:
  • Zmienne składowe z dostępem domyślnym mogą być dostępne tylko dla klas w tym samym pakiecie
  • Zmienne składowe z modyfikatorem dostępu protected mogą być dostępne dla klas w tym samym pakiecie, plus podklasy bez względu na pakiet.
  • protected = pakiet + dzieci (dzieci oznaczają podklasy)
  • Dla podklas zmienne składowe z modyfikatorem dostępu protected mogą być dostępne tylko poprzez dziedziczenie, podklasy z spoza pakietu nie mają dostępu do składowych klasowych poprzez referencje do nad klasy, jedyną drogą aby inne klasy miały dostęp do tych składowych jest dziedziczenie
  • Zmienne składowe z modyfikatorem dostępu protected z innego pakietu, poprzez dziedziczenie są tylko dostępne dla swojej klasy, są nie dostępne dla innych klas z tego samego pakietu. Z wyjątkiem dla podklas posiadających podklasy.

Zmienne lokalne

• Zmienne lokalne zwane również zmiennymi metod, zmienne automatyczne lub zmienne stosu, zmienne te nie mogą posiadać modyfikatora dostępu.
• Przy zmiennych lokalnych możemy tylko używać tylko modyfikatora final
• Zmienne lokalne nie dostają domyślnych wartości, trzeba je zawsze inicjalizować przed użyciem

Inne modyfikatory składowych klasowych

• metody oznaczone jako final nie mogą być nadpisywane w podklasach
• metody abstrakcyjne są deklarowane jako sygnatura, z typem który muszą zwracać i opcjonalnie z klauzurą throws, ale nie mogą być zaimplementowane, czyli nie mogą posiadać ciała, muszą się kończyć średnikiem " ; "
• abstrakcyjne metody nie mogą kończyć się klamrami
• Trzy sposoby wykrycia nieabstrakcyjnej metody:
  • metoda nie jest oznaczona słowem abstract
  • metoda posiada klamry np. public abstract ass() { }
  • metoda zawiera kod pomiędzy nawiasami klamrowymi
• pierwsza konkretna klasa, która dziedziczy po klasach abstrakcyjnych musi mieć zaimplementowane wszystkie metody abstrakcyjne
• słowa synchronized można tylko używać przy deklaracji metod lub bloków kodu
• metody oznaczone jako synchronized mogą posiadać wszystkie modyfikatory dostępu, i mogą być również oznaczone jako final
• metody abstrakcyjne muszą być zaimplementowane w podklasach więc muszą spełniać warunki dziedziczenia ich. Metody te nie mogą:
  • metody abstrakcyjne nie mogą być oznaczone jako private
  • metody abstrakcyjne również nie mogą być oznaczone słowem final
• modyfikator native może być użyty tylko z metodą
• modyfikator strictfp może być tylko używany z klasami i metodami

Metody z lista argumentów zwane var-args

• Od Java'y 5, możemy deklarować metody, które przyjmują parametry od 0 do wielu argumentów. Dlatego nazywa się je var-args
• metody var-args deklarujemy przy użyciu składni typ... nazw lub typ ... nazw np. int count ( int ... args ) { }
• metoda może posiadać tylko jeden taki parametr.
• jeżeli metoda posiada normalne parametry i parametr var-arg, to ten parametr var-arg musi być wymieniony na końcu

Deklaracja zmiennych

• Zmienne zwane zmiennymi instancji mogą:
  • posiadać jakikolwiek modyfikator dostępu
  • mogą być onaczone jako final lub transient
• Zmienne instancji klasy nie mogą być oznaczone jako abstract, synchronized, native, strictfp
• jest dozwolone zadeklarowanie zmiennej lokalnej z taką samą nazwą co zmienna instancji klasy, nazywa się to "shadowing"
• zmienne zadeklarowane jako final posiadają następujące właściwości:
  • zmienne oznaczone jako final mogą być zainicjalizowane tylko raz, nie można później już przypisać im innej wartości
  • referencja oznaczona jako final nie może wskazywać na inny obiekt
    
    1. final Object o = new Object( );  
    2. Object o1 = o;  
    3. o.setSomething( 'a' ); // może być zmieniana wartość   
    4. boolean test = (o == o1) ? true : false; // bedzie true   

      final Object o = new Object( );
      Object o1 = o;
      o.setSomething( 'a' ); // może być zmieniana wartość 
      boolean test = (o == o1) ? true : false; // bedzie true 
    

  • referencje oznaczone jako final muszą być zainicjalizowane zanim konstruktor się zakończy
    1.  class Test {  
    2.     final String str;  
    3.     Test ( ) {  
    4.        str = "is initialized";  
    5.     }   
    6.  }  
    7.   
    8. // lub tak  
    9.   
    10.  class Test2 {  
    11.     final String str;  
    12.     Test ( ) { }  
    13.     {  
    14.        // blok wykonuje sie przed konstruktorem  
    15.        str = "is initialized";  
    16.     }   
    17.  }  

      class Test {
         final String str;
         Test ( ) {
            str = "is initialized";
         } 
      }
    
     // lub tak
    
      class Test2 {
         final String str;
         Test ( ) { }
         {
            // blok wykonuje sie przed konstruktorem
            str = "is initialized";
         } 
      }
    

• W Javie nie ma czegoś takiego jak final object. Oznaczenie referencji jako final wcale nie oznacza że sam obiekt jest niezmienny
• transient modyfikator ten odnosić się może tylko do zmiennych klasowych
• tak samo modyfikator volatile

Deklaracja tablic

• Tablica może przechowywać typy proste lub obiekty, ale należy pamiętać że jest ona sama obiektem
• Kiedy deklarujemy tablice nawiasy kwadratowe mogą być z prawej lub lewej strony nazwy zmiennej np. int[ ] a; int a[ ]; int [ ] a; int[ ] a [ ]; int [ ][ ] a
• Nigdy nie można deklarować tablicy od razu z rozmiarem np. int [6] arr tak nie można
• Tablica przechowująca obiekty może przechowywać wszystkie obiekty które przejdą test IS-A czyli inctanceof

Metody statyczne i zmienne statyczne

• Zmienne te nie są powiązane z instancją żadnej klasy, znaczy że nie musi istnieć instancja danej klasy aby móc się odwołać do zmiennej statycznej czy też metody
• Nie są potrzebne żadne instancje klas aby móc użyć składowych statycznych klasy
• Istnieje tylko jedna kopia zmiennej/klasy statycznej i wszystkie instancje klasy się nią dzielą
• nie można się odwoływać z metod statycznych do składowych niestatycznych

Enums

• Enum określa listę stałych wartości przypisaną do jakiegoś typu
• enum nie jest String-iem ani int-em, enum jest zbiorem stałych określonych przez typ enum np. LATO lub ZIMA należą do enum o typie Sezon
• enum możemy deklarować wewnątrz klasy lub na zewnątrz, ale nie można deklarować wewnątrz metody
• jeżeli deklarujemy enum poza klasą nie może być ono oznaczone poprzez żaden z tych modyfikatorów: static, final, abstract, protected, private
• enum może zawierać konstruktor, zmienne, metody i stale klasowe
• enum może przekazać argument do konstruktora enum poprzez składnie np BIG(8), gdzie przekazujemy wartość 8 do konstruktora enum
• enum kostruktor może zawierać argumenty i może być przeciążany
• enum konstruktor nigdy nie może zostać wywołany bezpośrednio w kodzie, jest zawsze wywoływany automatycznie kiedy enum jest inicjalizowane
• średnik na końcu deklaracji enum jest opcjonalny obydwa zapisy są dozwolone:
  1. enum Count {ONE, TWO, THREE}  
  2. enum Count {ONE, TWO, THREE};  

    enum Count {ONE, TWO, THREE}
    enum Count {ONE, TWO, THREE};
  

• Count.values ( ) zwraca tablice typu Count z jego wartościami

Więc po przeczytaniu tych skromnych notatek czas zrobić sobie mały test ;)

SCJP 6 exam

---