Kurs Java krok po kroku¶

System operacyjny¶

Ponieważ programy w języku Java kompilowane są do kodu pośrednioego a następnie uruchamiane na wirtualnej maszynie, to programowanie w tej technologii jest tak samo wygodne na dowolnym systemie operacyjnym. Z racji swojej popularności przykłady będą jednak obrazowane na systemie operacyjnym Windows 7 (identyczne kroki należy podejmować w przypadku systemów Windows XP, czy Windows 8).

Java Development Kit¶

Elementem niezbędnym do kompilowania kodów źródłowych napisanych w języku Java jest zestaw narzędzi o nazwie Java Development Kit. Obecnie obowiązującą wersją konsumencką jest Java 7, jednak dla deweloperów dostępna jest już wersja 8, która wprowadza znaczące usprawnienia i to z niej będziemy korzystali.

Ze strony Oracle należy pobrać najnowszą dostępną wersję JDK w wersji odpowiedniej dla naszego systemu operacyjnego (32 lub 64 bit) oraz zainstalować ją w dowolnym miejscu na swoim komputerze.

Środowisko programistyczne (IDE)¶

Kolejnym narzędziem, które będzie wykorzystywane w trakcie kursu jest środowisko programistyczne eclipse. Na rynku istnieją także inne IDE takie jak Netbeans oraz Intellij IDEA (szczególnie popularne w zastosowaniach komercyjnych), jednak to eclipse jest najpopularniejsze, a jednocześnie proste w obsłudze i z dużymi możliwościami rozbudowy oraz co ważne - całkowicie bezpłatne.

Ponieważ w dalszej częściu kursu będziemy tworzyli aplikacje z graficznym interfejsem użytkownika, zalecamy pobrać wcześniej przygotowane środowisko eclipse wyposażone w niezbędne wtyczki. Całość można pobrać ze strony eFXclipse w postaci archiwum zip, a następnie wypakować je w dowolnym miejscu na komputerze.

JavaFX Scene Builder¶

Rekomendowaną przez firmę Oracle technologią do tworzenia graficznego interfejsu użytkownika (GUI) aplikacji pisanych w Javie jest obecnie JavaFX. Powstało w tym celu narzędzie, które znacznie ułatwia cały proces i pozwala stworzyć interfejs za pomocą przyjaznego mechanizmu drag&drop.

Narzędzie JavaFX Scene Builder w wersji 2.0 można pobrać ze strony Oracle.

Rozwiązywanie problemów¶

1. Sprawdzenie wersji systemu operacyjnego

W celu sprawdzenia wersji systemu operacyjnego kliknij prawym przyciskiem myszy na opcji “Komputer” i wybierz właściwości. Wśród informacji znajdziesz także wersję systemu operacyjnego (32 lub 64 bit)

Wszystkie wcześniej wspomniane narzędzia należy zainstalować zgodnie z wersją swojego systemu operacyjnego.

2. Konfiguracja Javy 8 w przypadku kilku jej wersji na komputerze.

W przypadku, gdy na komputerze było wcześniej zainstalowanych kilka wersji Javy, eclipse może domyślnie korzystać z jej starszej wersji (np. 7), co na późniejszym etapie uniemożliwi nam tworzenie aplikacji z graficznym interfejsem użytkownika w Javie FX. W celu sprawdzenia i skonfigurowania odpowiedniej wersji Javy w eclipse należy przejść do opcji Window -> Preferences -> Installed JREs.

Jako domyślne środowisko uruchomieniowe powinno być to oznaczone jako 1.8.0 (z ewentualnym dopiskiem o wersji aktualizacji). Jeżeli tak nie jest należy wybrać opcję Add -> Standard VM a następnie wskazać główny folder zainstalowanego pakietu JDK w sekcji JRE home.

Powyżej widać, że skonfigurowana jest zarówno Java 7 jak i 8, ale wersja 8 ustawiona jest jako domyślna

3. Eclipse po uruchomieniu pokazuje błąd związany z wtyczką Mercurial (system kontroli wersji).

Błąd należy zignorować, nie powinien pojawiać się przy kolejnych uruchomieniach środowiska.

Eclipse IDE¶

Eclipse to najpopularniejsze środowisko programistyczne wśród programistów Java. Jego głównymi zaletami z punktu widzenia osoby początkującej jest wykrywanie błędów w trakcie pisania kodu a także podpowiadanie składni wraz z możliwością generowania i prostej modyfikacji (refaktoryzacji) kodu źródłowego. Wszystko to składa się przede wszystkim na znaczną oszczędność czasu.

Przy pierwszym uruchomieniu środowiska zostaniemy zapytani o wskazanie folderu “workspace” - jest to folder, w którym przechowywane będą tworzone przez nas projekty. Zalecamy zostawić tę lokalizację domyślną.

Na powyższym zrzucie ekranu widać domyślny widok, który zastaniemy po uruchomieniu środowiska eclipse. Można w nim wyróżnić 4 główne obszary:

1. Package Explorer - w tym miejscu będziemy widzieli wszystkie projekty, które zapisane są w folderze workspace oraz ich strukturę w postaci rozwijanego drzewa
2. Obszar oznaczony numerem 2 to główna część robocza - w tym miejscu będziemy edytowali kod źródłowy aplikacji
3. Outline - to skrótowy podgląd danego pliku i elementów w nim zawartych (zmienne, metody/funkcje)
4. W dolnej części ekranu znajduje się kilka zakładek. Najważniejsza z nich to Problems, która pokazuje wszelkie błędy i ostrzeżenia występujące w kodzie źródłowym. W tym miejscu zobaczymy także dodatkową zakładkę Console z wydrukami generowanymi przez nasze aplikacje.

Pierwszy Projekt¶

W celu utworzenia nowego projektu wybieramy opcję File -> New -> Java Project

Wpisujemy dowolną nazwę projektu w polu Project name a także wybieramy wersję maszyny wirtualnej (JRE), na jakiej ma być uruchomiony nasz program (domyślnie JavaSE-1.8). Klikamy Finish.

W obszarze Project Explorer pojawi się nowo utworzony projekt:

Widzimy tu folder src, w którym umieszczane będą pliki z kodem źródłowym, a także dołączoną wirtualną maszynę, na której nasz projekt będzie uruchamiany.

Teraz należy utworzyć plik, w którym będziemy edytowali kod źródłowy. W dalszej częściu kursu będziemy mówili krótko o tworzeniu nowej klasy. Klasa jest pojęciem związanym z programowaniem obiektowym, które będzie głównym zagadnieniem kolejnej lekcji, na chwilę obecną przyjmijmy po prostu, że w klasie umieszczamy kod naszego programu.

Kliknij prawym przyciskiem na folderze src i wybierz opcję New -> Class. Można także posłużyć się wygodnym skrótem i skorzystać z przycisku z symbolem C, który znajdziemy na górnym pasku nawigacyjnym.

W kreatorze klasy wymagane jest podanie jedynie nazwy klasy. My jednak zaznaczymy także opcję przy public static void main(String[] args).

W naszym przypadku nazwą klasy jest FirstClass.

W utworzonej przez nas klasie został wygenerowany następujący kod źródłowy, do którego dopisaliśmy także dodatkowy wiersz System.out.print(“Witaj Świecie!”); :

plik FirstClass.java

1
2
3
4
5
6
7
8

public class FirstClass {

  public static void main(String[] args) {
    // TODO Auto-generated method stub
    System.out.print("Witaj Świecie!");
  }

}

W linii 1 widzimy definicję klasy. Klasę definiujemy za pomocą słowa kluczowego class, po którym następuje jej nazwa. Eclipse automatycznie oznacza ją jako publiczną za pomocą słowa kluczowego public, co najprościej można wytłumaczyć jako możliwość jej wykorzystania z dowolnego miejsca w naszym projekcie.

W wierszu 3 widzimy zapis public static void main(String[] args), czyli publiczną, statyczną metodę o nazwie main, która nie zwraca żadnego wyniku (void). Element umieszczony w nawiasie, czyli String[] args to argument metody main w postaci tablicy - więcej na ten temat powiemy w dalszej części lekcji.

Zauważ, że zarówno definicja klasy jak i metody rozpoczyna się i kończy nawiasami klamrowymi. Nawiasy klamrowe znacznie podnoszą czytelność kodu, szczególnie, gdy klasa składa się z kilkuset, czy nawet kilku tysięcy wierszy.

W metodzie main znajduje się jeden wiersz komentarza poprzedzony znakiem podwójnego ukośnika.

Po komentarzu dopisaliśmy także linijkę o treści System.out.print(“Witaj Świecie”);, która wydrukuje na ekranie tekst podany w nawiasie, czyli Witaj Świecie.

W celu uruchomienia programu wybierz z górnego paska nawigacyjnego charakterystyczny przycisk z symbolem strzałki (Run) lub po prostu użyj skrótu klawiaturowego Ctrl+F11.

W tym momencie w dolnej części eclipse powinno się pojawić okno konsoli (Console) z wydrukiem naszego tekstu.

Typy danych¶

W Javie tak jak w praktycznie każdym języku programowania istnieją różne typy danych. Typ danych to opis tego co reprezentuje dana wartość. Z powodu budowy komputera rozróżnia się liczby całkowite, liczby zmiennoprzecinkowe, znaki, ciągi znaków.

• boolean - typ logiczny. Może przyjmować jedynie dwie wartości - true (prawda) lub false (fałsz).
• byte, short, int, long - typy całkowitoliczbowe. Różnią się zakresem wielkości liczby jakie mogą przechowywać (od najmniejszego do największego) - np. 1, 5, 10, 3456.
• float, double - typy zmiennoprzecinkowe o różnym zakresie (double może przechowywać większe liczby). Separatorem dziesiętnym jest kropka, np. 3.14, 276.24563.
• char - typ znakowy, reprezentuje pojedyncze litery lub znaki. Wartości tego typu umieszczamy pomiędzy znakami pojedynczego cudzysłowu, np. ‘a’, ‘&’.
• String - (pisany z wielkie litery) - specjalny typ, który służy do przechowywania ciągów znaków. Ciągi znaków zapisujemy pomiędzy podwójnymi cudzysłowami, np. “Ania”, “Jakiś dowolny tekst”.

Ćwiczenie (5 min)

Napisz program, który wydrukuje na ekranie następujące wartości (wykorzystaj różne typy danych):

245
123.456
a
Java jest cool

plik DataTypes.java

1
2
3
4
5
6
7
8

public class FirstClass {
  public static void main(String[] args) {
    System.out.println(245);
    System.out.println(123.456);
    System.out.println('a');
    System.out.println("Java jest cool");
  }
}

Zmienne¶

Drukowanie danych, na których nie możemy wykonywać żadnych działań, czy po prostu zapamiętać w pamięci komputera nie byłoby zbyt użyteczne. Na szczęście w Javie możemy tworzyć tzw. zmienne, czyli takie elementy, które pozwalają na przechowywanie wartości różnych typów danych. Java w odróżnieniu od np. PHP jest językiem statycznie typowanym co oznacza, że zmienna musi mieć określony typ. Jeżeli chcesz przechowywać w niej wartość zmiennoprzecinkową, to nie możesz jej zadeklarować jako int, ponieważ spowoduje to błąd kompilacji.

Tworzenie zmiennej możemy podzielić na dwa etapy:

• deklarację - w tym momencie następuje zaalokowanie pamięci w komputerze
• inicjalizację (inicjację) - w tym momencie następuje przypisanie konkretnej wartości do zmiennej

Dwa wyżej wspomniane etapy mogą być od siebie oddzielone lub też można je połączyć ze sobą.

plik Variables.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public class Variables {
  public static void main(String[] args) {
    // deklaracja zmiennych różnego typu
    int x;
    double num;
    char letter;
    String napis;

    // inicjalizacja zmiennych
    x = 5;
    num = 12.67;
    letter = 'b';
    napis = "To może być bardzo długie zdanie";

    // deklaracja połączona z inicjalizacją
    int y = 15;
    String zdanie = "To jest przykładowe zdanie";
  }
}

Ćwiczenie (5 min)

Napisz program podobny do tego z poprzedniego zadania - wydrukuj na ekranie kilka wartości różnego typu, ale tym razem skorzystaj także ze zmiennych.

plik DataTypesVars.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class DataTypesVars {
  public static void main(String[] args) {
    int num1 = 123;
    double num2 = 567.123;
    char b = 'b';
    String name = "Jan Kowalski";

    System.out.println(num1);
    System.out.println(num2);
    System.out.println(b);
    System.out.println(name);
  }
}

Operacje arytmetyczne i logiczne¶

Jednymi z najważniejszych elementów w jakich wykorzystujemy komputery są obliczenia. Nie zawsze muszą to być skomplikowane rachunki matematyczne - czasami chcemy coś po prostu przesunąć o 1 piksel w prawo na ekranie (np. w grach), a innym razem zwiększyć wiek użytkownika o 1, gdy ma urodziny.

W języku Java znajdziemy wszystkie najpopularniejsze operatory arytmetyczno logiczne:

• +, - - dodawanie i odejmowanie liczb
• *, / - mnożenie i dzielenie całkowite liczb
• % - dzielenie modulo (reszta z dzielenia)
• && - koniunkcja logiczna. Tylko PRAWDA && PRAWDA da w wyniku PRAWDA
• || - alternatywa logiczna. Co najmniej jedna składowa musi być PRAWDĄ, aby wynik całego wyrażenia był prawdą. PRAWDA||PRAWDA lub PRAWDA||FAŁSZ lub FAŁSZ||PRAWDA ale nie FAŁSZ||FAŁSZ
• >, >=, <, <= - porównania. Większe, większe lub równe, mniejsze, mniejsze lub równe.
• == - porównanie równości

Wyniki wyrażeń arytmetyczno logicznych mogą być obliczane na podstawie zmiennych lub wartości, a także przypisywane do innych zmiennych.

plik Arithmetic.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Arithmetic {
  public static void main(String[] args) {
    int num1 = 5;
    int num2 = 3;
    //jaki jest wynik działania num1*num2 ?
    int num3 = num1 * num2;
    System.out.println(num3);

    //czy zmienna num1 jest większa od 3 ?
    boolean validate = num1 > 3;
    System.out.println(validate);
  }
}

Znak dodawania (+) ma również specjalne zastosowanie w przypadku ciągów znaków (typ String). Powoduje on złączenie (konkatenację) dwóch ciągów znaków i utworzenie na ich podstawie nowego napisu.

String napis = "Jan" + "Kowalski";

Ćwiczenie (10 min) Napisz prosty kalkulator. Zadeklaruj i zainicjuj dwie liczby typu zmiennoprzecinkowego a następnie wyświetl na ekranie wynik ich dodawania, odejmowania, mnożenia i dzielenia. Dodatkowo wyświetl na ekranie, czy pierwsza z liczb jest większa od drugiej, a także, czy ich iloczyn jest większy od 100. Przykładowy wydruk programu:

a + b = 28.3
a - b = 18.7
a * b = 112.8
a / b = 4.895833333333334
A > B ?true
A * B > 100 ? true

plik SimpleCalculator.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class SimpleCalculator {
  public static void main(String[] args) {
    double a = 23.5;
    double b = 4.8;

    System.out.println("a + b = " + (a + b));
    System.out.println("a - b = " + (a - b));
    System.out.println("a * b = " + (a * b));
    System.out.println("a / b = " + (a / b));
    System.out.println("A > B ?" + (a > b));
    System.out.println("A * B > 100 ? " + (a*b > 100));
  }
}

Zauważ, że w powyższym przykładzie konkatenacji a nawet obliczeń dokonujemy bezpośrednio w metodzie drukującej wynik na ekranie. Warto zwrócić także uwagę na to, że wartość typu String możemy łączyć z wartościami innego typu i zostaną one automatycznie dołączone do naszego napisu. Jeżeli wykorzystałeś dodatkowe zmienne do przechowywania wyników poszczególnych działań - nie jest to błędem.

Tablice jednowymiarowe¶

Zmienne nadają się świetnie do przechowywania pojedynczych wartości, jednak jeżeli w swoim programie posiadasz pewien zbiór danych, niezbędne będzie zastosowanie czegoś bardziej wygodnego. W końcu zapisywanie 100 liczb w postaci:

int x1 = 1;
int x2 = 2;
int x3 = 3;
//itd.

nie byłoby zbyt wygodne, prawda? Podstawowym elementem, który pozwala rozwiązać ten problem w programowaniu są tablice.

Deklaracja i inicjalizacja tablic jest bardzo podobna do zwykłych zmiennych:

1
2

int[] tab = new int[5];
String[] words = new String[10];

Powyżej zadeklarowano i utworzono tablicę 5 liczb całkowitych typu int, która może przechowywać 5 wartości oraz tablicę typu String, która może przechowywać 10 napisów.

W przypadku, gdy z góry znasz wartości, którymi chcesz uzupełnić tablicę, istnieje szybki sposób na jej inicjalizację poprzez wymienienie wszystkich wartości w trakcie tworzenia tablicy:

int[] numbers = new int[]{1, 2, 3, 4, 5};

Zauważ, że w takim przypadku nie jest konieczne określanie rozmiaru tablicy w nawiasach kwadratowych, ponieważ maszyna wirtualna wywnioskuje to sama na podstawie ilości podanych elementów.

W wielu przypadkach tablica będzie tworzona na podstawie rozmiaru, który użytkownik wprowadzi np. z klawiatury i nie będziemy go znali w dalszej części kodu. W takiej sytuacji możemy jednak skorzystać z wartości length, którą posiada każda tablica niezależnie od tego jakiego jest typu. Poniżej przedstawiony jest kod tablicy liczb całkowitych o rozmiarze 5, jednak w przyszłości nauczymy się odbierać dane od użytkownika z klawiatury i wartość ta może być wcześniej nieznana. W takiej sytuacji w 2 wierszu możemy pobrać rozmiar tablicy poprzez właściwość tab.length.

int[] tab = new int[5];
int size = tab.length;
System.out.print(size);

W celu przypisania lub odwołania się do poszczególnych komórek takich tablic należy odwołać się do nich poprzez indeksy:

plik Tabs.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Tabs {
    public static void main(String[] args) {
        int[] tab = new int[5];
        String[] words = new String[10];

        // tablice posiadają indeksy numerowane od 0
        tab[0] = 1;
        tab[1] = 2;

        // ale elementów nie musimy uzupełniać w określonym porządku
        words[0] = "Ala";
        words[3] = "kot";

        System.out.println("Pierwszy element tablicy tab[] = " + tab[0]);
        System.out.println("Czwarty element tablicy words[] = " + words[3]);
    }
}

Rozmiaru tablic niestety nie da się zmienić, więc jeżeli uznasz, że zabrakło Ci w niej miejsca, będziesz musiał utworzyć nową, większą tablicę.

Ćwiczenie (10 min)

Napisz program, w którym utworzysz tablicę 10 losowo wybranych przez siebie liczb zmiennoprzecinkowych. Wydrukuj na ekranie:

• wszystkie wartości,
• sumę wartości zapisanych na pozycjach nieparzystych tablicy(pierwszy, trzeci, piąty ... element tablicy)
• ostatni element tablicy (wykorzystaj właściwość length)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class TabCalculator {
    public static void main(String[] args) {
        double[] nums = new double[] { 2.5, 15.7, 1024.6, 33, 56.82, 1.1,
                23.90, 999.25, 550.6, 15.7 };

        System.out.println("Elementy tablicy: ");
        System.out.println(nums[0] + " " + nums[1] + " " + nums[2] + " "
                + nums[3] + " " + nums[4] + " " + nums[5] + " " + nums[6] + " "
                + nums[7] + " " + nums[8] + " " + nums[9]);

        double sum = nums[0] + nums[2] + nums[4] + nums[6] + nums[8];
        System.out.println("Suma elementów na indeksach nieparzystych: " + sum);

        System.out.println("Ostatni element tablicy: " + nums[nums.length-1]);
    }
}

W ćwiczeniu można było napotkać na kilka problemów. Zarówno w pierwszym jak i drugim podpunkcie należy pamiętać o indeksowaniu tablic zaczynając od 0. Do nieparzystych elementów tablicy odwołujemy się poprzez parzyste indeksy (bo zaczynają się od 0). Z kolei w trzecim punkcie należy pamiętać o tym, że właściwość length zwraca rzeczywisty rozmiar tablicy, a ponieważ indeksy numerowane są od 0, to ostatnim indeksem, do którego możemy się odwołać jest length-1.

Tablice wielowymiarowe¶

Tablice jednowymiarowe znacząco usprawniają przechowywanie danych w naszej aplikacji, ponieważ nie musimy już deklarować dużej ilości zmiennych. Wyobraź sobie jednak sytuację, gdy tworzysz grę w okręty:

Możliwe, że przychodzi Ci teraz do głowy pomysł, aby wykorzystać w niej kilka tablic jednowymiarowych, które będą reprezentowały kolejne wiersze planszy. Słusznie, jednak w sytuacji, gdy będziemy chcieli utworzyć planszę o rozmiarze 20x20 komórek, niezbędne będzie zadeklarowanie 20 tablic, np.:

int[] w0 = new int[20];
int[] w1 = new int[20];
//...
int[] w19 = new int[20];

Przy tablicach jednowymiarowych stwierdziliśmy jednak, że tablica to taki typ danych, który pozwala przechowywać większe ilości wartości tego samego typu. Nic więc nie stoi na przeszkodzie, żeby w tablicy przechowywać inne tablice, a tym samym utworzyć tablicę wielowymiarową.

Tablicę taką najłatwiej wyobrazić sobie jako siatkę o rozmiarze x na y:

Zauważ kilka rzeczy:

• tablica wielowymiarowa nie musi mieć takiej samej liczby wierszy co kolumn
• poszczególne wiersze mogą przechowywać różne ilości elementów

Przykład:

plik MultiArray.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public class MultiArray {
    public static void main(String[] args) {
        // tablica liczb całkowitych o rozmiarze 2x2
        int[][] multiArray = new int[2][2];

        // tablica liczb zmiennoprzecinkowych, która składa się z tablic o
        // różnych rozmiarach
        double[][] multiArray2 = new double[3][];
        multiArray2[0] = new double[3];
        multiArray2[1] = new double[2];
        multiArray2[2] = new double[1];

        // W wyniku tablica multiArray2 ma następującą strukturę:
        /*
         * XXX
         * XX
         * X
         */

        //lub na konkretnych liczbach:
        int[][] multiArray3 = new int[3][];
        multiArray[0] = new int[]{0, 1, 2};
        multiArray[1] = new int[]{3, 4};
        multiArray[2] = new int[]{5};

        //co daje w wyniku:
        /*
         * 0 1 2
         * 3 4
         * 5
         */
    }
}

Ćwiczenie (10 min)

Napisz program, w którym utworzysz tablicę o rozmiarze NxN typu boolean (załóżmy maksymalny rozmiar jako 5x5). Wypełnij jej przekątną wartościami typu true a na końcu wyświetl wartość elementu przechowywanego w prawym dolnym wierzchołku tablicy. Przy wyświetlaniu wartości wykorzystaj właściwość length tak, aby po zmianie rozmiaru tablicy nie było konieczne modyfikowanie kodu wyświetlającego tę wartość.

plik Matrix.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class Matrix {
    public static void main(String[] args) {

        //rozmiar tablicy
        int n = 3;

        boolean[][] array = new boolean[n][n];

        //uzupełniamy przekątną
        array[0][0] = true;
        array[1][1] = true;
        array[2][2] = true;

        /*
         * Wyświetlamy element w prawym dolnym krańcu tablicy
         * array[array.length-1] - indeks ostatniego wiersza
         * array[array.length - 1].length - 1 - indeks ostatniej kolumny w ostatnim wierszu
         */
        System.out.println("Prawy dolny element: " + array[array.length - 1][array[array.length - 1].length - 1]);
    }
}

Dodatek 1 - praca z eclipse¶

Całkiem możliwe, że już na tym etapie zacząłeś zauważać, że pisanie powtarzającego się kodu (np. nazw zmiennych, czy powtarzanie co chwilę System.out.print()) potrafi doprowadzić do lekkiej frustracji i odbiera chęci do pisania kodu “bo przecież wiadomo jak to ma wyglądać”.

W tym miejscu pokażemy Ci kilka użytecznych skrótów, które w eclipse znacząco podnoszą efektywność pracy oraz oszczędzają Twój cenny czas.

CTRL + SPACJA¶

Skrót, który wykorzystuje się zdecydowanie najczęściej. Pozwala na autouzupełnianie kodu i wystarczy, że wpiszesz jedynie kilka pierwszych liter zmiennej, a reszta zostanie uzupełniona automatycznie.

Mając zmienną o długiej nazwie:

Wystarczy, że przy kolejnym użyciu wpiszesz fragment nazwy i wciśniesz Ctrl+Spacja, a długa nazwa zostanie uzupełniona:

W początkowej fazie nauki Javy równie często wykorzystuje się instrukcję System.out.println() - jej wpisywanie również można uprościć. Wystarczy, że wpiszesz syso i wciśniesz Ctrl+Spację, a reszta zostanie uzupełniona.

CTRL + 1¶

Skrót, który przydaje się szczególnie wtedy, gdy dużo pracujemy na klawiaturze i nie przepadamy za sięganiem po mysz. Jeżeli przykładowo widzisz ostrzeżenie (podkreślenie na żółto) wystarczy, że najedziesz w dany obszar kursorem i wciśniesz Ctrl+1 a eclipse podpowie Ci sugerowane rozwiązania.

W powyższym przykładzie widzimy ostrzeżenie, któe informuje nas o tym, że utworzyliśmy zmienną, której nigdzie nie wykorzystujemy - w podpowiedziach pojawia się m.in. możliwość jej usunięcia.

Alt + Shift + R¶

Jeżeli w swoim kodzie chcesz zmienić nazwę zmiennej lub zauważyłeś błąd typu literówka, to poprawienie tego może być problematyczne, ponieważ zmiennej tej prawdopodobnie używasz co najmniej w kilku innych miejscach. Wciskając skrót Ctrl+Shift+R na nazwie zmiennej, czy też nazwie klasy, możesz zmienić ich nazwę, a eclipse zadba o to, aby zaktualizować jej nazwę również we wszystkich innych jej wystąpieniach w kodzie źródłowym.

Dodatek 2 - wywołanie programu z argumentami¶

Wróćmy jeszcze na chwilę do metody main i jej argumentów. Programy napisane w Javie najczęściej są pakowane docelowo do jednego archiwum w postaci pliku .jar (Java ARchive). Program taki możemy uruchomić z wiersza poleceń z odpowiednimi argumentami w postaci listy oddzielonej spacjami. Argumenty te utworzą tablicę typu String, a następnie zostaną przekazane jako argument metody main() - to właśnie String[] args, który powtarza się za każdym razem.

Najczęściej argumenty wywołania są pomijane, jednak warto wiedzieć jak z nich korzystać. Utwórzmy zwykły pusty projekt z jedną klasą zawierającą metodę main():

Struktura projektu

plik ArgTest.java

1
2
3
4
5

public class ArgTest {
    public static void main(String[] args) {
        System.out.println("Witaj " + args[0]);
    }
}

Widzimy tutaj prosty przykład bardzo podobny do naszego pierwszego “Hello World” jednak tym razem wyświetlamy tekst “Witaj” połączony z pierwszym elementem tablicy args. W jaki sposób przekazać ten argument do metody main? Kliknij prawym przyciskiem myszy na projekcie, wybierz opcję Run As -> Run Configuration a następnie w zakładce Arguments podaj np. swoje imię:

Teraz wystarczy wybrać Apply oraz Run, a na ekranie zobaczymy, że argument został poprawnie przekazany:

Jeżeli chcesz przekazać większą ilość argumentów, wystarczy, że wymienisz je po spacji, a następnie odwołasz się do nich po odpowiednich indeksach w kodzie Javy, tj. args[0], args[1], args[2] itd - tak jak w przypadku każdej innej tablicy.

Klasy i obiekty¶

Ćwiczenie Wyobraź sobie, że tworzysz prostą aplikację do obsługi sklepu komputerowego. Najważniejsze będzie w niej zdecydowanie przechowywanie informacji o produktach. Wypisz kilka cech produktu, które Twoim zdaniem będą istotne z punktu widzenia użytkownika tej aplikacji(sprzedawcy).

Przykłady cech przydatnych

Nazwa produktu
Cena
Producent
Model / nazwa kodowa
Rok produkcji

Możliwe, że rzeczy, które wypisałeś są inne od pokazanych powyżej - to bardzo dobrze! Świadczyć to może o różnej wizji na aplikację. Na tę chwilę ograniczymy się do dwóch podstawowych informacji, czyli nazwy produktu oraz jego ceny. Te dwie podstawowe rzeczy na dobrą sprawę pozwolą nam znaleźć dowolny towar w bazie wszystkich produktów oraz dokonać sprzedaży na podstawie podanej ceny.

Ćwiczenie (5 min)

Napisz prosty program, w którym w zmiennych przechowasz informacje o 2 różnych produktach (np. Monitor Samsung Syncmaster za 700zł oraz Laptop HP Probook 450 za 3000zł). Wydrukuj następnie informacje o tych produktach na ekranie. Wykorzystaj różne typy danych do przechowywania nazw produktów a inne do przechowywania ceny.

Przypomnijmy, że najpierw należy utworzyć nowy projekt poprzez menu File -> New -> Java Project, a następnie w folderze src dodać nową klasę np. korzystając z przycisku ze znakiem C na górnej belce nawigacyjnej. Nazwa klasy powinna być identyczna z nazwą pliku (eclipse zadba o to automatycznie) - w naszym przypadku będzie to plik Shop.java.

plik Shop.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Shop {
    public static void main(String[] args) {
        String product1Name = "Samsung Syncmaster";
        double product1Price = 700.0;

        String product2Name = "HP Probook 450";
        double product2Price = 3000.0;

        System.out.println("Produkty w sklepie: ");
        System.out.println(product1Name + ":" + product1Price);
        System.out.println(product2Name + ": " + product2Price);
    }
}

Wszystko wygląda na pierwszy rzut oka w porządku, ale zastanów się teraz w jaki sposób zapisałbyś informację o kilkuset produktach w tym sklepie? Możliwe, że przychodzi Ci do głowy utworzenie tablic z imionami, nazwiskami itd. Nie jest to najgorszy pomysł, jednak ma jedną dużą wadę - dane nie są spójne i w żaden sposób ze sobą powiązane. Zmiana czegokolwiek, np dodanie 1 produktu, wiązałoby się z koniecznością aktualizacji innej tablicy z cenami, należałoby uważać na odwoływanie się do odpowiednich indeksów tablic itd.

Tutaj dochodzimy do sedna programowania obiektowego. Czy nie byłoby świetną sprawą możliwość utworzenia swojego typu danych “Product”, który moglibyśmy wykorzystywać tak jak wartości typu int, czy double? W Javie możemy zdefiniować swój typ, zwyczajnie tworząc nową klasę, a w niej definiując zmienne typów prostych (lub wcześniej utworzonych typów obiektowych).

plik Product.java

1
2
3
4

public class Product {
    String name;
    double price;
}

Struktura projektu eclipse:

Zauważ, że w klasie tej nie tworzymy po raz kolejny metody main - jest ona potrzebna tylko w jednej klasie w ramach całego projektu i to od niej rozpocznie się działanie programu. Pozostałe klasy będą miały natomiast za zadanie definicję nowego typu danych lub wydzielenie pewnych funkcjonalności (np. obliczeń, przetwarzania tekstu, pobierania danych z internetu itd.). Na podstawie dowolnej klasy możemy utworzyć obiekt. Obiekty zawsze będziemy tworzyli poprzez zapis new NazwaKlasy(); przekazując w nawiasie ewentualne parametry (o tym za chwilę).

plik Shop.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Shop {
    public static void main(String[] args) {
        Product product1 = new Product();
        product1.name = "Samsung Syncmaster";
        product1.price = 700.0;

        Product product2 = new Product();
        product2.name = "HP Probook 450";
        product2.price = 3000.0;

        System.out.println("Produkty w sklepie: ");
        System.out.println(product1.name + ":" + product1.price);
        System.out.println(product2.name + ": " + product2.price);
    }
}

Jak widzisz zmienne name i price z wcześniejszego kodu są teraz opakowane w obiekty typu Product. Do poszczególnych pól klasy odwołujemy się za pomocą operatora kropki, np. “product1.name”.

Na chwilę obecną może Ci się wydawać, że zrobiło się tylko więcej kodu, a program nadal robi to samo. Zwróć jednak uwagę, że dane są teraz bardziej spójne, a dzięki podejściu obiektowemu informacje o np. 100 produktach możemy przechowywać w tylko 1 tablicy typu Product[].

plik Shop.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Shop {
    public static void main(String[] args) {
        Product[] products = new Product[2];

        products[0] = new Product();
        products[0].name = "Samsung Syncmaster";
        products[0].price = 700.0;

        products[1] = new Product();
        products[1].name = "HP Probook 450";
        products[1].price = 3000.0;

        System.out.println("Produkty w sklepie: ");
        System.out.println(products[0].name + ":" + products[0].price);
        System.out.println(products[1].name + ": " + products[1].price);
    }
}

Ćwiczenie (10 min)

Wyobraź sobie, że tworzysz aplikację do diagnostyki komputerowej samochodów. Zacznij od utworzenia klasy Car przechowującej informacje o marce producenta, modelu, roku produkcji i mocy silnika. W drugiej klasie o nazwie CarDiagnostic utwórz dwa obiekty klasy Car i wyświetl informacje o samochodach na ekranie.

Struktura projektu:

plik Car.java

1
2
3
4
5
6

public class Car {
    String carBrand; // marka samochodu
    String model;
    int year; //rok produkcji
    int horsePower; // ilość koni mechanicznych
}

plik CarDiagnostic.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class CarDiagnostic {
    public static void main(String[] args) {
        Car audiA4 = new Car();
        audiA4.carBrand = "Audi";
        audiA4.model = "A4";
        audiA4.year = 2008;
        audiA4.horsePower = 170;

        Car vwGolf = new Car();
        vwGolf.carBrand = "Volkswagen";
        vwGolf.model = "Golf";
        vwGolf.year = 2010;
        vwGolf.horsePower = 130;

        System.out.println("Samochód 1: ");
        System.out.println(audiA4.carBrand + " " + audiA4.model
                + ", rok produkcji: " + audiA4.year + ", moc: "
                + audiA4.horsePower);

        System.out.println("Samochód 2: ");
        System.out.println(vwGolf.carBrand + " " + vwGolf.model
                + ", rok produkcji: " + vwGolf.year + ", moc: "
                + vwGolf.horsePower);
    }
}

Metody¶

Klasa Product potrafi już przechowywać informacje o nazwie i cenie produktu, jednak jak wspomnieliśmy w definicji klasy jest to także zbiór funkcjonalności. W programowaniu obiektowym funkcjonalności danej klasy realizuje się poprzez utworzenie metod. W naszym przykładzie funkcjonalnością może być na przykład zwrócenie przez obiekt klasy Product nazwy oraz ceny w czytelnej formie, dzięki czemu w metodzie println() nie będziemy musieli się odwoływać do poszczególnych pól.

plik Product.java

1
2
3
4
5
6
7
8

public class Product {
    String name;
    double price;

    String getProductInfo() {
        return name + ": " + price;
    }
}

W klasie Product utworzyliśmy metodę getProductInfo. Ponieważ zwraca ona opisową formę produktu musieliśmy zadeklarować jej typ jako String. Wynik metody należy zwrócić za pomocą słowa kluczowego return.

typ_zwracany nazwaMetody(opcjonalne_argumenty_metody) {
  //ciało metody między nawiasami klamrowymi
}

plik Shop.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Shop {
    public static void main(String[] args) {
        Product[] products = new Product[2];

        products[0] = new Product();
        products[0].name = "Samsung Syncmaster";
        products[0].price = 700.0;

        products[1] = new Product();
        products[1].name = "HP Probook 450";
        products[1].price = 3000.0;

        System.out.println("Produkty w sklepie: ");
        System.out.println(products[0].getProductInfo());
        System.out.println(products[1].getProductInfo());
    }
}

Do metod, podobnie jak do pól klasy odołujemy się za pomocą operatora kropki, jednak oprócz samej nazwy metody nie możemy zapomnieć o dodaniu na końcu okrągłych nawiasów.

Konstruktory¶

Ostatnią rzeczą, którą możemy uprościć w klasie Shop jest inicjalizacja zmiennych. W chwili obecnej w celu utworzenia jednego tylko obiektu potrzebujemy aż 3 linijek kodu - w przypadku tworzenia 100 obiektów, kod rozrasta się do 300 linii - jest to niedopuszczalne.

Tworzenie obiektów możemy jednak uprościć za pomocą specjalnych metod nazywanych konstruktorami.

plik Product.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class Product {
    String name;
    double price;

    //konstruktor przyjmujący 2 argumenty
    Product(String n, double p) {
        name = n;
        price = p;
    }

    String getProductInfo() {
        return name + ": " + price;
    }
}

Nasz konstruktor przyjmuje dwa argumenty - jeden typu String, a drugi typu double. Wartości przekazane jako argumenty konstruktora przypisujemy następnie do pól klasy, czyli name oraz price. Teraz możemy uprościć tworzenie obiektów w klasie Shop do tylko jednej linijki dla każdego z nich:

plik Shop.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Shop {
    public static void main(String[] args) {
        Product[] products = new Product[2];

        products[0] = new Product("Samsung Syncmaster", 700.0);

        products[1] = new Product("HP Probook 450", 3000.0);

        System.out.println("Produkty w sklepie: ");
        System.out.println(products[0].getProductInfo());
        System.out.println(products[1].getProductInfo());
    }
}

Ćwiczenie (10 min)

Rozwiń aplikację z poprzedniego ćwiczenia (diagnostyka sanmochodu) o następujące informacje. W klasie Car dodaj konstruktor pozwalający zainicjować wszystkie pola klasy oraz dwie metody: getInfo(), która zwróci opisową formę danego samochodu, a także upgreade(), która zwiększa moc silnika o tyle koni mechanicznych ile przekażemy jako jej parametr. Przetestuj nowe funkcjonalności w klasie CarDiagnostic.

plik Car.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Car {

    String carBrand; // marka samochodu
    String model;
    int year; //rok produkcji
    int horsePower; // ilość koni mechanicznych

    //konstruktor do zainicjowania wszystkich pól
    Car(String cb, String m, int y, int hp) {
        carBrand = cb;
        model = m;
        year = y;
        horsePower = hp;
    }

    //zwiększenie mocy silnika
    void upgreade(int hp) {
        horsePower = horsePower + hp;
    }

    //zwrócenie opisowej formy samochodu
    String getInfo() {
        return carBrand + " " + model + "; " + year + "; " + horsePower + "HP";
    }
}

plik CarDiagnostic.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class CarDiagnostic {
    public static void main(String[] args) {
        //utworzenie obiektów
        Car audiA4 = new Car("Audi", "A4", 2008, 170);
        Car vwGolf = new Car("Volkswagen", "Golf", 2010, 130);

        //tuning
        audiA4.upgreade(30);
        vwGolf.upgreade(20);

        //wydruk informacji
        System.out.println("Samochód 1: ");
        System.out.println(audiA4.getInfo());

        System.out.println("Samochód 2: ");
        System.out.println(vwGolf.getInfo());
    }
}

Przeciążanie metod i konstruktorów¶

Czasami może zdarzyć się sytuacja, w której nie będziemy mieli pełnych informacji o danym produkcie, który chcielibyśmy utworzyć. Przykładowo będziemy mieli jego nazwę, ale będziemy musieli jeszcze chwilę poczekać na ustalenie jej ceny w centrali. W takiej sytuacji możemy utworzyć kilka konstruktorów, które pozwolą nam zainicjować obiekt danej klasy. Gdy w klasie istnieje kilka konstruktorów lub metod o takiej samej nazwie, ale różniących się przyjmowanymi parametrami, to będziemy mówili o nich, że są dostępne w kilku przeciążonych wersjach.

plik Product.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class Product {
    String name;
    double price;

    //konstruktory
    Product(String n, double p) {
        name = n;
        price = p;
    }

    Product(String n) {
        name = n;
    }

    String getProductInfo() {
        return name + ": " + price;
    }
}

W powyższym przykładzie widzimy, że utworzyliśmy drugi konstruktor, który inicjuje jedynie nazwę produktu. Cena (price) przyjmie w takiej sytuacji wartość domyślną, którą dla typu double jest 0.0. W podobny sposób możemy przeciążać dowolne metody, które będą miały takie same nazwy, ale przyjmą różne parametry.

Ćwiczenie (5 min)

W programie do diagnostyki samochodu dopisz dodatkowy konstruktor pozwoli zainicjować jedynie markę i model samochodu, pozostawiając rok produkcji i moc silnika wartościami domyślnymi. W klasie CarDiagnostic utwórz za pomocą tego konstruktora nowy obiekt i wyświetl informacje o nim na ekranie.

plik Car.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class Car {

    String carBrand; // marka samochodu
    String model;
    int year; //rok produkcji
    int horsePower; // ilość koni mechanicznych

    Car(String cb, String m) {
        carBrand = cb;
        model = m;
    }

    Car(String cb, String m, int y, int hp) {
        carBrand = cb;
        model = m;
        year = y;
        horsePower = hp;
    }

    void upgreade(int hp) {
        horsePower = horsePower + hp;
    }

    String getInfo() {
        return carBrand + " " + model + "; " + year + "; " + horsePower + "HP";
    }
}

plik CarDiagnostic.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class CarDiagnostic {
    public static void main(String[] args) {
        Car audiA4 = new Car("Audi", "A4", 2008, 170);
        Car vwGolf = new Car("Volkswagen", "Golf", 2010, 130);
        Car opelCorsa = new Car("Opel", "Corsa");

        //tuning
        audiA4.upgreade(30);
        vwGolf.upgreade(20);

        System.out.println("Samochód 1: ");
        System.out.println(audiA4.getInfo());

        System.out.println("Samochód 2: ");
        System.out.println(vwGolf.getInfo());

        System.out.println("Samochód 3: ");
        System.out.println(opelCorsa.getInfo());
    }
}

Słowo kluczowe this¶

Zarówno aplikacja symulująca sklep z częściami komputerowymi jak i program symulujący diagnostykę samochodową posiadają już pewną bazową funkcjonalność. Czytelność kodu w kilku miejscach można jednak poprawić.

Dobrą praktyką jest stosowanie wszędzie tam gdzie to możliwe opisowych nazw zmiennych, jednak w naszym przypadku ciężko wymyślić zamiennik dla “name”, czy “year” (stosowanie polskich nazw również nie jest dobrą praktyką). Na szczęście przewidziano również taką funkcjonalność języka i nazwy argumentów metod, czy konstruktorów mogą być identyczne z nazwami pól klasy, te drugie należy jednak poprzedzić dodatkowo słowem kluczowym this.

Tym sposobem nasza poprawiona klasa Product prezentuje się jak poniżej.

plik Product.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class Product {
    String name;
    double price;

    //konstruktory
    Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    Product(String name) {
        this.name = name;
    }

    String getProductInfo() {
        return name + ": " + price;
    }
}

Zapis this.name = name należy rozumieć jako “przypisz do pola tej (this) klasy o nazwie name wartość argumentu konstruktora o nazwie name”.

Słowo kluczowe this ma także drugie zastosowanie, które pozwala wywoływać przeciążoną wersję konstruktora w innym konstruktorze. Ma to takie zastosowanie, że pozwala zaoszczędzić powtarzalnego kodu w przypadku, gdy w klasie zdefiniujemy np. 4 podobne konstruktory, w których spora część kodu źródłowego się powtarza. U nas nie zaoszczędzimy specjalnie kodu, jednak wygląda to następująco:

plik Product.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class Product {
    String name;
    double price;

    //konstruktory
    Product(String name, double price) {
        this(name); //wywołanie innego konstruktora
        this.price = price;
    }

    Product(String name) {
        this.name = name;
    }

    String getProductInfo() {
        return name + ": " + price;
    }
}

Jak widzisz w konstruktorze przyjmującym dwa argumenty wywołujemy w pierwszej kolejności konstruktor z jednym argumentem poprzez this(name). W ten sposób zainicjowaliśmy pole name, a następnie możemy zainicjować cenę, czyli pole price.

Ćwiczenie (5 min)

Popraw klasę Car z poprzedniego zadania w taki sposób, aby nazwy argumentów konstruktorów miały bardziej znaczące nazwy (najlepiej takie same jak nazwy pól klasy). Wykorzystaj także słowo kluczowe this w celu wywołania w jednym z konstruktorów drugiego konstruktora i zaoszczędzić tym samym powtarzalnego kodu.

plik Car.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class Car {

    String carBrand; // marka samochodu
    String model;
    int year; //rok produkcji
    int horsePower; // ilość koni mechanicznych

    Car(String carBrand, String model) {
        this.carBrand = carBrand;
        this.model = model;
    }

    Car(String carBrand, String model, int year, int horsePower) {
        this(carBrand, model);
        this.year = year;
        this.horsePower = horsePower;
    }

    void upgreade(int hp) {
        horsePower = horsePower + hp;
    }

    String getInfo() {
        return carBrand + " " + model + "; " + year + "; " + horsePower + "HP";
    }
}

Pakiety i modyfikatory dostępu¶

Istotnym elementem, który pomaga w organizacji większych projektów jest podział klas i plików źródłowych na pakiety. Pakiety są niczym innym jak dodatkowymi folderami, które pozwalają grupować wspólnie klasy, które odpowiadają za podobne funkcjonalności. W celu utworzenia pakietu wybieramy po prostu New -> Package. Nazewnictwo pakietów zazwyczaj odzwierciedla nazwę domeny autorów, czyli np. pl.org.ceo.kursjava.pakiet1 - gdzie pakiet1 powinien być jakąś znaczącą nazwą, kursjava nazwą projektu, a pl.org.ceo to odwrócona nazwa domeny Centrum Edukacji Obywatelskiej.

Gdy w kodzie projektu CarDiagnoser podzielimy klasy na dwa pakiety (przeciągnij klasy do odpowiednich pakietów):

zauważamy błąd w klasie CarDiagnostic.

plik CarDiagnostic.java

1
2
3
4
5
6

package pl.org.ceo.cardiagnoser.app;
import pl.org.ceo.cardiagnoser.data.Car;

public class CarDiagnostic {
//kod bez zmian
}

Pierwszą rzeczą, na którą warto zwrócić uwagę są dwie linie kodu, które eclipse dodał automatycznie:

• package oznacza pakiet, w którym umieszczona jest dana klasa
• import jest dyrektywą niezbędną w przypadku, gdy korzystamy z klas umieszczonych w innych pakietach. W naszym przypadku musieliśmy zaimportować klasę Car.

Błąd w klasie polega na tym, że konstruktor jest niewidoczny:

Można sobie zadać pytanie, ale jak to niewidoczny, skoro przed chwilą z niego korzystaliśmy? Jest to spowodowane różnymi zasięgami widoczności pól metod i konstruktorów. W Javie istnieją cztery możliwe zasięgi:

• default - domyślny, czyli pakietowy zasięg dostępu
• public - publiczny, można się odwoływać z dowolnego miejsca w pakiecie i poza nim
• protected - zasięg ograniczony do danego pakietu
• private - zasięg tylko w ramach jednej klasy. Do tak oznaczonych pól, metod i konstruktorów nie można odwołać się nawet z klas w tym samym pakiecie

Ponieważ klasy Car i CarDiagnoser znajdują się w różnych pakietach odpowiednie konstruktory i pola musimy oznaczyć jako publiczne:

plik Car.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package pl.org.ceo.cardiagnoser.data;

public class Car {

    public String carBrand; // marka samochodu
    public String model;
    public int year; //rok produkcji
    public int horsePower; // ilość koni mechanicznych

    public Car(String carBrand, String model) {
        this.carBrand = carBrand;
        this.model = model;
    }

    public Car(String carBrand, String model, int year, int horsePower) {
        this(carBrand, model);
        this.year = year;
        this.horsePower = horsePower;
    }

    public void upgreade(int hp) {
        horsePower = horsePower + hp;
    }

    public String getInfo() {
        return carBrand + " " + model + "; " + year + "; " + horsePower + "HP";
    }
}

Ćwiczenie podsumowujące (20 minut)¶

Napisz prosty kalkulator, który będzie zgodny z podejściem programowania obiektowego. Niech składa się on z dwóch klas:

• Calculator - klasa, w której zdefiniujesz metody add(), subtract(), multiply() oraz divide() odpowiedzialne odpowiednio za dodawanie, odejmowanie, mnożenie i dzielenie. Każda z metod powinna przyjmować dwa argumenty typu double, na których wykonuje obliczenie i zwraca w wynik.
• Main - klasa z metodą main(), w której należy przetestować działanie poszczególnych metod. Argumentami metod powinny być dwie wcześniej zadeklarowane zmienne.

plik Calculator.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Calculator {
    double add(double a, double b) {
        return a + b;
    }

    double subtract(double a, double b) {
        return a - b;
    }

    double multiply(double a, double b) {
        return a * b;
    }

    double divide(double a, double b) {
        return a / b;
    }
}

plik Calculator.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Main {
    public static void main(String[] args) {
        double a = 25;
        double b = 5;
        Calculator calc = new Calculator();

        System.out.println(a + "+" + b + " = " + calc.add(a, b));
        System.out.println(a + "-" + b + " = " + calc.subtract(a, b));
        System.out.println(a + "*" + b + " = " + calc.multiply(a, b));
        System.out.println(a + "/" + b + " = " + calc.divide(a, b));
    }
}

Struktury sterujące¶

Struktury sterujące to specjalne elementy języka, które pozwalają na wybór odpowiedniej ścieżki w aplikacji. Przykładowo jeżeli chcemy porównać ze sobą dwie liczby całkowite, musimy sprawdzić warunek, a następnie podjąć decyzję, co w wyniku tego porównania wyświetlić na ekranie:

Co więcej warunki takie mogą być bardziej rozgałęzione, czyli np. możemy sprawdzić, czy wczytana liczba jest większa, mniejsza, czy równa 0 itd.

Instrukcja if else¶

Podstawową strukturą sterującą w większości języków programowania, w tym także w Javie jest instrukcja if. W swojej najprostszej formie odpowiada ona sytuacji, którą widzisz na wcześniejszym diagramie - pozwala sprawdzić prosty warunek, który w wyniku powinien zwrócić wartość typu boolean, czyli true lub false i na podstawie tego zadecydować, co nasz program zrobi dalej.

Ogólna konstrukcja bloku if wygląda następująco:

1
2
3
4
5

if(warunek) {
  //działania, gdy warunek zwraca true
} else {
  //działania, gdy warunek zwraca false
}

Ćwiczenie (5 minut)

Zaimplementuj program, który służy do porównywania dwóch liczb całkowitych zgodny z przedstawionym wyżej diagramem. Wyświetl na ekranie komunikat o tym, która liczba jest większa od której. Liczby wczytaj do wcześniej zadeklarowanych zmiennych.

plik Main.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 11;

        if (a > b) {
            System.out.println("A jest większe od B " + a + " > " + b);
        } else {
            System.out.println("B jest większe od A " + b + " > " + a);
        }
    }
}

W nawiasie występującym po instrukcji if musi znajdować się wyrażenie, które w wyniku zwraca true lub false. Nie musi to być jedynie porównanie dwóch liczb tak jak w powyższym przykładzie, ale także bardziej złożony warunek np. wykorzystujący operatory logiczne && lub ||.

W przypadku kodu tak prostego jak ten powyżej, gdzie w bloku if oraz else pomiędzy nawiasami klamrowymi znajduje się jedynie jedna instrukcja (np. System.out.print()), nawiasy klamrowe można pominąć, czyli uprościć nasz kod do postaci:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 11;

        if (a > b)
            System.out.println("A jest większe od B " + a + " > " + b);
        else
            System.out.println("B jest większe od A " + b + " > " + a);
    }
}

W praktyce jednak stosowanie klamer podnosi czytelność kodu, więc warto je stosować nawet w najbardziej trywialnych sytuacjach.

Możliwe, że zauważyłeś, że powyższy kod ma jedną poważną wadę. W przypadku, gdy liczby a i b będą identyczne, to ich porównanie za pomocą znaku ostrej nierówności zwróci false. W takiej sytuacji wyświetlony zostanie komunikat o tym, że liczba B jest większa od A, a to oczywiście nie jest prawdą.

W takim przypadku możemy zastosować np. zagnieżdżone instrukcje if.

Ćwiczenie (5 minut)

Popraw wcześniejszy kod w taki sposób, aby najpierw sprawdzić, czy liczby są równe, a dopiero gdy nie są, porównaj je operatorem nierówności. Wykorzystaj zagnieżdżone warunki if i w każdej sytuacji wyświetl na ekranie stosowny komunikat.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 11;

        if (a == b) {
            System.out.println("Liczby A i B są równe " + a + " = " + b);
        } else {
            if (a > b) {
                System.out.println("A jest większe od B " + a + " > " + b);
            } else {
                System.out.println("B jest większe od A " + b + " > " + a);
            }
        }
    }
}

Powyższy kod posiada jedną, aczkolwiek istotną wadę. Nawet pojedynczo zagnieżdżone bloki instrukcji if wpływają w znaczącym stopniu na zmniejszenie czytelności kodu i w ogólności dobrą praktyką jest unikanie takich sytuacji. Najprościej jest to zrobić korzystając z nieco bardziej złożonej instrukcji if else:

1
2
3
4
5
6
7
8
9

if (warunek1) {
    //instrukcje gdy warunek1 jest true
} else if (warunek2) {
    //instrukcje gdy warunek2 jest true
} else if (warunek3) {
    //instrukcje gdy warunek3 jest true
} else {
    //instrukcje gdy żadny z warunków nie był true
}

Korzystając z dodatkowych warunków w postaci else if możemy w dowolny sposób rozgałęzić działanie naszej aplikacji bez konieczności zagnieżdżania warunków if i obniżania czytelności kodu. Pamiętaj, że blok z warunkiem2 wykona się tylko wtedy, gdy warunek1 zwróci false, analogicznie warunek3, gdzy warunek2 oraz warunek1 będą nieprawdziwe.

Ćwiczenie (5 minut)

Przerób wcześniejszy kod z porównywaniem liczb w taki sposób, aby wyeliminować zagnieżdżone warunki if.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class Main {
    public static void main(String[] args) {
        int a = 12;
        int b = 11;

        if (a == b) {
            System.out.println("Liczby A i B są równe " + a + " = " + b);
        } else if (a > b) {
            System.out.println("A jest większe od B " + a + " > " + b);
        } else {
            System.out.println("B jest większe od A " + b + " > " + a);
        }
    }
}

Zauważ, że ponieważ wiemy, że istnieją tylko trzy możliwe wyniki porównania dwóch liczb, to w ostatnim bloku nie musimy zapisywać else if(a<b) a wystarczy jedynie samo else - jest to jedyny możliwy wynik jaki pozostał.

Struktura sterująca switch¶

Powyżej pokazana struktura if-else-if pomimo iż bardziej czytelna od zagnieżdżonych warunków, to jednak w sytuacji, gdy mamy np. menu aplikacji składające się z 10 możliwych opcji, nie wydaje się najlepszym rozwiązaniem. W większości języków programowania rozwiązaniem tego problemu jest bardziej złożona struktura switch.

W odróżnieniu od instrukcji if, w strukturze switch operujemy nie na warunkach zwracających wartość true lub false, ale na liczbach całkowitych. Od Javy w wersji 7 możliwe jest także stosowanie w miejsce liczb napisów typu String.

Schematyczna budowa switch wygląda jak poniżej:

//wybrana opcja musi być typu całkowitoliczbowego lub być wartością typu String
switch (wybrana_opcja) {
    case wartość1:
        //instrukcje, gdy wartość1 jest równa wartości wybrana_opcja
        break;
    case wartość2:
         //instrukcje, gdy wartość2 jest równa wartości wybrana_opcja
        break;
    case ...
    default:
        //instrukcje, gdy żaden z wcześniejszych warunków nie pasuje do wybrana_opcja
        //odpowiednik ostatniego bloku else z instrukcji if-else-if
}

Istotne w powyższym kodzie jest zastosowanie instrukcji break. Jeżeli jej nie zastosujesz w danym bloku case, wtedy wykonane zostaną także instrukcje z innych bloków case znajdujących się poniżej (aż do napotkania break). W bloku default nie jest to wymagane, ponieważ jest on ostatnim w całej konstrukcji i nie musimy niczego przerywać. Dzięki instrukcji switch możemy zbudować w wygodny sposób proste menu w swojej aplikacji w stylu:

Ćwiczenie (10 minut)

Napisz prostą aplikację, w której utworzysz jedną zmienną całkowitoliczbową i przypiszesz do niej wartość z zakresu od 1 do 10. Następnie stwórz blok switch, w którym na podstawie wybranej opcji wyświetlisz wcześniej zainicjowaną zmienną podniesioną do 1, 2, 3 lub 4 potęgi.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class Exponential {
    public static void main(String[] args) {
        int number = 5;

        int option = 2;

        switch (option) {
        case 1:
            System.out.println(number + " do potęgi 1 = " + number);
            break;
        case 2:
            System.out.println(number + " do potęgi 2 = " + number*number);
            break;
        case 3:
            System.out.println(number + " do potęgi 3 = " + number*number*number);
            break;
        case 4:
            System.out.println(number + " do potęgi 4 = " + number*number*number*number);
            break;
        default:
            System.out.println("Wybrano niepoprawną opcję");
        }
    }
}

Pętle while i do while¶

W pierwszej części kursu dowiedziałeś się, że w Javie istnieją specjalne struktury danych, które pozwalają przechowywać wiele wartości tego samego typu, które nazwaliśmy tablicami. W tym miejscu powrócimy do nich na chwilę, aby pokazać, że ich przetwarzanie, czy wyświetlanie może być znacznie krótsze i do każdego elementu tablicy nie musimy odwoływać się osobno tak jak do zwykłych zmiennych.

Dwa pierwsze rodzaje pętli, które omówimy to while oraz do while. Różnica między nimi jest subtelna, aczkolwiek wpływa w znaczący sposób na to co dzieje się w naszym programie. Ogólna postać obu pętli wygląda jak poniżej:

1
2
3
4
5
6
7
8
9

//pętla while
while (warunek) {
    //instrukcje, które będą powtarzane tak długo, dopóki warunek zwraca true
}

//pętla do while
do{
    //instrukcje, które będą się wykonywały tak długo, dopóki warunek zwraca true
} while(warunek);

Różnica pomiędzy dwoma wyżej pokazanymi rodzajami pętli polega na tym, że w przypadku zwykłej pętli while warunek jest sprawdzany przed rozpoczęciem ciała pętli, więc jeżeli warunek nie będzie prawdziwy, to zawartość pętli nie wykona się ani razu. W przypadku pętli do while mamy pewność, że instrukcje w jej ciele wykonają się co najmniej raz, ponieważ warunek sprawdzany jest dopiero na końcu. W miejscu wyrażenia, które w powyższym kodzie nazwaliśmy jako warunek należy wstawić dowolną zmienną typu boolean lub wyrażenie logiczne zwracające true lub false.

Ćwiczenie (10 minut)

Napisz program, w którym zadeklarujesz tablicę 50 liczb całkowitych. Wypełnij ją przy pomocy pętli while wartościami od 1 do 50, a następnie wyświetl jej kolejne elementy za pomocą pętli do while.

plik Loops1.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class Loops1 {
    public static void main(String[] args) {
        int[] array = new int[50];

        int i = 0; // licznik pętli

        // wypełniamy tablicę
        while (i < array.length) {
            array[i] = i + 1;
            i = i + 1;
        }

        // zerujemy licznik
        i = 0;

        //wyświetlamy wartości
        do {
            System.out.print(array[i] + "; ");
            i = i + 1;
        } while (i < array.length);
    }
}

Do rozwiązania należało zastosować scenariusz, który będzie się często powtarzał w niemal każdej aplikacji, która korzysta z tablic:

1. Utworzenie tablicy
2. Zainicjowanie licznika pętli
3. Wypełnienie kolejnych komórek tablicy wartościami (while)
4. Wykonanie operacji na danych w tablicy (pętla do while)

W praktyce dużo częściej stosuje się pętle while, ponieważ są po prostu bardziej intuicyjne

Inkrementacja i dekrementacja¶

Operacją, która w przypadku pętli będzie się bardzo często powtarzała jest zwiększanie lub zmniejszanie zmiennej reprezentującej licznik o 1. W programowaniu jest to tak często wykorzystywane, że powstały specjalne operatory, które skracają zapis, a po pewnym czasie stają się nawykiem przy pisaniu pętli.

Inkrementacja to zwiększenie wartości zmiennej o 1, natomiast dekrementacja to zmniejszenie o 1. Inkrementację oznaczamy znakiem podwójnego plusa (++), natomiast dekrementację podwójnego minusa (–).

W praktyce wygląda to następująco:

1
2
3
4
5

int a = 1;
a++;
//a ma teraz wartość 2
a--;
//a ma teraz znowu wartość 1

Dodatkowo istnieją dwa rodzaje powyższych operatorów. W formie przyrostkowej, czyli np. a++ oraz przedrostkowej, czyli ++a. Różnica polega na tym, kiedy wykonywane jest faktyczne zwiększenie, czy zmniejszenie wartości o 1. W przypadku inkrementacji przyrostkowej wartość zmiennej jest zwiększana dopiero po wykonaniu operacji, w której zmienna ta występuje.

Najłatwiej zobrazować to prostym przykładem:

1
2
3
4

int x = 1;
System.out.println(x); //wyświetla 1
System.out.println(x++); //również wyświetla 1, ale po wyświetleniu zwiększa wartość x do 2
System.out.println(x); //wyświetla 2

Analogicznie dla inkrementacji przedrostkowej:

1
2
3
4

int x = 1;
System.out.println(x); //wyświetla 1
System.out.println(++x); //najpierw zwiększa wartość x do 2 i wyświetla 2
System.out.println(x); //wyświetla 2

W pętlach znajduje to takie zastosowanie, że możemy pominąć ręczne zwiększanie licznika w postaci i = i+1 i zapisać i++, dodatkowo w niektórych sytuacjach bezpośrednio przy sprawdzaniu warunku, np.:

int i=0;
while(i++ < 10) { ... }

Ćwiczenie (5 minut)

Przerób poprzedni przykład z wypełnianiem tablicy w taki sposób, aby wykorzystać operator inkrementacji. Dodatkowo wartości w tablicy wyświetl od końca wykorzystując dekrementację.

plik Loops1Increment.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class Loops1Increment {
    public static void main(String[] args) {
        int[] array = new int[50];

        int i = 0; // licznik pętli

        // wypełniamy tablicę
        while (i < array.length) {
            array[i] = i + 1;
            i++;
        }

        // przypisujemy do licznika ostatni indeks tablicy
        i = array.length-1;

        //wyświetlamy wartości
        do {
            System.out.print(array[i] + "; ");
        } while (i-- > 0);
    }
}

Pętla while nie zmieniła się znacząco, jedynie zamieniliśmy sposób zwiększania zmiennej i. W pętli do while zastosowaliśmy dekrementacją, a dodatkowo zmieniliśmy warunek, na taki, który pozwala nam wyświetlać wartości od ostatniego indeksu tablicy, do pierwszego (czyli 0 zgodnie z indeksowaniem tablic).

Pętle for i for each¶

Pętle for i for each to dwa kolejne rodzaje pętli, które idealnie znajdują zastosowanie w przypadku kolekcji danych o znanych z góry rozmiarach, czyli np. tablicach. Ich specyficzna konstrukcja sprawia, że powinniśmy je stosować przede wszystkim w sytuacjach, gdy chcemy przeglądnąć całą kolekcję elementów.

Schematyczna budowa pętli for:

1
2
3

for(inicjalizacja_licznika; warunek_stopu; zmiana_licznika) {
    //operacje
}

Zwróć uwagę, że w nawiasach okrągłych znajdują się trzy elementy, które są oddzielone od siebie średnikami. W sytuacji, gdy chcielibyśmy uzupełnić tablicę o rozmiarze 10 liczbami 10, 20, 30, ..., 100, można to zrobić w następujący sposób:

1
2
3
4
5
6
7
8
9

public class ForLoop {
    public static void main(String[] args) {
        int[] array = new int[10];

        for(int i=0; i < array.length; i++) {
            array[i] = (i+1)*10;
        }
    }
}

W porównaniu do pętli while i do while zapis taki staje się bardziej czytelny, ponieważ wszystkie elementy bezpośrednio związane z pętlą, czyli zmienna licznika i warunek końca pętli są zawarte bezpośrednio w deklaracji pętli obok siebie. Będzie to przydatne, gdy kod w pętli będzie nieco bardziej rozbudowany.

Istnieje także odmiana pętli for, która przeznaczona jest wyłącznie do operacji na kolekcjach, gdzie znacząco uproszczono kwestie związane z licznikiem, czy jakimikolwiek warunkami stopu. Jedynym zadaniem pętli for each, o której mowa, jest przejście po wszystkich elementach kolekcji.

Schematyczna budowa pętli for each:

for(typ_zmiennej zmienna: kolekcja) {
    operacje na zmiennej
}

Typ zmiennej musi być zgodny z typem kolekcji (czyli np. tablicy), ponieważ w kolejnych iteracjach przypisywana będzie do niej kolejna jej wartość.

Przykładowo dodajmy do poprzedniego przykładu opcję wydruku danych na ekranie z użyciem pętli for each:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class ForLoop {
    public static void main(String[] args) {
        int[] array = new int[10];

        for(int i=0; i < array.length; i++) {
            array[i] = (i+1)*10;
        }

        for(int number: array) {
            System.out.print(number + "; ");
        }
    }
}

Ponieważ nasza tablica była typu int[] to zmienna number została zadeklarowana jako int. Możemy ją wykorzystać następnie w naszej pętli.

Ćwiczenie podsumowujące¶

Napisz program w którym wyświetlisz na ekranie zawartość tablicy dwuwymiarowej o rozmiarach NxN (gdzie rozmiar N jest wartością przechowywaną w zmiennej, którą można modyfikować). Tablica powinna być wypełniona znakami “0” (zero), jedynie na krawędziach oraz przekątnych powinny znajdować się znaki “X”. Do wypełnienia tablicy zastosuj pętle for, natomiast do wyświetlenia jej zawartości pętle while. Używaj w kodzie tam gdzie to możliwe operatorów inkrementacji. Przykładowy wydruk programu:

X X X X X X X X
X X 0 0 0 0 X X
X 0 X 0 0 X 0 X
X 0 0 X X 0 0 X
X 0 0 X X 0 0 X
X 0 X 0 0 X 0 X
X X 0 0 0 0 X X
X X X X X X X X

plik Zad1.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public class Zad1 {
    public static void main(String[] args) {
        int n = 8;
        char[][] array = new char[n][n];

        //wypełniamy tablicę
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                //wypełnienie X na krawędziach tablicy
                if (i == 0 || j == 0 || i == n - 1 || j == n - 1) {
                    array[i][j] = 'X';
                //wypełnienie X na przekątnych
                } else if (i == j || i == n - j - 1) {
                    array[i][j] = 'X';
                //wypełnienie 0 w pozostałych miejscach
                } else {
                    array[i][j] = '0';
                }
            }
        }

        //liczniki pętli
        int i = 0, j = 0;
        //wyświetlanie tablicy
        while (i < n) {
            while (j < n) {
                System.out.print(array[i][j] + " ");
                j++;
            }
            j = 0;
            System.out.println(); //nowa linia na końcu wiersza
            i++;
        }
    }
}

Odbieranie danych od użytkownika¶

W naszych dotychczasowych programach skupialiśmy się na poznawaniu podstawowych mechanizmów języka Java, jednak brakowało w nich interakcji z użytkownikiem. Biblioteka wejścia/wyjścia w Javie jest dosyć rozbudowana jednak w tej części kursu poznamy podstawowe sposoby interakcji człowieka z komputerem.

Najprostszą klasą, która pozwoli odczytywać dane od użytkownika jest Scanner. Posiada ona zestaw użytecznych metod, które pozwolą nam wczytać zarówno liczby jak i napisy. Klasa ta jest dosyć uniwersalna, więc w zależności od tego co przekażemy w konstruktorze podczas inicjalizacji możemy za pomocą jej obiektu zarówno odczytywać dane od użytkownika, które będą wprowadzane z klawiatury, ale także odczytywać informacje zawarte w plikach.

Inicjalizacja obiektu Scanner w przypadku, gdy chcemy odczytać dane od użytkownika wygląda następująco:

1
2
3
4
5

import java.util.Scanner;

public class Example {
    Scanner sc = new Scanner(System.in);
}

Przede wszystkim, aby korzystać z klasy Scanner w swoim kodzie, musisz ją najpierw zaimportować z pakietu java.util (np. wykorzystując skrót Ctrl+Shift+O w eclipse). Obiekt tworzony jest przez przekazanie w konstruktorze standardowego strumienia wejścia, którym jest System.in.

Następnie do odczytu danych należy skorzystać z jednej z metod zawartych w klasie Scanner:

• nextInt() - odczytanie kolejnej liczby typu int
• nextDouble() - odczytanie kolejnej liczby typu double (uwaga, domyślny separator dziesiętny jest zależny od ustawień maszyny wirtualnej, w Polsce domyślnie liczby należy wprowadzać rozdzielone przecinkiem)
• nextLine() - wczytanie kolejnego wiersza tekstu (String) zakończonego znakiem nowej linii ‘n’
• analogicznie dla innych typów danych istnieją metody takie jak nextBoolean(), nextLong() itp.

Ważne jest to, że w przypadku, gdy odczytywać będziemy liczby, w buforze nadal pozostanie znak nowej linii, który należy wczytać za pomocą metody nextLine(). Przykład:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import java.util.Scanner;

public class SimpleInput {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("Podaj pierwszą liczbę: ");
        //wczytujemy wartość zmiennej z klawiatury
        int num1 = sc.nextInt();
        //usuwamy znak nowej linii z bufora
        sc.nextLine();

        System.out.println("Podaj drugą liczbę: ");
        //wczytujemy drugą liczbę
        int num2 = sc.nextInt();
        //usuwamy znak nowej linii z bufora
        sc.nextLine();

        System.out.println("Suma podanych liczb to: " + (num1 + num2));

        System.out.println("Jak masz na imię? ");
        //wczytujemy napis
        String name = sc.nextLine();

        System.out.println("Witaj " + name + "!");

        //po zakończonym odczycie zamykamy strumień wejścia
        sc.close();
    }
}

Ćwiczenie (10 min)

Napisz prosty program do zarządzania książkami biblioteki. Powinien się on składać z dwóch klas:

• Book - klasa reprezentująca pojedynczą książkę. Powinna posiadać pola reprezentujące numer ISBN, tytuł oraz autora
• BookManager - główna klasa aplikacji, w której wczytasz od użytkownika dotyczące 1 książki, utworzysz na ich podstawie obiekt klasy Book i wyświetlisz odpowiednie informacje na ekranie. Zadbaj o utworzenie odpowiednich konstruktorów.

plik Book.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Book {
    String isbn;
    String title;
    String author;

    Book(String isbn, String title, String author) {
        this.isbn = isbn;
        this.title = title;
        this.author = author;
    }

    String getBookInfo() {
        return isbn + " - " + title + " - " + author;
    }
}

plik BookManager.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import java.util.Scanner;

public class BookManager {
    public static void main(String[] args) {
        //tworzymy obiekt do odczytu danych
        Scanner sc = new Scanner(System.in);

        //prosimy użytkownika o podanie odpowiednich danych
        System.out.println("Podaj ISBN: ");
        String isbn = sc.nextLine();
        System.out.println("Podaj Tytuł: ");
        String title = sc.nextLine();
        System.out.println("Podaj autora: ");
        String author = sc.nextLine();

        //zamykamy strumień wejścia
        sc.close();

        //tworzymy obiekt Book i wyświetlamy informacje na ekranie
        Book book = new Book(isbn, title, author);
        System.out.println(book.getBookInfo());
    }
}

Przykładowy wynik działania programu:

Dziedziczenie¶

W naszej aplikacji możemy teraz przechowywać i wczytywać od użytkownika informacje o książkach, jednak warto zauważyć, że przecież w bibliotece oprócz książek są także komiksy, gazety, ogólnie rzecz ujmując magazyny. W tym momencie należałoby stworzyć osobną klasę Magazine, która przechowywać będzie również numer ISBN, tytuł, oraz np. wydawnictwo. Problemem jest to, że pewne dane zaczynają się tutaj powielać, a tego w programowaniu zdecydowanie powinniśmy unikać.

W celu rozwiązania m.in. tego problemu powstał paradygmat programowania obiektowego, które pozwala budować hierarchię klas, dającą możliwość tworzenia kodu, który może być wykorzystywany wielokrotnie i być bazą do tworzenia jeszcze kolejnych klas.

Na powyższym diagramie widać bazową klasę Publication, po której dziedziczą dwie kolejne klasy: Book oraz Magazine. Różnią się one tym, że książka posiada najczęściej jednego autora (np. Henryk Sienkiewicz), natomiast w przypadku gazety w tym miejscu pojawi się wydawnictwo (np. Ringier Axel Springer).

Powyższa regułka oznacza, że w przypadku, gdy spojrzymy na powyższy diagram, klasa Book, czy Magazine będą posiadały także pola z klasy Publication, czyli isbn oraz title. W Javie dziedziczenie można osiągnąć stosując słowo kluczowe extends w definicji klasy, np.:

plik Publication.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Publication {
    String isbn;
    String title;

    Publication(String isbn, String title) {
        this.isbn = isbn;
        this.title = title;
    }

    String getInfo() {
        return title + " - " + isbn;
    }
}

plik Book.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Book extends Publication {
    String author;

    Book(String isbn, String title, String author) {
        super(isbn, title);
        this.author = author;
    }

    String getInfo() {
        return super.getInfo() + " - " + author;
    }
}

plik Magazine.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Magazine extends Publication {
    String publisher;

    Magazine(String isbn, String title, String publisher) {
        super(isbn, title);
        this.publisher = publisher;
    }

    String getInfo() {
        return super.getInfo() + " - " + publisher;
    }
}

Zwróć uwagę, że pomimo iż w klasach Book oraz Magazine nie zadeklarowaliśmy pól isbn oraz title to mamy do nich dostęp w konstruktorze, czy metodach getBookInfo() i getMagazineInfo(), ponieważ dziedziczą one te cechy z klasy Publication.

Kolejną nowością jest zastosowanie specjalnej konstrukcji super(). Działa ona w sposób podobny do słowa kluczowego this, którego używaliśmy w przypadku, gdy posiadaliśmy kilka przeciążonych wersji konstruktora z tą różnicą, że wywołuje konstruktor nadklasy z odpowiednimi parametrami.

Ostatnia rzecz dotyczy przesłaniania metod. W klasie Publication zdefiniowaliśmy metodę getInfo(). Jeżeli w klasie dziedzicząsej (Book lub Magazine) zdefiniujemy metodę o takiej samej sygnaturze, to powiemy, że przesłania ona oryginalną metodę getInfo(). W celu wywołania metody nadklasy należy posłużyć się w takiej sytuacji zapisem super.getInfo().

@Override
String getInfo() {
    return super.getInfo() + " - " + author;
}

Ćwiczenie (10 min)

W klasie BookManager utwórz tablice do przechowywania książek oraz magazynów. W każdej tablicy utwórz przynajmniej po jednym obiekcie danego typu, a następnie wyświetl je na ekranie.

plik BookManager.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

import java.util.Scanner;

public class BookManager {
    public static void main(String[] args) {
        // tworzymy obiekt do odczytu danych
        Scanner sc = new Scanner(System.in);

        // tworzymy tablice
        Book[] books = new Book[10];
        Magazine[] magazines = new Magazine[10];

        // prosimy użytkownika o podanie informacji o książce
        System.out.println("Podaj ISBN książki: ");
        String isbn = sc.nextLine();
        System.out.println("Podaj Tytuł książi: ");
        String title = sc.nextLine();
        System.out.println("Podaj autora książki: ");
        String author = sc.nextLine();

        books[0] = new Book(isbn, title, author);

        // prosimy użytkownika o podanie informacji o magazynie
        System.out.println("Podaj ISBN magazynu: ");
        isbn = sc.nextLine();
        System.out.println("Podaj Tytuł magazynu: ");
        title = sc.nextLine();
        System.out.println("Podaj wydawcę magazynu: ");
        String publisher = sc.nextLine();

        magazines[0] = new Magazine(isbn, title, publisher);

        // zamykamy strumień wejścia
        sc.close();

        // tworzymy obiekt Book i wyświetlamy informacje na ekranie
        System.out.println(books[0].getInfo());
        System.out.println(magazines[0].getInfo());
    }
}

W porównaniu do wcześniejszego kodu zyskaliśmy teraz możliwosć przechowywania informacji zarówno o ksiażkach jak i innego rodzaju publikacjach. Ponieważ przechowujemy je w tablicach to dodatkowo dane są teraz bardziej spójne.

Polimorfizm¶

Wcześniej wspomnieliśmy, że dziedziczenia warto używać między innymi po to, żeby zaoszczędzić konieczności powielania tego samego kodu. Problem w tym, że gdy tak jak w powyższym przykładzie stosujemy tablice oddzielnych typów to operacje na nich i tak będą powielane, np:

System.out.println("Książki: ");
for(int i=0; i < books.length; i++) {
    if(books[1] != null)
        System.out.println(books[i].getInfo());
}

System.out.println("Magazyny: ");
for(int i=0; i < magazines.length; i++) {
    if(magazines[1] != null)
        System.out.println(magazines[i].getInfo());
}

Lepiej by było tak naprawdę przechowywać wszystkie te dane w jednej wspólnej tablicy typu Publication, a następnie ewentualnie rozpoznać, czy dany element tablicy jest typu Book, czy Magazine.

Efekt taki można osiągnąć dzięki zastosowaniu polimorfizmu lub inaczej mówiąc wielopostaciowości. Polega to na tym, że do ogólnej, wspólnej referencji można przypisać obiekty różnych typów, które po typie tej referencji dziedziczą.

W naszym przypadku klasy Book i Magazine dziedziczą po klasie Publication, więc jak najbardziej możliwe jest zapisanie:

Publication pub1 = new Book(argumenty_konstruktora);
Publication pub2 = new Magazine(argumenty_konstruktora);

W podobny sposób możemy także utworzyć tablicę typu Publication, która będzie przechowywała zarówno książki jak i magazyny. Pamiętać należy jednak o dwóch rzeczach:

1. Zawsze mamy dostęp jedynie do metod z typu referencji. Jeżeli w klasie Book zdefiniujemy dodatkową metodę changeBookTitle(), a referencja będzie typu Publication, to nie będziemy mieli dostępu do takiej metody. Jeśżeli chcesz uzyskać dostęp do wszystkich metod (również tych nie zdefiniowanych w typie nadrzędnym) musisz skorzystać z rzutowania typu. Rzutowanie polega na wykorzystaniu nawiasu, np.:

Publication pub = new Magazine(...);
((Magazine)pub).metodaZKlasyMagazine();

2. Metody będą wywoływane na rzecz typu obiektu, a nie typu referencji. Jeżeli zapisaliśmy Publication pub1 = new Book(argumenty_konstruktora); to wywołując metodę pub1.getInfo() wywołamy jej wersję z klasy Book, a nie Publication.

Ćwiczenie (5 min)

Przerób klasę BookManager w taki sposób, aby przechowywać książki oraz magazyny w jednej wspólnej tablicy typu Publication[].

plik BookManager.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import java.util.Scanner;

import java.util.Scanner;

public class BookManager {
    public static void main(String[] args) {
        // tworzymy obiekt do odczytu danych
        Scanner sc = new Scanner(System.in);

        // tworzymy tablice
        Publication[] publications = new Publication[10];

        // prosimy użytkownika o podanie informacji o książce
        System.out.println("Podaj ISBN książki: ");
        String isbn = sc.nextLine();
        System.out.println("Podaj Tytuł książi: ");
        String title = sc.nextLine();
        System.out.println("Podaj autora książki: ");
        String author = sc.nextLine();

        publications[0] = new Book(isbn, title, author);

        // prosimy użytkownika o podanie informacji o magazynie
        System.out.println("Podaj ISBN magazynu: ");
        isbn = sc.nextLine();
        System.out.println("Podaj Tytuł magazynu: ");
        title = sc.nextLine();
        System.out.println("Podaj wydawcę magazynu: ");
        String publisher = sc.nextLine();

        publications[1] = new Magazine(isbn, title, publisher);

        // zamykamy strumień wejścia
        sc.close();

        // wyświetlamy informacje na ekranie
        System.out.println("Książki i magazyny: ");
        for (Publication p: publications) {
            if (p != null)
                System.out.println(p.getInfo());
        }
    }
}

Dzięki uproszczeniu sposobu przechowywania danych wyświetlanie danych odbywa się w jednej tylko pętli, dane są bardziej spójne, a kod bardziej przejrzysty.

Operator instanceof¶

W poprzednim przykładzie brakuje w tej chwili trochę informacji o tym, czy dana pozycja w tablicy publications jest typu Book, czy Magazine. W niektórych sytuacjach chcielibyśmy mieć taką informację w celu zwiększenia przejrzystości. W Javie możemy sprawdzić rzeczywisty typ obiektu (nie typ referencji) za pomocą operatora instanceof. Jego składnia jest następująca:

obiekt instanceof NazwaKlasy

np.

Publication book = new Book("123456789", "W pustyni i w puszczy", "Henryk Sienkiewicz");
if(book instanceof Book) {
    System.out.println("To jest książka");
}

Na ekranie zobaczymy tekst “To jest ksiażka”.

Sprawdzenie obiektu za pomocą operatora instanceof zwraca w wyniku true lub false, więc jak widać w powyższym przykładzie, może on być zastosowany jako warunek w instrukcji if.

Ćwiczenie (5 min)

Przerób kod klasy BookManager w taki sposób, aby dane były wyświetlane w formie:

Książka: 123456789 - W pustyni i w puszczy - Henryk Sienkiewicz
Magazyn: 987654321 - Wprost - Wydawnictwo Wprost

plik BookManager.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import java.util.Scanner;

public class BookManager {
    public static void main(String[] args) {
        // tworzymy obiekt do odczytu danych
        Scanner sc = new Scanner(System.in);

        // tworzymy tablice
        Publication[] publications = new Publication[10];

        // prosimy użytkownika o podanie informacji o książce
        System.out.println("Podaj ISBN książki: ");
        String isbn = sc.nextLine();
        System.out.println("Podaj Tytuł książi: ");
        String title = sc.nextLine();
        System.out.println("Podaj autora książki: ");
        String author = sc.nextLine();

        publications[0] = new Book(isbn, title, author);

        // prosimy użytkownika o podanie informacji o magazynie
        System.out.println("Podaj ISBN magazynu: ");
        isbn = sc.nextLine();
        System.out.println("Podaj Tytuł magazynu: ");
        title = sc.nextLine();
        System.out.println("Podaj wydawcę magazynu: ");
        String publisher = sc.nextLine();

        publications[1] = new Magazine(isbn, title, publisher);

        // zamykamy strumień wejścia
        sc.close();

        // wyświetlamy informacje na ekranie
        System.out.println("Książki i magazyny: ");
        for (Publication p: publications) {
            if (p != null)
                if(p instanceof Book) {
                    System.out.println("Książka: " + p.getInfo());
                } else if(p instanceof Magazine) {
                    System.out.println("Magazyn: " + p.getInfo());
                }
        }
    }
}

Klasy abstrakcyjne i interfejsy¶

Nasza aplikacja jest już prawie gotowa, jednak warto się zastanowić nad jeszcze jedną rzeczą. Stworzyliśmy klasę Publication, która jest klasą bazową dla dwóch konkretnych typów danych, które wykorzystujemy. Ponieważ nie chcemy używać obiektów klasy Publication bezpośrednio, powinniśmy z niej zrobić jedynie pewną warstwę abstrakcji, czyli klasę, która jest jedynie klasą bazową dla innych typów, ale nie można tworzyć jej obiektów bezpośrednio.

W Javie można to osiągnąć wykorzystując klasę abstrakcyjną. Jeżeli jakaś klasa ma być abstrakcyjna, należy w jej sygnaturze dodać o tym informację za pomocą słowa kluczowego abstract.

plik Publication.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public abstract class Publication {
    String isbn;
    String title;

    Publication(String isbn, String title) {
        this.isbn = isbn;
        this.title = title;
    }

    String getInfo() {
        return title + " - " + isbn;
    }
}

Klasy abstrakcyjne mają dwie ważne właściwości, o których musisz pamiętać:

1. Nie można utworzyć obiektu klasy abstrakcyjnej za pomocą operatora new. Typ abstrakcyjny może być jedynie typem referencji dla typów bardziej sprecyzowanych (dziedziczących po tej klasie abstrakcyjnej).
2. W klasie abstrakcyjnej mogą być zdefiniowane metody abstrakcyjne, czyli metody, które określają jedynie sygnaturę metody, ale nie posiadają implementacji. Jeżeli jakaś klasa posiada chociaż jedną metodę abstrakcyjną, to musi być oznaczona jako klasa abstrakcyjna. Każda klasa, która dziedziczy po klasie abstrakcyjnej musi posiadać konkretną implementację każdej metody abstrakcyjnej.

Przykład metody abstrakcyjnej:

plik Publication.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public abstract class Publication {
    String isbn;
    String title;

    Publication(String isbn, String title) {
        this.isbn = isbn;
        this.title = title;
    }

    String getInfo() {
        return title + " - " + isbn;
    }

    abstract void printInfo();
}

Jak widzisz metoda printInfo() oznaczona jest słowek abstract. Nie posiada ona żadnej implementacji - nie posiada nawet nawiasów klamrowych i zakończona jest średnikiem.

Jak widzisz dodanie metody abstrakcyjnej powoduje błędy w naszym projekcie w klasach dziedziczących po Publication. W celu ich wyeliminowania powinniśmy zaimplementować metodę printInfo() w tych klasach, np.:

plik Book.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Book extends Publication {
    String author;

    Book(String isbn, String title, String author) {
        super(isbn, title);
        this.author = author;
    }

    String getInfo() {
        return super.getInfo() + " - " + author;
    }

    @Override
    void printInfo() {
        System.out.println(getInfo());
    }
}

analogicznie w klasie Magazine:

plik Magazine.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Magazine extends Publication {
    String publisher;

    Magazine(String isbn, String title, String publisher) {
        super(isbn, title);
        this.publisher = publisher;
    }

    String getInfo() {
        return super.getInfo() + " - " + publisher;
    }

    @Override
    void printInfo() {
        System.out.println(getInfo());
    }
}

W Javie istnieją także klasy, które są w pełni abstrakcyjne nazywane interfejsami, czyli posiadają jedynie metody abstrakcyjne oraz ewentualnie zdefiniowane stałe wartości (oznaczone jako public static). Interfejsy definiujemy za pomocą słowa kluczowego interface, a implementujemy je (analogia do dziedziczenia) za pomocą słowa kluczowego implements. Na tym etapie nie będziemy się zagłębiali w stosowanie interfejsów w swoich programach, spójrz jedynie na przykład i zapamiętaj kilka rzeczy zapisanych poniżej.

Przykład interfejsu:

1
2
3
4
5

public interface Moveable {
    void move();

    void stop();
}

Klasa implementująca interfejs Moveable:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Car implements Moveable {

    public void move() {
        System.out.println("Samochód start");
    }

    public void stop() {
        System.out.println("Samochód stop");
    }
}

Ponieważ wszystkie metody interfejsu muszą być abstrakcyjne, to nie jest konieczne jawne używanie słowa kluczowego abstract - jest ono niejawnie dodawane automatycznie.

Zapamiętaj

1. W Javie można dziedziczyć tylko po jednej klasie (extends), nawet jeśli są to klasy abstrakcyjne.
2. Możesz implementować dowolną liczbę interfejsów (implements).

Dodatek - składowe statyczne¶

Jako dodatek tej lekcji wytłumaczymy jescze krótko co oznacza słowo kluczowe static. W niektorych sytuacjach chcielibyśmy mieć dostęp do metody, czy pola klasy bez konieczności tworzenia obiektu. Przykładem takiej metody jest dobrze nam już znana metoda main().

Jeżeli zdefiniujemy jakieś pole lub metodę jako statyczne, to możemy się do nich odwoływać bez tworzenia obiektu takiej klasy poprzez konstrukcję NazwaKlasy.nazwaPolaStatycznego lub NazwaKlasy.metodaStatyczna().

Najważniejszą rzeczą dotyczącą składowych statycznych klasy jest to, że w metodach statycznych możemy odwoływać się jedynie do innych elementów statycznych.

Wyjątki¶

W każdym programie występują pewne sytuacje wyjątkowe, które jednak można przewidzieć i w odpowiedni sposób obsłużyć. Nasza aplikacja powinna być odporna przede wszystkim na błędy, które mogą wyniknąć nie z naszej programistycznej winy, czyli np. zamknięcie połączenia sieciowego w trakcie komunikacji z innym komputerem podłączonym do sieci, błąd odczytu pliku, albo zwyczajnie wprowadzenie przez użytkownika danych w niepoprawnym formacie (napis zamiast liczby).

We wszystkich takich przypadkach zostają wygenerowane wyjątki, czyli specjalne obiekty, które mówią o tym co poszło nie tak jak powinno. W Javie istnieją dwa sposoby na obsługę wyjątków, które w tym miejscu krótko omówimy.

Hierarchia dziedziczenia klas wyjątków wygląda tak jak na poniższym schemacie.

Nie musisz tego zapamiętywać, ponieważ najważniejszą różnicą pomiędzy poszczególnymi typami wyjątków jest to, czy musimy je obsługiwać, czy też nie. Obsługę wyjątków w niektórych sytuacjach wymusi na Tobie eclipse. W innych sytuacjach warto spojrzeć na sygnatury metod w dokumentacji, ponieważ to w nich znajdziesz informację, czy może ona generować jakiś wyjątek.

Zacznijmy od prostej aplikacji, która posłuży nam do omówienia zagadnień tej lekcji.

Ćwiczenie (10 minut)

Przeanalizuj kod poniższego programu, który służy do zbierania danych o uczestnikach dowolnego konkursu, uruchom go oraz przetestuj dostępne opcje.

plik Person.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package pl.org.ceo.data;
public class Person {
    private String firstName;
    private String lastName;
    private String pesel;
    private int age;

    public String getFirstName() {
        return firstName;
    }
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
    public String getLastName() {
        return lastName;
    }
    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    public String getPesel() {
        return pesel;
    }
    public void setPesel(String pesel) {
        this.pesel = pesel;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return firstName + " " + lastName + " - " + pesel + ", " + age + " lat";
    }
}

Zwróć uwagę na to, że pola tej klasy oznaczyliśmy jako prywatne oraz wygenerowaliśmy dla nich zestaw dwóch metod - tzw. getterów i setterów, które pozwalają je odczytać poza tą klasą. Jest to ogólnie przyjęta konwencja, do której należy się przyzwyczaić, ponieważ spotkamy się z nią w Javie na każdym kroku.

Druga nowość to przesłonięcie metody toString(). Oznaczona jest jako Override, czyli przesłania metodę toString() z klasy nadrzędnej. Możliwe, że myślisz - ale jak to, przecież klasa Person nie dziedziczy po żadnej klasie (brak extends). Otóż w Javie niejawnie każda klasa dziedziczy po specjalnej klasie Object. Metoda toString() to ogólnie przyjęta metoda, która zwraca opisową formę obiektu.

plik Competition.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

package pl.org.ceo.app;
import java.util.Scanner;

import pl.org.ceo.data.Person;

public class Competition {

    public static final int ADD_COMPETITOR = 0;
    public static final int PRINT_ALL = 1;
    public static final int EXIT = 2;

    private static Person[] competitors;
    private static int competitorsNumber;

    public static void main(String[] args) {
        competitors = new Person[100];
        competitorsNumber = 0;
        Scanner sc = new Scanner(System.in);
        int option = 0;

        do {
            printOptions();
            option = sc.nextInt();
            sc.nextLine();

            switch (option) {
            case ADD_COMPETITOR:
                addCompetitor(sc);
                break;
            case PRINT_ALL:
                printCompetitors();
                break;
            case EXIT:
                break;
            }
        } while (option != EXIT);

    }

    private static void printCompetitors() {
        System.out.println("--------------------");
        System.out.println("Lista uczestników:");
        for(int i=0; i < competitorsNumber; i++) {
            System.out.println(competitors[i].toString());
        }
    }

    private static void addCompetitor(Scanner sc) {
        if(competitorsNumber < competitors.length) {
            Person person = new Person();
            System.out.println("--------------------");
            System.out.println("Dodawanie nowego uczestnika: ");
            System.out.println("Imię: ");
            person.setFirstName(sc.nextLine());
            System.out.println("Nazwisko");
            person.setLastName(sc.nextLine());
            System.out.println("PESEL:");
            person.setPesel(sc.nextLine());
            System.out.println("Wiek:");
            person.setAge(sc.nextInt());
            sc.nextLine();

            competitors[competitorsNumber] = person;
            competitorsNumber++;
        } else {
            System.out.println("Osiągnięto maksymalną liczbę uczestników");
        }
    }

    private static void printOptions() {
        System.out.println("--------------------");
        System.out.println("Dostępne opcje: ");
        System.out.println(ADD_COMPETITOR + " - Dodaj uczestnika");
        System.out.println(PRINT_ALL + " - Wyświetl uczestników");
        System.out.println(EXIT + " - Wyjście z programu");
        System.out.println("Wybierz opcję: ");
    }
}

Klasa Person to nasz nośnik danych. Przechowuje ona informacje dotyczące imienia, nazwiska, nr. PESEL oraz wieku uczestnika. W klasie Competition znajduje się główna logika aplikacji, w której dajemy użytkownikowi jedną z trzech opcji, czyli dodanie nowego uczestnika, wyświetlenie wszystkich uczestników lub wyjście z programu. Po wybraniu opcji wywoływana jest odpowiednia metoda, w której wyświetlamy odpowiednie komunikaty, odbieramy dane od użytkownika i na ich podstawie tworzymy kolejne obiekty Person lub wyświetlamy już te dodane. Wszystkie składowe klasy zostały oznaczone jako statyczne, więc nie jest wymagane tworzenie obiektu klasy Competition w celu wywoływania metod, czy odwoływania się do poszczególnych pól z metody main(). Elementy oznaczone jako public static final nazywać będziemy stałymi.

Wyjątki - blok try catch¶

Miejscem, w którym w naszym programie mogą pojawić się problemy, są związane głównie z odbiorem danych od użytkownika - w końcu nie jesteśmy w stanie przewidzieć, czy zamiast konkretnej liczby nie wprowadzi on dla żartu napisu “asdf”. Jeżeli coś takiego się wydarzy, zostanie wtedy wygenerowany wyjątek fazy wykonania o nazwie InputMismatchException, który jest spowodowany tym, że metoda nextInt() nie jest przygotowana na odbiór danych typu String.

Aplikacja w tej sytuacji przestaje działać, a dane zostają utracone. W Javie istnieje jednak dosyć prosty mechanizm obsługi sytuacji wyjątkowych za pomocą bloku try catch. Jego ogólna konstrukcja wygląda następująco:

try {
  //instrukcje mogące wygenerować wyjątek
} catch(typ_wyjatku nazwa_zmiennej) {
  //instrukcje, które zostaną wykonane po wygenerowaniu wyjątku
} finally {
  //instrukcje, które wykonają się zawsze, niezależnie, czy wyjątek wystąpi, czy też nie (blok opcjonalny)
}

W naszym kodzie w bloku try można oczywiście umieścić odczyt danych, czyli wywołanie metody nextInt(). Można także w nim umieścić dużo większy fragment kodu, jednak warto się zastanowić, czy na pewno się to opłaca i czy pomoże nam to w identyfikacji konkretnego problemu.

plik Competition.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

public class Competition {

    //reszta kodu bez zmian

    public static void main(String[] args) {
        competitors = new Person[100];
        competitorsNumber = 0;
        Scanner sc = new Scanner(System.in);
        int option = 0;

        do {
            printOptions();
            try {
                option = sc.nextInt();
                sc.nextLine();
            } catch(InputMismatchException exc) {
                sc.nextLine(); //"zjadamy" znak nowej linii z bufora
                System.out.println("--------------------");
                System.out.println("Dane w nieprawidłowym formacie ");
                continue; //przejście do kolejnej iteracji pętli
            }

            switch (option) {
            case ADD_COMPETITOR:
                addCompetitor(sc);
                break;
            case PRINT_ALL:
                printCompetitors();
                break;
            case EXIT:
                break;
            }
        } while (option != EXIT);

    }

    //reszta kodu bez zmian
}

Jeżeli użytkownik wprowadzi teraz niepoprawne dane podczas przypisania option = sc.nextInt(); wygenerowany zostanie wyjątek, który jednak obsługujemy w bloku try-catch, a tym samym możemy zapobiec zakońćzeniu programu. Ponieważ po wygenerowaniu wyjątku sterowanie programu jest przekazywane natychmiast do bloku catch, musimy w pierwszej kolejności pozbyć się z bufora znaku nowej linii, który pozostaje po wywołaniu metody nextInt(). Następnie wyświetlamy komunikat o błędzie i przechodzimy do kolejnej iteracji pętli dzięki instrukcji continue. Będzie się tak działo za każdym razem, gdy użytkownik wprowadzi wartość niezgodną z typem int.

Blok finally jest w tym przypadku zbędny. Przydatny będzie natomiast, gdy będziemy chcieli zamknąć strumień, czy plik niezależnie od tego, czy błąd wystąpił, czy nie.

Wyjątki - deklaracja throws¶

Istnieją takie sytuacje, w których nie chcemy obsługiwać wyjątków za pomocą bloku try-catch, bo zwyczajnie nie będziemy w stanie nic z tym problemem zrobić. W takiej sytuacji możemy przekazać wyjątek wyżej i dać osobie korzystającej z naszego kodu możliwość zadecydowania, czy chce obsłużyć dany wyjątek, czy też również nic z nim nie robić. Przykładem takiego działania jest metoda nextInt() klasy Scanner - może ona generować trzy różne wyjątki, które możemy obsłużyć tak jak w powyższym kodzie, albo je pominąć, tak jak robiliśmy to wcześniej.

plik Competition.java

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

package pl.org.ceo.app;

import java.util.InputMismatchException;
import java.util.Scanner;

import pl.org.ceo.data.Person;

public class Competition {

    public static final int ADD_COMPETITOR = 0;
    public static final int PRINT_ALL = 1;
    public static final int EXIT = 2;

    private static Person[] competitors;
    private static int competitorsNumber;

    public static void main(String[] args) {
        competitors = new Person[1];
        competitorsNumber = 0;
        Scanner sc = new Scanner(System.in);
        int option = 0;

        do {
            printOptions();
            try {
                option = sc.nextInt();
                sc.nextLine();
            } catch(InputMismatchException exc) {
                sc.nextLine();
                System.out.println("--------------------");
                System.out.println("Dane w nieprawidłowym formacie ");
                continue;
            }

            switch (option) {
            case ADD_COMPETITOR:
                try {
                    addCompetitor(sc);
                } catch(InputMismatchException e) {
                    sc.nextLine();
                    System.out.println("--------------------");
                    System.out.println("Błąd odczytu danych");
                } catch (ArrayIndexOutOfBoundsException e) {
                    System.out.println("--------------------");
                    System.out.println(e.getMessage());
                }
                break;
            case PRINT_ALL:
                printCompetitors();
                break;
            case EXIT:
                break;
            }
        } while (option != EXIT);

        sc.close();

    }

    private static void printCompetitors() {
        System.out.println("--------------------");
        System.out.println("Lista uczestników:");
        for(int i=0; i < competitorsNumber; i++) {
            System.out.println(competitors[i].toString());
        }
    }

    private static void addCompetitor(Scanner sc) throws InputMismatchException, ArrayIndexOutOfBoundsException {
        if(competitorsNumber < competitors.length) {
            Person person = new Person();
            System.out.println("--------------------");
            System.out.println("Dodawanie nowego uczestnika: ");
            System.out.println("Imię: ");
            person.setFirstName(sc.nextLine());
            System.out.println("Nazwisko");
            person.setLastName(sc.nextLine());
            System.out.println("PESEL:");
            person.setPesel(sc.nextLine());
            System.out.println("Wiek:");
            person.setAge(sc.nextInt());
            sc.nextLine();

            competitors[competitorsNumber] = person;
            competitorsNumber++;
        } else {
            //jeżeli tablica jest pełna, tworzymy wyjątek, który o tym informuje
            throw new ArrayIndexOutOfBoundsException("Osiągnięto maksymalną liczbę uczestników");
        }
    }

    private static void printOptions() {
        System.out.println("--------------------");
        System.out.println("Dostępne opcje: ");
        System.out.println(ADD_COMPETITOR + " - Dodaj uczestnika");
        System.out.println(PRINT_ALL + " - Wyświetl uczestników");
        System.out.println(EXIT + " - Wyjście z programu");
        System.out.println("Wybierz opcję: ");
    }
}