chmielua.com: 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::

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

Nie dozwolone:

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:

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:

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:

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:

    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

  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

  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:
```
  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

chmielua.com

In search this blog

poniedziałek, 22 sierpnia 2011

Fundamentals of JaVa