chmielua.com: Kolejność wykonywania kodu, wyjątki i assercja

If and switch

Jedynym dozwolonym wyrażeniem w bloku if jest wyrażenie zwracające wartość boolowską czyli typ boolean, innymi słowy musi być to wyrażenie którego wartość wynikowa daje jedną z wartości boolean lub Boolean
Należy uważać na przypisywanie wartości (=) zamiast znaku testującego (==) i zwracającego boolowską wartość
1. boolean x = false;
2. if (x = true) {} // mamy przypisanie więc x zawsze będzie true
```
  boolean x = false;
  if (x = true) {} // mamy przypisanie więc x zawsze będzie true
```
Nawiasy klamrowe nie są konieczne dla if'a, wtedy czytana jest tylko pierwsza linia wyrażenia warunkowego
switch może przyjmować tylko enum, byte, short, int, char Nie możemy np.
1. long s = 30;
2. switch(s) { }
4. // lub patrzymy na zasięg
5. byte b = getValue();
6. switch () {
7. case 1: break;
8. // da blad, jestesmy po za zakresem byte
9. case 128: break;
10. }
```
  long s = 30;
  switch(s) { }

// lub patrzymy na zasięg
  byte b = getValue();
  switch () {
     case 1: break;
     // da blad, jestesmy po za zakresem byte
     case 128: break; 
  } 
```
Stała case zmienna musi być stała niezmienna, wliczając w to enum, niemożna mieć wartości zmiennych, czy też zakresu wartości
Jeżeli zmienna w warunku switch'a pasuje do jakiejś stałej wartości case'a, wykonanie nastąpi od momentu dopasowania case'a i przejdzie przez całe wyrażenie switch'a, aż natrafi na break innymi słowy jeżeli nie ma w bloku case'a break'a to nie będzie to jedyny blok case'a jaki zostanie wykonany
default jest używany do przechwytywania wartości nie zamieszczonych w case'ach, zostanie on wykonany jeżeli zmienna nie znajdzie dopasowania w case'ach.
default blok może być umieszczony wszędzie w bloku switch'a, i jeśli ten blok nie zawiera break'a to kod będzie kontynuował wykonanie aż do zakończenia switch'a

Pętle (Loops)

Podstawowa pętla for zawiera trzy części: deklaracje, i/lub inicjalizacja, warunkową, i wyrażenie iteracyjne
Jeżeli zmienna jest oceniana lub też zwiększana lub zmniejszana w pętli for musi być zdeklarowana przed pętlą, lub też w części pętli przeznaczonej do deklaracji zmiennej.
Zmienna zdeklarowana w pętli lub przy deklaracji pętli nie będzie widoczna po za nią.
Można inicjalizować więcej niż jedna zmienną tego samego typu w pierwszej części pętli, każda inicjalizacja musi być oddzielona przecinkiem.
Pętla eachfor posiada dwie części, deklaracje i wyrażenie. Jest używana do przeglądania tablic i kolekcji
W pętli eachfor wyrażeniem jest tablica lub kolekcja którą chcemy przeglądać
W pętli eachfor deklaracja to inaczej zmienna która ma zasięg tylko w tym bloku, zmienna ta trzyma wartość danego elementu dla danej iteracji
Niemożna używać liczb lub też niczego innego co nie nie jest typu boolean dla konstrukcji if lub pętli. Niemożna np. powiedzieć że if(x) chyba, że x jest typu boolean
Pętla do-while pozwala wejść przynajmniej jeden raz, nawet jeżeli test warunku zwraca false

Komendy break and continue

Komenda break bez etykiety przerwie wykonywanie iteracji danej pętli, i uruchomienie pierwszej lini zaraz za pętlą
continue bez etykiety powtarza wykonanie danej iteracji od momentu wystąpienia w pętli oczywiście jeśli warunek pętli na to pozwala
break, continue z etykietą działają z tą samą zasadą z tym wyjątkiem, że odnoszą się do pętli oznaczonej tą etykietą

Obsługa wyjątków

Wyjątki dzieli się na dwie klasy : checked i unchecked
Wyjątki checked zaliczają się do tej klasy wszystkie podklasy klasy Exception, nie wliczając w to klas które dziedziczą po RuntimeException
Wyjątki należące do klasy checked podlegają obsłużeniu albo zdeklarowaniu takiej reguły; jakakolwiek metoda która może rzucić wyjątek należący do grupy checked (wliczając to metody które wykonują metody które mogą rzucić taki wyjątek) muszą zadeklarować taki wyjątek używając słowa kluczowego throws, lub też obsłużyć taki wyjątek odpowiednią konstrukcja try/catch
Podklasy klas Error or RuntimeException należą do grupy unchecked, więc kompilator nie wymusza ich deklarowania czy też obsługi. Można je deklarować lub też nie, kompilatorowi jest to bez różnicy, ale na ogól nie deklaruje się ani nie obsługuje się tej grupy wyjątków
Jeżeli używamy opcjonalnego bloku finally, blok ten zawsze będzie wykonywany, bez znaczenia czy wyjątek został zgłoszony w bloku try czy tez nie.
Jedynym sposobem żeby blok finally nie został wykonany jest wyłączenie JVM. To może nastąpić przez jeżeli kod z try lub catch wywoła metodę System.exit()
Blok finally również może zostać przerwany i nie oznacza to że wykona się on cały. Przerwanie może nastąpić np. jeżeli sam blok wywoła jakiś wyjątek lub też wywoła metodę System.exit()
Nie obsłużony prawidłowo wyjątek wyświetli stos wywołań, zaczynając od metody która wywołała wyjątek i kończąc na pierwszej metodzie która ma odpowiedni blok catch aby obsłużyć taki wyjątek, lub do wyłączenia JVM (co się zdarza jeżeli wyjątek dojdzie do metody main())
Można samemu definiować swoje wyjątki, przeważnie poprzez użycie dziedziczenia po klasie Exception, Twój wyjątek będzie wówczas należał do grupy checked i kompiler będzie wymuszał jego obsługe czy też deklarację.
Budując bloki catch należy pamiętać ze zaczyna się od najbardziej specyficznych kończąc na najbardziej ogólnych, ta kolejność musi być zachowana, Np. jeśli mamy do zdeklarowania dwa wyjątki IOException i Exception musimy IOException umieścić nad Exception w przeciwnym razie Exception będzie łapać wszystkie wyjątki jakie obsługuje klasa i jego podklasy, a że IOException jest jego podklasą umieszczenie go poniżej sprawia że nie będzie wywołany, kompilator zaś nie pozwala na deklarowanie wyjątków które nie mogą zostać wywołane
Pewne wyjątki są tworzone przez programistów, i jakieś przez JVM

Pewna część drzewa dla hierarchii dziedziczenia wyjątków

      java.lang.Throwable
              |
              |-- Error (unchecked)
              |    |
              |    |-- AssertionError
              |    |
              |    |--ThreadDeath
              |    |
              |    |--VirtualMachineError
              |        |
              |        |-- InternalError
              |        |
              |        |-- OutOfMemoryError
              |        |
              |        |-- StackOverflowError
              |        |
              |        |-- UnknownError
              |
              |-- Exception
                   |
                   |-- ClassNotFoundException
                   |
                   |-- CloneNotSupportedException
                   |
                   |-- IllegalAccessException
                   |
                   |-- InstantiationException
                   |
                   |-- InterruptedException
                   |
                   |-- NoSuchFieldException
                   |
                   |-- NoSuchMethodException
                   |
                   |-- RuntimeException (unchecked)
                   |     |
                   |     |-- ArithmeticException
                   |     |
                   |     |-- ArrayStoreException
                   |     |
                   |     |-- ClassCastException
                   |     |
                   |     |-- EnumConstantNotPresentException
                   |     |
                   |     |-- IllegalArgumentException
                   |     |     |
                   |     |     |-- IllegalThreadStateException
                   |     |     |
                   |     |     |-- NumberFormatException
                   |     |
                   |     |-- IllegalMonitorStateException
                   |     |
                   |     |-- IllegalStateException
                   |     |
                   |     |-- IndexOutOfBoundsException
                   |     |     |
                   |     |     |-- ArrayIndexOutOfBoundsException
                   |     |     |
                   |     |     |-- StringIndexOutOfBoundsException
                   |     |
                   |     |-- NegativeArraySizeException
                   |     |
                   |     |-- NullPointerException
                   |     |
                   |     |-- SecurityException
                   |     |
                   |     |-- TypeNotPresentException
                   |     |
                   |     |-- UnsupportedOperationException                    
                   |
                   |-- java.io.IOException

Mechanizm Asercji

Asercja daje nam możliwość testowania naszych założeń podczas tworzenia kodu
Asercja zazwyczaj jest włączona podczas testowania, ale wyłączona podczas wdrażania aplikacji
Od Javy 1.4 można używać słowa kluczowego assert, Jeżeli użyjemy assert dla nazwy zmiennej lub metody musimy skompilować plik używając komendy -source 1.3 dla javac
Asercja jest wyłączona domyślnie podczas wykonywania. Aby włączyć używa się flagi w linii komend -ea lub -enableassertions
Selektywnie wyłączenie asercji wykonuje się poprzez użycie flagi -da lub -disableassertions
Jeżeli użyjemy tych flag bez żadnych argumentów, to wyłączamy lub włączamy asercje ogólnie, można łączyć włączniki aby mieć asercje dla wybranych klas lub pakietów albo żeby nie mieć
Można włączać i wyłączać asercje na wybranych klasach używając następującego polecenia:
```
   javac -ea -da:MyClass TestClass
```
Można również włączać i wyłączać asercje dla pakietów, pakiet po pakiecie, jakikolwiek pakiet zdefiniujemy jego pod pakiety również są liczone
Nie należy używać asercji do sprawdzania argumentów metod publicznych.
Nie należy używać asercji gdzie może spowodować tak zwany side effects. Asercja niema gwarancji wywołania, a my zapewne nie chcemy zachowania zależnego od tego czy asercja jest włączona czy też nie, przykład side effect
1. void process(int index) {
2. assert(index++ > 0); /* side effect */
3. /* ... */
4. }
5. // rozwiązanie
6. void process(int index) {
7. assert(index > 0); /* no side effect */
8. ++index;
9. /* ... */
10. }
```
  void process(int index) {
     assert(index++ > 0); /* side effect */
     /* ... */
  }
  // rozwiązanie 
  void process(int index) {
     assert(index > 0); /* no side effect */
     ++index;
     /* ... */
  }
```
Można używać asercji, nawet dla metod publicznych, do sprawdzania czy dany blok nigdy nie będzie wykonywany poprzez np. assert false; dla kodu który nigdy nie powinien zostać wykonany, więc jeśli dany kod zostanie wykonany zostanie rzucony natychmiast wyjątek a dokładniej błąd java.lang.AssertionError