Przykład:

import java.io.*;

public class FilesExample{
    public static void main(String[] args) throws IOException {
        //ZAPIS DO PLIKU BAJTOWO
        char[] chars = {'T', 'e', 'k', 's', 't'};
        FileOutputStream out = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            out = new FileOutputStream("src/all/part_10_Files/test.txt");//jeżeli plik nie istnieje to zostanie utworzony
            for (char c : chars) {
                out.write(c); //zapisujemy do pliku
            }
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (out != null) out.close();//zamykamy plik
        }


        //po skompilowaniu kodu w terminalu pojawił się nasz plik.
        //każde uruchomienie programu spowoduje nadpisanie zawartości pliku

        //ZAPIS DO PLIKU ZNAKÓW UNICODE, CZYLI NP POLSKICH LITER, bajt po bajcie
        String tekst = "ąęćńźżłó";
        char[] charsfw = tekst.toCharArray();
        FileWriter fw = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            fw = new FileWriter("src/all/part_10_Files/fw.txt");//jeżeli plik nie istnieje to zostanie utworzony
            for (char c : charsfw) {
                fw.write(c); //zapisujemy do pliku
            }
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (fw != null) fw.close();//zamykamy plik
        }

        //ZAPIS DO PLIKU WIELU ZNAKÓW NA RAZ, bez zapisu Unicode czyli polskich znaków
        String tekst1 = "To jest tekst do zapisu.";
        char[] charsbos = tekst1.toCharArray();
        BufferedOutputStream bos = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            bos = new BufferedOutputStream(new FileOutputStream("src/all/part_10_Files/bis.txt"));
            for (char c : charsbos) {
                bos.write(c); //zapisujemy do pliku
            }
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (bos != null) bos.close();//zamykamy plik
        }

        //ZAPIS DO PLIKU WIELU ZNAKÓW NA RAZ, z zapisem Unicode czyli polskich znaków
        String tekst2 = "To jest tekst do zapisu.";
        BufferedWriter bw = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            bw = new BufferedWriter(new FileWriter("src/all/part_10_Files/bw.txt"));
            for (int i = 0; i<5; i++) {
                bw.write("Linijka " + i + ": " + tekst2 + "\n"); //zapisujemy do pliku
            }
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (bw != null) bw.close();//zamykamy plik
        }

        //W celu zapisu danych innych niż tekstowe należy korzystać z wyspecjalizowanych klas
        //buforowanie do pliku binarnego
        DataOutputStream dos = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            dos = new DataOutputStream(
                    new BufferedOutputStream(
                            new FileOutputStream("src/all/part_10_Files/dos.txt")));
           dos.writeUTF("Testowy strumień binarny");
           dos.writeShort(30000);
           dos.writeLong(12345678963214L);
           dos.writeFloat(55.36F);
           dos.writeDouble(25878.2548d);
           dos.writeByte(11);
           dos.writeChar('A');
           //zapisujemy
            dos.flush();
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (dos != null) dos.close();//zamykamy plik
        }

//-------------------------------------------------------------------------------
        //ODCZYT PLIKU BAJT PO BAJCIE
        FileInputStream in = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            in = new FileInputStream("src/all/part_10_Files/test.txt");
            int i = 0;
            while ((i = in.read()) != -1) {//-1 to koniec pliku
                System.out.print((char) i); //konwertujemy na char, bo inaczej będą tylko bajty
            }
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (in != null) in.close();//zamykamy plik
        }
        System.out.println("\n");

        //ODCZYT PLIKU Z POLSKIMI ZNAKAMI, bajt po bajcie
        FileReader fr = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            fr = new FileReader("src/all/part_10_Files/fw.txt");
            int i = 0;
            while ((i = fr.read()) != -1) {//-1 to koniec pliku
                System.out.print((char) i); //konwertujemy na char, bo inaczej będą tylko bajty
            }
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (fr != null) fr.close();//zamykamy plik
        }

        //ODCZYT PLIKU wiele znaków, bez zapisu Unicode czyli polskich znaków
        BufferedInputStream bis = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            bis = new BufferedInputStream(new FileInputStream("src/all/part_10_Files/bis.txt"));
            int i = 0;
            while ((i = bis.read()) != -1) {//-1 to koniec pliku
                System.out.print((char) i); //konwertujemy na char, bo inaczej będą tylko bajty
            }
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (bis != null) bis.close();//zamykamy plik
        }
        System.out.println("\n");

        //ODCZYT PLIKU wiele znaków, z Unicode czyli polskimi znakami
        BufferedReader br = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            br = new BufferedReader(new FileReader("src/all/part_10_Files/bw.txt"));
            String str = null;
            while ((str = br.readLine()) != null) {
                System.out.println(str);
            }
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (br != null) br.close();//zamykamy plik
        }

        //W celu odczytu danych innych niż tekstowe należy korzystać z wyspecjalizowanych klas
        //!!!odczytujemy dane w takiej samej kolejności jak zapisywaliśmy!!!
        DataInputStream dis = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            dis = new DataInputStream(
                    new BufferedInputStream(
                            new FileInputStream("src/all/part_10_Files/dos.txt")));

            //odczytujemy po kolei tak jak było zapisane
            //dos.writeUTF("Testowy strumień binarny");
            String str1 = dis.readUTF();
            System.out.println(str1);
            //dos.writeShort(30000);
            short srt = dis.readShort();
            System.out.println(srt);
            //dos.writeLong(12345678963214L);
            /*long lng = dis.readLong();
            System.out.println(lng);*/
            //jeżeli chcielibyśmy pominąć odczyt któregoś z typów musimy przeskoczyć określoną ilość bajtów
            dis.skipBytes(8);
            //dos.writeFloat(55.36F);
            float flt = dis.readFloat();
            System.out.println(flt);
            //dos.writeDouble(25878.2548d);
            double dbl = dis.readDouble();
            System.out.println(dbl);
            //dos.writeByte(11);
            byte bt = dis.readByte();
            System.out.println(bt);
            //dos.writeChar('A');
            char ch = dis.readChar();
            System.out.println(ch);
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (dis != null) dis.close();//zamykamy plik
        }
        //---------------------------------------------------------------------
        //KOPIOWANIE PLIKU
        FileInputStream incp = null;
        FileOutputStream outcp = null;
        //zabezpieczamy się przed błedem
        try {
            //uchwyt do pliku
            incp = new FileInputStream("src/all/part_10_Files/test.txt");
            outcp = new FileOutputStream("src/all/part_10_Files/testcp.txt");
            int i = 0;
            while ((i = incp.read()) != -1) {//-1 to koniec pliku
                outcp.write(i);
            }
        } catch (IOException e) { //możemy też zapisać Exception
            e.printStackTrace();
        } finally {
            if (incp != null) incp.close();//zamykamy plik
            if (outcp != null) outcp.close();//zamykamy plik
        }


    }
}

Klasa File

za pomocą klasy File możemy operować na plikach i katalogach

import java.io.File;
import java.io.IOException;
import java.util.Date;


public class FileClass {
    public static void main(String[] args) throws IOException {
        File file = new File("src/all/part_10_Files/klasafile.txt");
        //sprawdzamy czy plik istnieje
        if (!file.exists()){
            //tworzymy plik
            if (file.createNewFile()){
                System.out.println("Utworzono nowy plik.");
            } else {
                System.out.println("Wystąpił nieoczekiwany błąd.");
            }
        }
        System.out.println("Czy plik może być odczytany?: " + file.canRead());
        System.out.println("Czy plik może być zapisywany?: " + file.canWrite());
        System.out.println("Czy to katalog?: " + file.isDirectory());
        System.out.println("Czy to plik?: " + file.isFile());
        System.out.println("Jak się nazywa plik?: " + file.getName());
        System.out.println("Nadrzędny katalog: " + file.getParent());
        System.out.println("Ścieżka dostępu: " + file.getPath());
        System.out.println("Ścieżka dostępu absolutna: " + file.getAbsolutePath());
        System.out.println("Czy plik jest ukryty?: " + file.isHidden());
        System.out.println("Kiedy modyfikowany?: " + new Date(file.lastModified()));
        System.out.println("Ilość bajtów?: " + file.length());

        //listujemy katalog
        File fl = new File("src/all/part_10_Files");
        if (fl.exists()){
            String[] files = fl.list();
            for (String f : files) {
                System.out.println(f);
            }
        } else {
            System.out.println("taki folder nie istnieje");
        }

        //tworzymy katalog
        File dir = new File("src/all/part_10_Files/test_dir");
        if(!dir.exists()) {
            dir.mkdir();
            System.out.println("Utworzono katalog");
        } else{
            System.out.println("Katalog już istnieje");
        }

    }
}

Serializacja

Serializacja pozwala na zapisanie/odczytanie obiektów

import java.io.*;

class CarObject implements Serializable{
    public String manufacturer;
    public String name;
    public int productionYear;
    public int topSpeed;
    public transient int id; //to pole nie będzie serializowane

    public CarObject(String manufacturer, String name, int productionYear, int topSpeed, int id) {
        this.manufacturer = manufacturer;
        this.name = name;
        this.productionYear = productionYear;
        this.topSpeed = topSpeed;
        this.id = id;
    }

    @Override
    public String toString() {
        return "CarObject{" +
                "manufacturer='" + manufacturer + '\'' +
                ", name='" + name + '\'' +
                ", productionYear=" + productionYear +
                ", topSpeed=" + topSpeed +
                ", id=" + id +
                '}';
    }
}

public class SerializeExample {
    public static void main(String[] args) throws IOException {
        CarObject car1 = new CarObject("Ford", "Mustang", 1970,200,1);
        CarObject car2 = new CarObject("Dodge", "Charger", 1975,220,2);

        //zapisujemy obiekt do pliku
        ObjectOutputStream out = new ObjectOutputStream(
                new BufferedOutputStream(
                        new FileOutputStream("src/all/part_10_Files/serialize.dat")
                ));
        out.writeObject(car1);
        out.writeObject(car2);
        out.flush(); //opróżniamy bufor
        out.close();

        //odczytujemy obiekt
        ObjectInputStream in = new ObjectInputStream(
                new BufferedInputStream(
                        new FileInputStream("src/all/part_10_Files/serialize.dat")
                ));
        try {
            while (true){
                CarObject car = (CarObject) in.readObject();
                System.out.println(car);
            }
        } catch (EOFException e){
            //koniec pliku
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            if (in!=null) in.close();
        }
    }
}

Artykuł 22. JAVA – operacje na plikach i katalogach pochodzi z serwisu Kama Kaczmarek.

thread – wątek

Wątek ma kilka etapów „życia”:
NEW – został utworzony, jeszcze nie działa, przed wywołaniem metody start
RUNNABLE – w gotowości do działania lub działający
BLOCKED – oczekujący na odblokowanie zasobów
WAITING – oczekujący aż inny wątek się zakończy, zwykle powiązane jest to z metodą join()
TIMED_WAITING – uśpiony, związany z metodą sleep()
TERMINATED – zakończył pracę
etap wątku możemy sprawdzić metodą getState()

Przykład: stwórzmy najprostszy wątek odliczający

//tworzymy nową klasę
class NewThread extends Thread{
    //każdy z wątków będzie usypiany na inny czas, oczywiście czasem zarządza Java, my jedynie możemy jej przekazać że bardzo nam zależy żeby było jak napisaliśmy
    public int sleepTime;

    //tworzymy konstruktor, by móc nazywać wątki
    public NewThread(String name, int sleepTime) {
        super(name);
        this.sleepTime = sleepTime;
    }

    public void run(){
        for (int i=1; i<=10; i++){
            System.out.println(this.getName() + " i: " + i);
            //chcemy uśpić wątek na sekundę
            try {
                this.sleep(this.sleepTime);
            } catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

public class ThreadsExample {
    public static void main(String[] args) {
        NewThread t1 = new NewThread("Wątek1", 1000); //wątek NEW
        System.out.println(t1.getState());//możemy sprawdzić stan wątku
        t1.start();//aby uruchomić wątek należy go wystarować
        System.out.println(t1.getState());
        NewThread t2 = new NewThread("Wątek2", 800);
        t2.start();
    }
}

Race condition

Podczas pracy z wątkami należy uważać na sytuację, kiedy kilka wątków pracuje na tym samym zasobie.
Wyobraźmy sobie, że te wątki pobierają aktualną wartość i ją modyfikują, który wątek będzie pierwszy? czy wartość, którą pobrał wątek została już zmodyfikowana przez inny wątek? czy może jeszcze nie?
Taka sytuacja, gdzie kilka wątków jednocześnie odczytuje i modyfikuje identyczne dane nazywa się wyścigiem – race condition.

Taki problem możemy rozwiązać dzięki słówku synchronized, który umieszczamy przy tworzeniu metody. Zapewnia ono, że kilka współistniejących wątków nie wykona w tym samym czasie tego samego kodu. Uniemożliwia wielu wątkom współdzielenie zasobu.

Aby zrozumieć problem wyścigu przeanalizujmy poniższy kod, gdzie mamy do czynienia z 2 wątkami, które jednocześnie wywołują metodę increment, która zwiększa o 1 wartość zmiennej counter.

class ThreadCounter implements Runnable{
    ThreadsRaceCondition app;

    public ThreadCounter(ThreadsRaceCondition app) {
        this.app = app;
    }

    @Override
    public void run() {
        for (int a = 0; a < 100000; a++){
            app.increment();
        }
    }
}
public class ThreadsRaceCondition {
    public int counter = 0;
    public /*synchronized*/ void increment(){ //dodanie słówka synchronized eliminuje problem wyścigu
        this.counter++;
    }
    public int getCounter(){
        return counter;
    }

    public static void main(String[] args) throws InterruptedException{
        ThreadsRaceCondition t = new ThreadsRaceCondition();
        Thread th1 = new Thread(new ThreadCounter(t));
        Thread th2 = new Thread(new ThreadCounter(t));
        th1.start();
        th2.start();
        th1.join(); //main poczeka na oba wątki, join() pozwala nakazać wątkowi, aby poczekał aż poprzedni wątek zakończy działanie
        th2.join();
        System.out.println(t.getCounter());

        //różne wyniki przed użyciem słówka synchronized: 188983 137796 120909
        //po dodaniu synchronized zawsze otrzymamy poprawny wynik 200000
        /* jeżeli chcemy synchronizować określony blok kodu używamy zapisu:
        public void increment(){
            synchronized(this){//i to co jest w {} zostanie zsynchronizowane
                this.counter++;
            }
        }
        Używając powyższego rozwiązania korzystamy z tzw monitora, czyli obiektu, który zostaje odblokowany lub zablokowany. I w powyższym przykładzei określamy go jako this, chyba że korzystamy z innego obiektu np. listy to przekazujemy w nawiasie nie this, a właśnie ArrayList
        Nie należy nadużywać synchronized, ponieważ powoduje to spowolnienie działania programu
         */

    }
}

Wątki działają równolegle i każdy ma iterację w pętli for po 100000 razy, czyli po zakończeniu pracy wynik powinien wynosić 200000, ale tak się nie dzieje. Co więcej, za każdym razem otrzymujemy inny wynik.
W każdej iteracji pętli wątki pobierają wartość counter i zwiększają ją o 1, jeżeli np. w aktualnym momencie wartość zmiennej wynosi 4, pobierają ją oba wątki, zwiększają o 1 i zapisują, to wartość counter zamiast wynosić 6, będzie wynosiła 5 – co jest błędem.

Podobny problem może nastąpić jeżeli rdzeń procesora przydzieli danemu wątkowi więcej czasu na wykonanie operacji lub wątek zostanie wywłaszczony(uśpiony).
Np.
w1 i w2 startują, więc pobierają wartość counter 0;
w1 zostaje uśpiony na jakiś czas;
w2 w tym czasie zwiększa wartość counter w 4 iteracjach i zapisuje 4
w1 się wybudza, ale w pamięci ma 0, które zwiększa o 1 i do zmiennej counter zapisuje 1
i tak właśnie tracone są dane.
Wątki należy synchronizować.

Oczekiwanie na dane

Często zachodzi potrzeba, aby zaczekać na dane, które są przetwarzane w innym wątki.
W takim przypadku używamy wait i notify.

Napiszmy apkę dla oczekiwania na dostarczenie pizzy.

import java.util.LinkedList;

class House{
    public LinkedList<String> delivery = new LinkedList<>();

    public void waitForDelivery(){
        //tworzymy blok synchronized ponieważ na tym obiekcie mogą jednocześnie pracować 2 wątki
        synchronized (delivery) {
            //pętla sprawdzi czy delivery nie jest pusta. Jeżeli kolekcja jest pusta to będziemy czekali na powiadomienie o zmianie tego stanu
            System.out.println("Oczekiwanie na dostawę");
            while(delivery.isEmpty()){//pętla zabezpiecza wątek przed nieplanowanym wybudzeniem
                try{
                    delivery.wait();
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.println("Pizza odebrana: " + delivery.poll());
        }
    }

    public void pizzaGuy(){
        synchronized (delivery){
            System.out.println("Pizza dostarczona");
            delivery.add("Pepperoni");
            //teraz musimy powiadomić wątek, który czekał
            delivery.notify();//to wybudzi wątek, który czekał
        }
    }
}

public class ThreadsWaitNotify {
    public static void main(String[] args) throws InterruptedException{
        //tworzymy obiekt i wątki
        House house = new House();
        Thread customer = new Thread(new Runnable() {//wątek klienta
            @Override
            public void run() {
                house.waitForDelivery();
            }
        });
        customer.start();//ten wątek będzie czekał, aż w delivery coś się zmieni
        Thread.sleep(3000);//symulujemy, że coś się z pizzą dzieje

        //kolejny wątek
        Thread producer = new Thread(new Runnable() {
            @Override
            public void run() {
                house.pizzaGuy(); //w tym wątku mamy dodanie elementu do delivery, a następnie wywołanie metody notify(), co spowoduje wybudzenie 1 wątku i wyświetlenie informacji, że pizza została dostarczona i element zostanie zdjęty z listy przez pool
            }
        });
        producer.start();
        customer.join();
    }
}

Interfejs Runnable

Zamiast korzystać z klasy Thread możemy skorzystać z interfejsu Runnable.
Pozwala to na rozszerzanie wielu klas.

Przykład:

class RunnableC implements Runnable{
    private int sleepTime;
    private String threadName;
 
    public RunnableC(int sleepTime, String threadName) {
        this.sleepTime = sleepTime;
        this.threadName = threadName;
    }

    @Override
    public void run() {
        for (int i=1; i<=10; i++){
            System.out.println(threadName + ", wartość: " + i);
            //chcemy uśpić wątek na sekundę
            try {
                Thread.sleep(sleepTime); //Thread.sleep usypia tylko aktualnie wykonywany wątek
            } catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
//jeżeli chcemy się pozbyć Thread możemy stworzyć nową klasę
class RunnableC2 extends RunnableC implements Runnable{
    private Thread thread;

    public RunnableC2(int sleepTime, String threadName) {
        super(sleepTime, threadName);
    }

    public void start(){
        if (thread == null){
            thread = new Thread(this);
            thread.start();
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        RunnableC t1 = new RunnableC(500, "Wątek 1 ");
        Thread th1 = new Thread(t1, "Wątek 1 ");
        th1.start();

        RunnableC t2 = new RunnableC(1000, "Wątek 2 ");
        Thread th2 = new Thread(t2, "Wątek 2 ");
        th2.start();

        RunnableC2 t3 = new RunnableC2(300, "Wątek 3 ");
        t3.start();
    }
}

Wątek na bazie klasy anonimowej

public class AnonimusRunnableExample {
    public static void main(String[] args) throws InterruptedException {/*nie będziemy robili przechwytywania ewentualnego błędu, zapiszemy że może taki wystąpić */

            Thread thread = new Thread(new Runnable() {//jak zaczniemy pisać new Ru... intellij podpowie {}
                @Override
                public void run() {
                    for (int i = 0; i < 5; i++) {
                        System.out.println("i = " + i);
                    }
                }
            });
            thread.start();

            //sprawdzimy czy wątek jest zakończony
            Thread.sleep(200);
            System.out.println(thread.getState());
    }
}

Wątki i Lambda

public class LambdaThread {
    public static void main(String[] args) {
        Thread thread = new Thread( () -> {
            for (int i=0; i<5; i++){
                System.out.println("i = " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });
        thread.start();
    }
}

Wątek demoniczny

Wątki demoniczne to najczęściej wątki, które monitorują stan aplikacji (jednym z takich wątków jest GarbageCollector),
nie wpływają bezpośrednio na działanie apki i mogą być „odgórnie” zakończone przez JVM, gdy kończy ona pracę z wątkami klienckimi np main.
Należy pamiętać , aby umieszczać w tych wątkach takie zadania, które mogą zostać gwałtownie przerwane.

Przykład:

public class ThreadsDemon {
    public static void main(String[] args) throws InterruptedException{
        //tworzymy nowy wątek
        Thread th = new Thread(new Runnable() {
            @Override
            public void run() {
                //tworzymy nieskończoną pętlę, bo i tak zostanie ona zamknięta gdy main się zakończy
                int i = 0; //tworzymy zmienną by podejrzeć działanie wątku w tle
                while(true) {
                    try{
                        Thread.sleep(1000);
                        System.out.println("Wątek demoniczny: " + i);
                        i++;
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        });
        //najpierw określamy czy wątek jest demoniczny, później starujemy
        th.setDaemon(true);
        th.start();
        //zapauzujmy nasz główny wątek kliencki
        Thread.sleep(5000);//w tym czasie będzie działał nasz wątek demoniczny, a po 5 sekundach zakończy się działanie wątków
        System.out.println("Zakończenie działania programu.");
    }
}

Zadanie: Napisz program – Zegar

import javax.swing.*;
import java.awt.*;
import java.time.LocalDateTime;
import java.time.chrono.ChronoLocalDateTime;

//skorzystamy z klasy JFrame i Runnable
public class Clock extends JFrame implements Runnable{

    //dodajemy prywatną zmienną, która będzie przechowywała aktualny wątek
    private Thread thread;

    //deklarujemy zmienne określające h, m i s
    String hour, min, sec;
    //teraz label, w którym przechowamy informację
    JLabel label;

    //tworzymy pusty konstruktor z wątkiem
    public Clock() {
        label = new JLabel("", JLabel.CENTER); //dodajemy nowy label
        label.setBounds(5,5,100,40); //ustawiamy położenie o wielkość labela
        add(label); //dodajemy nasz label do JFrame
        setSize(100,80); //wymiery okna
        setLayout(null);//mamy bounds więc ustawiamy null, nie określamy layoutu
        setVisible(true); //pokazujemy okienko
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //co się stanie po kliknięciu X

        thread =  new Thread(this);
        thread.start();
    }

    @Override
    public void run() {
        try{
            //tworzymy nieskończoną pętlę, bo czas będzie liczony bez końca
            while (true){
                //pobieramy aktualny czas
                LocalDateTime today = LocalDateTime.now();
                hour = "" + today.getHour();
                //sformatujemy wyświetlanie minut do 2 cyfr
                min = String.format("%02d",today.getMinute()); //przekazujemy 2 znaki i liczby całkowite stąd %2d, a jeżeli będzie pobrana pojedyncza liczba to dodajemy 0 stąd %02d
                sec = String.format("%02d",today.getSecond()); //przekazujemy 2 znaki i liczby całkowite stąd %2d, a jeżeli będzie pobrana pojedyncza liczba to dodajemy 0 stąd %02d

                //dodajemy informację do Labela
                label.setText(hour + ":" + min + ":" + sec);
                //przed zakończeniem pętli while uśpimy wątek na 1s
                thread.sleep(1000);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //tworzymy nową instancję zegara
        Clock clock = new Clock();
    }
}

Artykuł 21. JAVA – wątki pochodzi z serwisu Kama Kaczmarek.

Przykład:

import java.util.Optional;


public class OptionalExample {
    public static void main(String[] args) {
        //tworzymy Optional, który nie może być null za pomocą metody of()
        Optional<String> optional1 = Optional.of("Optional.of()");
        System.out.println(optional1.get());

        //jezeli stworzymy optional z null:
        //Optional<String> optional2 = Optional.of(null);//otrzymujemy błąd NullPointerException

        //metoda nullable - może posiadać wartość lub bycnull
        Optional<String> optional3 = Optional.ofNullable("Optional.ofNullable(\"Nie null\")");
        System.out.println(optional3);
        Optional<String> optional4 = Optional.ofNullable(null);
        System.out.println("tu mamy null i zwróci: " + optional4 + ", nie ma błędu.");

        //metoda empty tworząca pusty Optional
        Optional<String> optional5 = Optional.empty();
        System.out.println("pusty Optional zwróci: " + optional5 + ", nie ma błędu.");

        //tworzymy Optionala i wykorzystamy jego metody
        //tworzymy zmienną, która może mieć wartość lub null - nie wiemy co przechowuje
        String str = String.valueOf(0);
        //str=null; //spowosuje wyświetlenie komunikatu zmienna str jest null
        Optional<String> optStr = Optional.ofNullable(str);
        //pokaż kotku co masz w środku
        if (optStr.isPresent()){
            System.out.println(optStr.get());
        } else {
            System.out.println("zmienna str jest null");
        }

        //jeżeli wewnątrz Optionala jest wartość możemy wywołać lambdę
        optStr.ifPresent( i -> System.out.println(i));
        //referencja do metody
        optStr.ifPresent(System.out::println);

        //metoda map() pozwala na przekazanie funkcji jeżeli w obiekcie jest wartość, zwrócona wartość może być null
        Integer integer = Integer.valueOf(0);
        Optional<Integer> optInt = Optional.ofNullable(integer);
        Optional<Integer> res = optInt.map(i -> i+1);
        System.out.println(res);
        System.out.println(res.get());

        Integer integer1 = Integer.valueOf(0);
        Optional<Integer> optInt1 = Optional.ofNullable(integer1);
        optInt.map(i -> i+1)
                .map(i -> i * 100)
                .map(i -> i / 2)
                .ifPresent(System.out::println);

        Integer integer2 = null;
        Optional<Integer> optIntNull = Optional.ofNullable(integer2);
        Optional<Integer> resNull = optIntNull.map(i -> i+1);
        System.out.println(resNull); //to nam zwróci Optional.empty
        //System.out.println(resNull.get()); //ten zapis wygeneruje błąd: NoSuchElementException

        //jeżeli chcemy zwrócić domyślną wartość jeżeli nasz Optional jest null, to korzystamy z orElse
        System.out.println(resNull.orElse(666)); //ta wartość nie zostanie wyświetlona jeżeli optional nie będzie null

        //filtrowanie Optional poprzez wyrażenie lambda, jeżeli warunek zostanie spełniony to optional przekazywany jest dalej, jeżeli nie to otrzymamy pusty obiekt
        String str1 = "Nie pusty string";
        Optional<String> optS = Optional.ofNullable(str1);
        String test = optS.filter(s -> s.length() >0).orElse("Domyśny tekst");
        System.out.println(test);

        Optional<String> optS2 = Optional.ofNullable(null);
        optS2.map(s -> s + "blablabla")
                .filter(s -> s.length() >0)//jeżeli otional spełnia warunek to jest przekazywany dalej
                .or( () -> Optional.ofNullable("Nowy domyślny tekst"))//metoda or podstawia domyślną wartość jeżeli pojawi się pusty Optional
                .ifPresent(System.out::println);

        //metoda or i referencje
        String st = "Uwielbiam programować"; //zamień tekst na null
        Optional<String> os = Optional.ofNullable(st);
        String text = os.filter(s->s.length()>10)
                .or( () -> Optional.ofNullable("mamy null"))
                .map(String::toUpperCase)
                .map(String::trim)
                .orElse("i jestem tu");
        System.out.println(text);
    }
}

Artykuł 20. JAVA – klasa Optional pochodzi z serwisu Kama Kaczmarek.

Stream jest interfejsem generycznym,  doskonałą alternatywą dla przeglądania list przy pomocy pętli i przede wszystkim jest szybsza. Pozwala też na równoległe wykonywanie operacji na danych.

Przykład:

plik Products.java

public class Products {
    public String name;
    public int price;

    public Products(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Products{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

plik Car.java

import java.util.Comparator;
import java.util.Objects;

// w klasie musimy użyć Comparatoor do porównywania elementów, aby skutecznie stosować collect
public class Car implements Comparator<Car> {
    public String name;
    public int topSpeed;
    public int price;

    public Car(String name, int topSpeed, int price) {
        this.name = name;
        this.topSpeed = topSpeed;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", topSpeed=" + topSpeed +
                ", price=" + price +
                '}';
    }

    //dodajemy equals and hashcode
    //wybieramy z listy tylko name
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return name.equals(car.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    //implementujemy metodę compare
    //modyfikujemy zwracanie
    @Override
    public int compare(Car o1, Car o2) {
        return o1.name.compareTo(o2.name);
    }
}

plik StreamExample.java

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamExample {
    public static void main(String[] args) {
        //tworzymy zbiór, który następnie przefiltrujemy
        ArrayList<String> arl = new ArrayList<>();
        arl.add("PHP");
        arl.add("Python");
        arl.add("C++");
        arl.add("Java");
        arl.add("JS");
        arl.add("HTML");
        arl.add("CSS");


        //aby iterować po elementach użyjemy strumieniowania zamiast pętli
        //chcemy otrzymać listę elementów, których liczba znaków =3
        arl.stream().filter(someValue -> someValue.length()>=3 && someValue.length()<=6)//nie dajemy średnika, bo po kropce damy kolejne metody
                    //możemy dodatkowo przefiltrować ze względu na literę od jakiej sie zaczybnna nazwa
                    .filter(someValue -> someValue.startsWith("P") || someValue.startsWith("C"))
                    //iterujemy po elementach po przefiltrowaniu
                    .forEach(someValue -> System.out.println(someValue));

        //tworzymy listę na bazie klasy
        ArrayList<StreamMyClass> animals = new ArrayList<>();
        animals.add( new StreamMyClass("Elephant", 4000, 2));
        animals.add( new StreamMyClass("Python", 150, 5));
        animals.add( new StreamMyClass("ShiTzu", 7, 0));
        animals.add( new StreamMyClass("Wasp", 0, 7));
        animals.add( new StreamMyClass("Wife", 75, 10));

        //filtrujemy elementy własnej klasy po poziomie agresji
        animals.stream().filter(myName -> myName.agrresive>6)
                        .filter(myName ->  myName.weight>50 && myName.weight<100)
                        .forEach(myValue -> System.out.println(myValue));

        //otrzymane wyniki możemy dodać do innej kolekcji
        //służy do tego metoda collect()

        //tworzymy listę z wyników filtrowania
        List<StreamMyClass> list = animals.stream().filter(sth -> sth.agrresive>6)
                .collect(Collectors.toList());

        //teraz chcemy z wyników zrobić ArrayList
        ArrayList<StreamMyClass> arrl = new ArrayList<>(list);
        arrl.forEach(sth -> System.out.println(sth));

        //aby dodać do kolekcji tylko unikalne elementy użuwamy Set()
        //przykład1
        List<Integer> arr = Arrays.asList(8,-2,6,7,5,4,2,8,3,3,7,10,-11,2);
        Set<Integer> uniqueNumbers = arr.stream().collect(Collectors.toSet());
        System.out.println(uniqueNumbers);

        //przykład2
        ArrayList<String> arl1 = new ArrayList<>();
        arl1.add("PHP");
        arl1.add("PHP");
        arl1.add("Python");
        arl1.add("C++");
        arl1.add("C++");
        arl1.add("Java");
        arl1.add("JS");
        arl1.add("JS");
        arl1.add("HTML");
        arl1.add("CSS");
        Set<String> set = arl1.stream().filter(someValue -> someValue.length()>=3 && someValue.length()<=6)
                .filter(someValue -> someValue.startsWith("P") || someValue.startsWith("C"))
                .collect(Collectors.toSet());
        set.forEach(someValue-> System.out.println(someValue));

        //przykład z użyciem klasy Car
        ArrayList<Car> cars = new ArrayList<>();
        //dodajmy elementy, które będą zduplikowane
        cars.add(new Car("Peugeot", 270, 150000));
        cars.add(new Car("Ford", 250, 170000));
        cars.add(new Car("Peugeot", 270, 150000));
        cars.add(new Car("Mercedes", 240,200000));
        cars.add(new Car("Mercedes", 240,200000));
        cars.add(new Car("MBW", 280,260000));
        cars.add(new Car("Opel", 220, 140000));
        //użyjemy teraz collect() do wyciągnięcia unikalnych danych
        Set<Car> set1 = cars.stream().filter(car -> car.price<260000)
                .collect(Collectors.toSet());
        set1.forEach(car -> System.out.println(car));

        //sumowanie elementów za pomoca summingToInt na bazie klasy Products
        ArrayList<Products> product = new ArrayList<Products>();
        //dodajmy elementy
        product.add(new Products("apple", 3));
        product.add(new Products("banana", 4));
        product.add(new Products("pineaple", 4));
        product.add(new Products("bag", 1));
        product.add(new Products("perfume", 12));
        int totalPrice = product.stream()
                .collect(Collectors.summingInt(element -> element.price));
        System.out.println(totalPrice);

        //sumowanie elementów można teżprzeprowadzić za pomocą reduce()
        //skorzystamy z istniejącej listy arr
        int resultSum = arr.stream()
                //reduce(wartość starowa, (lambda z 2 argumentami: suma dotychczasowa i następny element)
                .reduce(0, (tempsum, el) -> tempsum+el);
        System.out.println("wynik sumowania reduce() " + resultSum);

        //sumowanie z referencją do metody
        int resultSumRef = arr.stream()
                .reduce(0, Integer::sum);
        System.out.println("Wynik sumowania redice() z referencją: " + resultSumRef);

        //zmapujmy teraz naszą listę po name
        Map<String, Products> producsMap = product.stream()
                .collect(Collectors.toMap(el->el.name, el->el));
        System.out.println(producsMap);
        //odwołajmy sie do konkretnego elementu mapy
        Products pr = producsMap.get("apple");
        System.out.println(pr);

        //referencja do metody
        List<Integer> producsPrices = product.stream()
                .filter(el->el.price<10)
                .map(Products::getPrice).collect(Collectors.toList());
        System.out.println(producsPrices);

        //kolekcję możemy przeszukać pod kątem największem i najmniejszej wartości
        //max()
        Products prodMaxPrices = product.stream().max((pr1, pr2) -> pr1.price>pr2.price ? 1 : -1)
                .get();
        System.out.println(prodMaxPrices);
        //min()
        Products prodMinPrices = product.stream().min((pr1, pr2) -> pr1.price>pr2.price ? 1 : -1)
                .get();
        System.out.println(prodMinPrices);

        //ograniczmy listę zwracanych wyników, wykorzystamy istniejącą litę arr
        List<Integer> result = arr.stream()
                .filter(el-> el > 0 && el <10)
                .limit(6)
                .collect(Collectors.toList());
        System.out.println(result);

        //aby zliczyc ilość elementów używamy count()
        System.out.println(result.stream().count());

        //jeżeli potrzebujemy stworzyć stream wypełniony wartościami, możemy zrobić to dwojako
        //z użyciem limit
        System.out.println("Stream z limitowaniem");
        Stream.iterate(0, i -> i+1).limit(10)
                .forEach(stream -> System.out.print(stream));
        //bez limit
        System.out.println("\nStream bez limitowania");
        Stream.iterate(0, i -> i<10, i -> i+1)
                .forEach(stream -> System.out.print(stream));

    }
}

plik StreamMyClass.java

//filtrowanie własnej klasy
//stwórzmy klasę dla klasyfikacji zwierząt pod kątem wagi i agresji
public class StreamMyClass {
    public String name;
    public int weight;
    public int agrresive; //1-10

    public StreamMyClass(String name, int weight, int agrresive) {
        this.name = name;
        this.weight = weight;
        this.agrresive = agrresive;
    }

    @Override
    public String toString() {
        return "StreamMyClass{" +
                "name='" + name + '\'' +
                ", weight=" + weight +
                ", agrresive=" + agrresive +
                '}';
    }
}

Artykuł 19. JAVA – strumieniowanie pochodzi z serwisu Kama Kaczmarek.

Wyrażenia lambda wykorzystujemy z interfejsami funkcyjnymi posiadającymi jedną abstrakcyjną metodę.

Interfejs funkcyjny może posiadać tylko jedną metodę abstrakcyjną, ale może posiadać wiele metod default i static. Metody default nie muszą być implementowane przez klasy korzystające z interfejsu (przydaje się to gdy już istniejący interfejs należy rozszerzyć).
Jeżeli w kodzie natrafimy na znak „->” oznacza on właśnie wykorzystanie lambdy.

Przykład:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.Predicate;

//tworzymy interfejs funkcyjny do mnożenia 2 intów
interface Multiplication{
    int multi(int x, int y);
}

//interfejs z metodą generyczną dzielenia
interface Division<T>{
    T div(T x, T y);
}

//krok4 - dodamy ogólny szablon dla działań matematycznych z typem generycznym
//będzie zracany wynik jakiegoś typu z metody, która będzie posiadała 2 parametry
//dzięki temu nie musimy definiować wielu interfejsów jw.
interface Operations<T>{
    T operate(T x, T y);
}

public class Lambda {

    //krok3 - przekazujemy wyrażenie lambda jako argument metody
    public void lambda(Multiplication multi){
        System.out.println("Wynik z metody pobierającej lambdę " + multi.multi(10,10));
    }

    public static void main(String[] args) {
        //krok1 - wykorzystujemy wyrażenie lambda
        Multiplication multi = (int x, int y) -> x * y;
        System.out.println("Mnożenie wynosi " + multi.multi(2,3));

        //krok2 - wykorzystujemy interfejs generyczny
        Division<Float> div = (Float x, Float y) -> {//użyjemy nawiasów klamrowych dla bloku kodu
            float d = x/y;
            return d;
        };//dajemy średnik, bo to koniec linijki kodu!
        float d = div.div(10f,2f);
        System.out.println("Dzielenie wynosi " + d);

        //cd krok3 - wykorzystamy metodę
        Lambda lambdaExampleWithMethod = new Lambda();
        lambdaExampleWithMethod.lambda(multi);
        lambdaExampleWithMethod.lambda( (x,y) -> (x+2) * y );//modyfikujemy dane, nie podaję typów, bo Java sama się domyśli

        //krok4 - wykorzystujemy szablon ogólny Operations
        Operations</*typ w zależności od potrzeb*/Integer> add = /*podpinamy teraz wyrażenie lambda*/ (x,y)->x+y;
        System.out.println("Metoda lambda z dodawaniem " + add.operate(5,6));

        Operations<Integer> multipl = (x,y)->x*y;
        System.out.println("Metoda lambda z mnożeniem " + add.operate(5,6));

        //wykorzystajmy wyrażenie lambda do sortowania elementów w tablicy ze względu na długość
        String[] arr = {"Python", "Java", "PHP", "C++", "HTML+CSS"};
        //korzystamy z metody sort dla Arrays
        Arrays.sort(arr, /*tworzymy wyrażenie lambda*/(x,y)->{return x.length() - y.length();});
        for (String a : arr) {
            System.out.println(a);
        }

        //wyrażenie lambda może korzystać z wbudowanych interfejsów funkcyjnych z pakietu java.util.functions
        //np. Predicate, żeby usunąć element z listy

        //tworzymy nową listę
        ArrayList<String> al = new ArrayList<>();
        al.add("PHP");
        al.add("Python");
        al.add(null);
        al.add("Java");
        al.add("C++");
        al.add("Pascal");
        al.add(null);

        //skorzystamy z metody removeIf
        //dodajmy na górze import pakietu functions
        //usuń element jeżeli x jest równe null lub jest równe "Pascal"
        al.removeIf( x -> x == null || x.equalsIgnoreCase("Pascal"));
        System.out.println(al); //otrzymujemy oczyszczoną listę


    }
}

Przykład: Wyrażenie lambda i default

@FunctionalInterface
interface Operators{
    int operate(int x, int y);

    default int add(int x, int y){
        System.out.println("Metoda add z interfejsu");
        return x+y;
    }
    default int subtract(int x, int y){
        System.out.println("Metoda subtract z intefejsu");
        return x-y;
    }
    default int multi(int x, int y){
        System.out.println("Metoda multi z intefejsu");
        return x*y;
    }
    static int divide(int x, int y){
        System.out.println("Metoda divide z intefejsu");
        return x/y;
    }
}

//tworzymy klasę implementującą nasz interfejs
class OperatorsClass implements Operators{

    //przesłaniamy metody abstrakcyjne

    @Override
    public int multi(int x, int y) {
        System.out.println("OperatorsClass.multi()");
        return x*y;
    }

    @Override
    public int operate(int x, int y) {
        System.out.println("OperatorsClass.operate()");
        return x+y;
    }

    //możemy wykorzystać domyślną implementację metody wewnątrz interfejsu

    @Override
    public int add(int x, int y) {
        //wywołamy metodę domyślną interfejsu
        System.out.println("OperatorsClass.add()");
        return Operators.super.add(x,y);
    }
}

public class LambdaAndDefaultMethods {
    public static void main(String[] args) {
        Operators math = (int x, int y) -> x * y;
        System.out.println(math.operate(5,2));

        System.out.println(Operators.divide(55,11));

        System.out.println(math.multi(5,2));

        OperatorsClass operatorsClass = new OperatorsClass();
        System.out.println(operatorsClass.operate(12,2));
        System.out.println(operatorsClass.multi(2,2));
        System.out.println(operatorsClass.subtract(20,10));
        System.out.println(operatorsClass.add(20,10));
    }
}

Referencja do metody

Z wyrażeniem lambda związane jest pojęcie referencji do metody.
Oznacza to, że możemy się odwołać do metody bez jej wywołania, potrzebuje jednak interfejsu funkcyjnego, gdyż referencja do metody tworzy instancję tegoż interfejsu.

Konstrukcja to: nazwaklasy::nazwametody.

Wykorzystamy referencję lambda do wyświetlenia hashu danego obiektu:

import java.util.function.IntSupplier;

public class LambdaReferenceToMethods {

    //stworzymy własną metodę wykorzystującą ntSupplier
    public void myFunction(IntSupplier intSupplier){
        System.out.println(intSupplier.getAsInt());
    }

    public static void main(String[] args) {
        Object obj = new Object();
        //wywołujemy interfejs funkcyjny zwracający int bezargumentowo - IntSupploer
        //jeżeli po obj damy kropkę zobaczymy listę dostępnych metod, ale my chcemy dostać się do metody poprzez referencję czyli wykorzystamy ::
        IntSupplier intSupplier = obj::hashCode;

        //wywołujemy metodę interfejsu funkcyjnego
        System.out.println(intSupplier.getAsInt());

        //tworzymy nową instancję z wykorzystaniem własnej metody
        //otrzymamy ten sam wynik jw
        LambdaReferenceToMethods lr = new LambdaReferenceToMethods();
        lr.myFunction(intSupplier);

    }
}

Lambda i Timer

Przykład wykorzystania lambdy wraz z klasą Timer do wyświetlania w okienku (klasa JFrame) aktualnego czasu co 1s.

import javax.swing.*;
import java.util.Date;

public class LambdaAndTimer extends JFrame {
    public static void main(String[] args) {
        //tworzymy okienko
        LambdaAndTimer lat = new LambdaAndTimer();
        lat.setTitle("Timer");//ustawiamy tytuł
        lat.setSize(300,100);//ustawiamy rozmiar okna
        lat.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//ustalamy co się stanie po naciśnięciu przycisku zamknięcia

        //miejsce gdzie będzie wyświetlany tekst w pojedynczej linijce
        JLabel lbl = new JLabel();
        lat.add(lbl);//dodajemy label do timera

        //wyświetlamy
        lat.setVisible(true);

        //tworzymy timer - ustawiamy czas na 1s(1000ms) i przekazujemy lambdę
        Timer timer = new Timer(1000, event ->{//aktualizujemy co 1s lbl i terminal
            Date date = new Date(); //pobieramy aktualną datę
            System.out.println(date.toString()); //wyświetlamy w terminalu
            lbl.setText(date.toString()); //wyświetlamy w label
        });
        //startujemy odliczanie
        timer.start();


    }
}

Artykuł 18. JAVA – wyrażenia Lambda pochodzi z serwisu Kama Kaczmarek.

plik GenericsExample.java

//stwórzmy klasę generyczną dla jednego typu, która będzie zawierała 2 pola oraz konstruktor, gettery i settery oraz toString

class Test<T>{//w nawiasie ostrym podajemy drukowanymi literami np. T(jak typ), K(klucz, V(wartość), E(element np. kolekcji), N(liczba) - dowolnie, później te litery przyjmą typ np. Integer, String...
    private T a;
    private T b;

    public Test(T a, T b) {
        this.a = a;
        this.b = b;
    }

    public T getA() {
        return a;
    }

    public void setA(T a) {
        this.a = a;
    }

    public T getB() {
        return b;
    }

    public void setB(T b) {
        this.b = b;
    }

    @Override
    public String toString() {
        return "Test{" +
                "a=" + a +
                ", b=" + b +
                '}';
    }
}


//stwórzmy teraz klasę generyczną dla wielu typów, która będzie zawierała 2 pola oraz konstruktor, gettery i settery oraz toString
class MultiTest<T, U, V>{//w nawiasie ostrym podajemy drukowanymi literami np. T, U, V - dowolnie, później te litery przyjmą typ np. Integer, String...
    private T x;
    private U y;
    private V z;

    public MultiTest(T x, U y, V z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public U getY() {
        return y;
    }

    public void setY(U y) {
        this.y = y;
    }

    public V getZ() {
        return z;
    }

    public void setZ(V z) {
        this.z = z;
    }

    @Override
    public String toString() {
        return "MultiTest{" +
                "x=" + x +
                ", y=" + y +
                ", z=" + z +
                '}';
    }
}


public class GenericsExample {
    public static void main(String[] args) {
        //przykład dla Integer
        Test<Integer> gnrInt = new Test<Integer>(1,2); //przyjmujemy typ Integer
        System.out.println(gnrInt.toString());

        //przykład dla String
        Test<String> gnrStr = new Test<String>("a","b"); //przyjmujemy typ String
        System.out.println(gnrInt.toString());

        //wywołamy teraz klasę generyczną dla wielu typów
        MultiTest<Integer, Float, String> multiTest = new MultiTest<>(1,2.5f, "String");
        System.out.println(multiTest.toString());
    }
}

Metody generyczne

Metody generyczne mogą się znajdować w dowolnej klasie, nie koniecznie generycznej.

Stwórzmy zwykłą klasę, która zawierać będzie metodę generyczną:

import java.util.ArrayList;

class SimpleClass{//zwykła klasa
    //metoda generyczna, która zwróci nam ostatni element ArrayList
    public static <E> E getLastElement(ArrayList<E> arl) {//przekazujemy ArrayList w argumencie
        return arl.get(arl.size() - 1);//pobieramy ostatni element listy
    }
}

public class GenericMethod {
    public static void main(String[] args) {
        //tworzymy ArrayList na bazie Integer
        ArrayList<Integer> arl = new ArrayList<>();
        arl.add(5);
        arl.add(15);
        System.out.println(SimpleClass.getLastElement(arl));//wywołujemy metodę z klasy
    }
}

Ograniczenia

Podczas pisania kodu możemy mieć potrzebę ograniczenia tego, co będzie podstawione pod typ generyczny np.  typ zmiennej lub klasa, która ma dziedziczyć tylko po konkretnej klasie:

plik GenericsExtends

import java.util.ArrayList;
import java.util.Iterator;

//tworzymy klasę bazową
class Person{
    private String name;

    //dodajemy konstruktor, gettery i settery oraz toString

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

//tworzymy klasę Employee, która rozszerzy klasę person
class Employee extends Person{
    private String jobTitle;

    //dodajemy konstruktor, gettery i settery oraz toString
    public Employee(String name, String jobTitle) {
        super(name);
        this.jobTitle = jobTitle;
    }

    public String getJobTitle() {
        return jobTitle;
    }

    public void setJobTitle(String jobTitle) {
        this.jobTitle = jobTitle;
    }

    @Override
    public String toString() {
        return "Employee{" +
                //ponieważ klasa rozszerza klasę Person, to mamy dostęp do pola name, które wyświetlimy
                "name=" + this.getName() + '\'' +
                "jobTitle='" + jobTitle + '\'' +
                '}';
    }
}

//tworzymy kolejną klasę
class Contractor extends Employee{
    public Contractor(String name, String jobTitle) {
        super(name, jobTitle);
    }
    @Override
    public String toString() {
        return "Contractor{" + super.toString() + "}";//łączymy toString z toString z Employee
    }
}

//poniższa klasa nie będzie dziedziczyła po Person, więc jej zastosowanie wygeneruje błąd
class Bug {
    private String name;

    //dodajemy konstruktor, gettery i settery oraz toString

    public Bug(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Bug{" +
                "name='" + name + '\'' +
                '}';
    }
}

//tworzymy klasę generyczną Organisation, która będzie posiadała ograniczenia
//zależy nam na tym, aby klasa Organisation mogła przyjmować jedynie klasy rozszerzające Person, żadne inne

class Organisation<T extends Person>{
    private ArrayList<T> participants;

    //tworzymy konstruktor, który stworzy zbiór konkretnego typu
    public Organisation() {
        participants = new ArrayList<T>();
    }

    //metoda dodająca uczestnika
    public void addParticipants(T p){
        participants.add(p);
    }

    //metoda pobierająca index
    public T getParticipants(int index){
        return participants.get(index);
    }

    //wyświetlenie uczestników
    public void printParticipants(){
        Iterator<T> iter = participants.iterator();
        while (iter.hasNext()){
            System.out.println(iter.next());
        }
    }
}

public class GenericsExtends {
    public static void main(String[] args) {
        //tworzymy nowy obiekt na bazie Organisation, który przyjmie typ Employee
        Organisation<Employee> org = new Organisation<>();
        org.addParticipants(new Employee("Jan","programmer"));
        org.addParticipants(new Employee("Iza","programmer"));
        org.addParticipants(new Contractor("Alek", "programmer"));

        org.printParticipants();

        //Organisation<Bug> test = new Organisation<Bug>(); //ta klasa nie rozszerza Person
    }
}

i kolejny przykład GenericExtends1.java

import java.util.ArrayList;
import java.util.Iterator;

class Country{
    private String name;

    public Country(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Country{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Continent extends Country{
    private String continentName;

    public Continent(String name, String continentName) {
        super(name);
        this.continentName = continentName;
    }

    public String getContinentName() {
        return continentName;
    }

    public void setContinentName(String continentName) {
        this.continentName = continentName;
    }

    @Override
    public String toString() {
        return "Continent{" +
                "country='" + super.getName() + '\'' +
                ", continentName='" + continentName + '\'' +
                '}';
    }
}

class World<T extends Country>{
    private ArrayList<T> parts;

    //tworzymy konstruktor, który stworzy zbiór konkretnego typu
    public World() {
        parts = new ArrayList<T>();
    }

    //metoda dodająca
    public void addParts(T p){
        parts.add(p);
    }

    //metoda pobierająca index
    public T getParts(int index){
        return parts.get(index);
    }

    //wyświetlenie uczestników
    public void printParts(){
        Iterator<T> iter = parts.iterator();
        while (iter.hasNext()){
            System.out.println(iter.next());
        }
    }
}

public class GenericExtends1 {
    public static void main(String[] args) {
        World<Continent> continent = new World<>();
        continent.addParts(new Continent("Poland", "Europe"));
        continent.addParts(new Continent("USA", "America N"));
        continent.addParts(new Continent("Germany", "Europe"));

        continent.printParts();;

    }
}

Artykuł 17. JAVA – typy generyczne pochodzi z serwisu Kama Kaczmarek.

Zamiast tworzyć tablicę, możemy użyć klasy ArrayList, z gotowymi metodami manipulującymi danymi.

Gdy korzystamy z metod ArrayList, musimy pamiętać, że należy rzutować typy, dlatego korzystając z kolekcji możemy od razu określić jaki typ danych będzie przechowywany.

Do obsługi danych w kolekcjach, możemy zastosować klasę Collections, która pozwala np. na sortowanie elementów

ArrayList

ArrayList jest tablicą, która może zostać zastąpiona inną, można jej używać do losowego pobierania danych i dodawania lub usuwania elementów.

Przykład:

import java.util.ArrayList;
import java.util.Collections;

public class ArrayList_Basics {
    public static void main(String[] args) {
        //tworzymy nowy obiekt ArrayList bez deklaracji typu
        ArrayList simpleList = new ArrayList();
        //dodajemy element do listy
        simpleList.add(new String("pierwszy tekst"));
        simpleList.add(new String("drugi tekst"));

        //pobieramy element listy, odwołujemy się do niego tak jak w tablicy, czyli po indeksie licząc od 0
        String element = (String)simpleList.get(0);//musimy dokonać rzutowania, bo przy deklaracji kolekcji nie określiliśmy typu
        System.out.println(element); //otrzymamy:pierwszy tekst

        //teraz skorzystamy z listy z deklaracją typu
        ArrayList<String> typedList = new ArrayList<>();//drugi raz nie musimy wpisywać typu
        //dodamy teraz nowe elementy, teraz będziemy mogli wybrać z listy String
        typedList.add("string 1");
        typedList.add("string 2");
        typedList.add("string 3");

        //pobieramy elementy
        String el = typedList.get(1);//nie musimy rzutować
        System.out.println(el);

        //przeglądamy kolekcję
        System.out.println("Lista:");
        for (String s: typedList){
            System.out.println(s);
        }

        //usuwamy elementy
        typedList.remove(2);
        System.out.println("Lista po usunięciu 3 elementu:");
        for (String s: typedList){
            System.out.println(s);
        }

        //dodamy element pod konkretny indeks - pozostałe się przesuną
        typedList.add(0,"string 0");
        System.out.println("Dodany element pod indeks 0:");
        for (String s: typedList){
            System.out.println(s);
        }

        //podmieniamy element listy
        typedList.set(2,"podmieniony element");
        System.out.println("Podmieniony element pod indeks 2:");
        for (String s: typedList){
            System.out.println(s);
        }

        //aby posortować elementy skorzystamy z klasy Collecttions
        System.out.println("Sortujemy:");
        Collections.sort(typedList);
        for (String s: typedList){
            System.out.println(s);
        }


    }
}

Metody ArrayList

Przetestujmy teraz możliwe metody ArrayList.

plik Person.java

//dodajemy nową prostą klasę operacyjną
public class Person {
    private String name; //ustawiamy prywatną zmienną

    //dodajemy konstruktor oraz gettery, settery i toString
    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

plik ArrayListMethods.java

import java.util.ArrayList;

public class ArrayListMethods {
    public static void main(String[] args) {
        //tworzymy nowe obiekty
        Person prs1 = new Person("Adam");
        Person prs2 = new Person("Anna");
        Person prs3 = new Person("Piotr");
        Person prs4 = new Person("Damian");
        Person prs5 = new Person("Jagoda");

        //dodajemy ArrayList z typem Person
        ArrayList<Person> al1 = new ArrayList<>();
        //dodajemy do listy obiekty utworzone wyżej
        al1.add(prs1);
        al1.add(prs2);
        al1.add(prs3);
        al1.add(prs4);
        al1.add(prs5);

        for (Person p : al1) {
            System.out.println(p);
        }

        //tworzymy nowe obiekty, które następnie będziemy dodawać do nowej listy
        //następnie nową listę dołączymy do istniejącej
        Person prs6 = new Person("Andrzej");
        Person prs7 = new Person("Julia");

        //tworzymy nową kolekcję
        ArrayList<Person> al2 = new ArrayList<>();
        //dołączamy nowe obiekty do listy al2
        al2.add(prs6);
        al2.add(prs7);

        //-------------------------------------------------
        //dołączamy drugą kolekcję do pierwszej kolekcji
        al1.addAll(al2);
        System.out.println("Uzupełniona kolekcja o nową kolekcję");
        for (Person p : al1) {
            System.out.println(p);
        }

        //--------------------------------------------------
        //czy dany element istnieje w kolekcji
        if (al1.contains(prs6)){
            System.out.println("al1 zawiera prs6");
        }

        //--------------------------------------------------
        //czy kolekcja zawiera wszystkie elementy innej kolekcji
        if (al1.containsAll(al2)){
            System.out.println("al1 zawiera elementy al2");
        }
        //jeżeli teraz dodalibyśmy do al2 nowy element to powyższy warunek zwróciłby false

        //--------------------------------------------------
        //usuwanie wszystkich elementów z jednej kolekcji, należących do innej kolekcji
        al1.removeAll(al2);
        if (al1.containsAll(al2)){
            System.out.println("al1 zawiera elementy al2");
        } else {
            System.out.println("al1 nie zawiera elementów al2");
        }

        //--------------------------------------------------
        //tworzenie tablicy z listy
        Person[] people = new Person[al1.size()];
        people = al1.toArray(people);
        System.out.println("Tablica stworzona z listy ma " + people.length + " elementów.");

        //--------------------------------------------------
        //czyszczenie kolekcji
        al1.clear();
        if (al1.isEmpty()){
            System.out.println("Kolekcja jest pusta");
        }
    }
}

Iterator

Iterator – alternatywa dla foreach. Do przeglądania kolekcji należy używać iteratora, pozwala on na uniknięcie błędów off-by-one oraz na jednolity sposób dostępu do struktur danych.

Przykład:

plik Animals.java

public class Animals {
    //stworzymy kilka prywatnych pól
    private String name, ocurrance;
    int size; //1-mały, 2-średni, 3-duży, 4-olbrzymi

    //dodajemy konstruktor
    public Animals(String name, String ocurrance, int size) {
        this.name = name;
        this.ocurrance = ocurrance;
        this.size = size;
    }

    //dodajemy gettery i settery
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getOcurrance() {
        return ocurrance;
    }

    public void setOcurrance(String ocurrance) {
        this.ocurrance = ocurrance;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    //dodajemy toString
    @Override
    public String toString() {
        return "Animals{" +
                "name='" + name + '\'' +
                ", ocurrance='" + ocurrance + '\'' +
                ", size=" + size +
                '}';
    }
}

plik ArrayListIterator.java

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListIterator {
    public static void main(String[] args) {
        //tworzymy kolekcję przechowującą typ Animal
        ArrayList<Animals> animal = new ArrayList<>();

        //uzupełniamy kolekcję
        animal.add(new Animals("Ryś", "Europe", 2));
        animal.add(new Animals("Frog", "All world", 1));
        animal.add(new Animals("Lion","Africa", 3));
        animal.add(new Animals("Medusa", "Oceans", 1));

        //Jak możemy iterować listy
        //1. pętla for
        System.out.println("\nPętla for:");
        for (int i = 0; i<animal.size(); i++){//możemy ją stosowac gdy chcemy rozpocząc iterację od innego elementu niż 0
            Animals animals = animal.get(i);
            System.out.println(animals);
        }
        
        //2. pętla foreach
        System.out.println("\nPętla foreach:");
        for (Animals animals : animal) {
            System.out.println(animals);
        }

        //3. Iterator
        System.out.println("\nIterator:");
        //iterator jest interfejsem, czyli pewnego rodzaju szablonem.
        Iterator<Animals> iterator = animal.iterator(); //jeżeli chcemy zobaczyć jakie metody udostępnia iterator, ustawiamy kursor na napisie Iterator i naciskamy ctrl+b lub ctrl+LPM
        //zastosujemy pętlę while, która sprawdzi, czy następny element listy istnieje
        while (iterator.hasNext()){
            Animals animals = iterator.next();//next() możemy użyć jeżeli wcześniej użyliśmy hasnext()
            System.out.println(animals);
        }

        //-----------------------------------------------------------------
        //METODY

        //domknięcia inaczej zwane wyrażeniem lambda - to taki skrócony zapis
        System.out.println("\nstosujemy wyrażenie lambda:");
        animal.iterator().forEachRemaining(element -> {
            System.out.println(element);
        });

        //tworzymy nową listę
        ArrayList<String> subject = new ArrayList<>();
        subject.add("PHP");
        subject.add("JAVA");
        subject.add("Python");
        subject.add("HTML");

        //usuwamy elementy
        System.out.println("Usuwanie elementów");
        Iterator<String> iterator1 = subject.iterator();
        while (iterator1.hasNext()){
            String str = iterator1.next();//next() możemy użyć jeżeli wcześniej użyliśmy hasnext()
            //System.out.println(animals1);
            if (str.equalsIgnoreCase("HTML")){
                iterator1.remove();
            }
            System.out.println(subject);
        }




    }
}

LinkedList

LinkedList ma takie same metody jak ArrayList, ale jest listą powiązaną, dwukierunkową.
Poszczególne elementy mają powiązania z sąsiadującymi elementami. Ten typ sprawdza się przy iteracji i wielu modyfikacjach.

Przykład:

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> ll = new LinkedList<>();
        ll.add("Pies");
        ll.add("Kot");
        String animal = "Papuga";
        ll.add(animal);
        System.out.println(ll);

        //dodawanie na początku
        ll.addFirst("Rybki");

        //dodawanie na końcu
        ll.addLast("Królik");

        System.out.println(ll);

        //pobieranie pierwszego elementu
        System.out.println(ll.getFirst());

        //pobieranie ostatniego elementu
        System.out.println(ll.getLast());

        //usuwanie pierwszego elementu
        System.out.println(ll.removeFirst());

        //usuwanie ostatniego elementu
        System.out.println(ll.removeLast());

        System.out.println(ll);

        //sprawdzamy czy element występuje na liście
        System.out.println(ll.contains(animal));

        ll.add("Pies");
        ll.add("Kot");
        System.out.println(ll);

        //usuwanie wystąpienia pierwszego
        System.out.println(ll.removeFirstOccurrence("Pies"));

        //usuwanie wystąpienia ostatniego
        System.out.println(ll.removeLastOccurrence("Kot"));

        System.out.println(ll);

        //dodawanie lub usuwanie elementów po indeksię będą wolniejsze niż w ArrayList ponieważ w LinkedList elementy są powiązane między sobą, posiadają referencje do sąsiadujących elementów
        ll.add(2,"królik");
        ll.set(0,"Rybki");
        System.out.println(ll.size());

    }
}

ListIterator

Do iteracji list wykorzystuje się ListIterator, który posiada wiele przydatnych metod.

import java.util.Iterator;
import java.util.LinkedList;
import java.util.ListIterator;

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

        LinkedList<String> ll = new LinkedList<>();
        ll.add("Pierwszy");
        ll.add("Dwa");
        ll.add("Trzy");
        ll.add("Cztery");

        //przeglądanie listy za pomoca while
        ListIterator<String> iterator = ll.listIterator();
        while(iterator.hasNext()){//sprawdzamy czy jest dostępny następny element
            String str = iterator.next();//pobieramy następny element

            if(str.equalsIgnoreCase("Pierwszy")){
                iterator.set("Jeden");//podmieniamy pobrany element na inny
            }
            if(str.equalsIgnoreCase("Cztery")){
                iterator.add("Pięć");//dodajemy kolejny element do listy
            }
        }


        ListIterator<String> iterator1 = ll.listIterator();
        while(iterator1.hasNext()){//sprawdzamy czy jest dostępny następny element
            String str = iterator1.next();

            if(str.equalsIgnoreCase("Pięć")){
                iterator1.remove();
            }
        }

        //wyświetlimy listę po zmianach
        System.out.println("Lista po zmianach:");
        Iterator<String> itr = ll.iterator();
        while(itr.hasNext()){
            System.out.println(itr.next());
        }

        //przeglądanie list od końca
        System.out.println("LIsta od tyłu:");
        ListIterator<String> iterator2 = ll.listIterator(ll.size());
        while (iterator2.hasPrevious()){//sprawdzamy czy jest dostępny poprzedni element
            String str = iterator2.previous();
            System.out.println(str);
        }
    }
}

HashSet

HashSet pozwala na stworzenie kolekcji elementów o unikalnym hashu, czyli unikalnym kodzie wyróżniającym dany element. HashSet nie pozwoli na dodanie do kolekcji więcej niż jednego unikalnego elementu.
Każdy kolejny element kolekcji ma swój unikalny hash.
HashSet nie zachowuje kolejności elementów.

Przykład:

plik Animals.java

//tworzymy przykładową klasę i dodajemy konstruktor, gettery, settery i toString

import java.util.Objects;

public class Animals {
    private String name;

    public Animals(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animals{" +
                "name='" + name + '\'' +
                '}';
    }

    //przesłaniamy metody celem uniknięcia problemu duplikaji elementów na liście
    //zaczynamy pisać public boolean i wybieramy opcję z listy, klikamy next... next.. itd

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false; //jeżeli przekazany obiekt jest null lub nie zgadzają się klasy to zwraca false
        Animals animals = (Animals) o; //konwertuje obiekt na  animals
        // poniższą linijkę modyfikujemy
        // return Objects.equals(name, animals.name);
        return this.name.equals(animals.getName()); //sprawdzamy czy nazwy są takie same
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }
}

plik HashSetExample.java

import java.util.HashSet;
import java.util.Iterator;

public class HashSetExample {
    public static void main(String[] args) {
        //spróbujemy rozwiązać problem, który może się zdarzyć podczas stosowania HashCode: kiedy nowo stworzony obiekt przypiszemy do zmiennej i dodamy do kolekcji, a następnie
        //dodamy następny element za pomocą add(), to oba elementy znajdą się na liście (będą miały różne hashe, a taką samą wartość)

        HashSet<Animals> animal = new HashSet<>();
        Animals animal1 = new Animals("dog"); //tworzymy nowy obiekt o unikalnym hashu
        //próbujemy dodać 2 razy ten sam obiekt - 2 razy ten sam hash
        animal.add(animal1);
        animal.add(animal1);//ten element nie zostanie dodany, bo na liście jest już element o takim hashu
        animal.add(new Animals("cat"));
        animal.add(new Animals("fish"));
        animal.add(new Animals("dog")); //ten element zostanie dodany pomimo, że "dog" już istnieje na liście, bo ma inny hash
        //przeglądamy naszą kolekcję
        Iterator<Animals> iterator = animal.iterator();//tworzymy iterator typu Animals - tak jak nazwa klasy
        while (iterator.hasNext()){
            Animals a = iterator.next();
            System.out.println(a);
        }
        /*
        W wyniku działania programu mamy 2 razy ten sam wpis, a tego chcemy uniknąć
        Animals{name='dog'}
        Animals{name='fish'}
        Animals{name='cat'}
        Animals{name='dog'}

        musimy przesłonić 2 metody w klasie Animals - equals i hashcode i to rozwiąże problem
         */
    }
}

TreeSet

TreeSet używamy do dużych zbiorów, sortuje on od razu rosnąco wszystkie elementy.
Do porównywania elementów tej samej klasy będziemy używali interfejsu Comparator i będziemy przesłaniali metodę compare.

import java.util.Iterator;
import java.util.TreeSet;


public class TreeSetExample {
    public static void main(String[] args) {
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(12);
        ts.add(10);
        ts.add(5);
        ts.add(25);

        //korzystamy z iteratora
        Iterator<Integer> it = ts.iterator();
        while (it.hasNext()){
            System.out.println(it.next()); //otrzymuje posortowaną rosnąco listę
        }

        //iteracja od końca
        Iterator<Integer> di = ts.descendingIterator();
        while (di.hasNext()){
            System.out.println(di.next());
        }
    }
}

TreeSet i Comparator

import java.util.Comparator;
import java.util.TreeSet;

/*
jeżeli w TreeSet korzystamy z własnych klas to używamy komparatora
 */
//stwórzmy klasę w tym samym pliku
class Animals{
    private String name;

    public Animals(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Animals{" +
                "name='" + name + '\'' +
                '}';
    }

}

//tworzymy nową klasę na bazie interfejsu Comparator, która umożliwi porównywanie elementów
class AnimalsComparator implements Comparator<Animals>
{
    //zaimplementujemy metody

    @Override
    public int compare(Animals o1, Animals o2) {
        //return 0;
        return o1.getName().compareTo(o2.getName());//tak porównamy 2 elementy
    }
}
public class TreeSetComparator {
    public static void main(String[] args) {
        TreeSet<Animals> animal = new TreeSet<>(new AnimalsComparator());//przekazujemy do konstruktora element AnimalsComparator
        animal.add(new Animals("dog"));
        animal.add(new Animals("cat"));
        animal.add(new Animals("fish"));
        animal.add(new Animals("rabbit"));

        for (Animals a : animal) {
            System.out.println(a);
        }
        /*
        Otrzymujemy posortowaną listę
        Animals{name='cat'}
        Animals{name='dog'}
        Animals{name='fish'}
        Animals{name='rabbit'}
         */
    }
}

HashMap

W języku Java nie istnieje tablica asocjacyjna, tak jak np. w PHP (tablica asocjacyjna pozwala na zamieanę indeksów liczbowych na słowne) i tu z pomocą przychodzi nam HashMap.
Iterując mapę musimy odwołać się do entrySet().

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

class Employee{
    private String name;

    public Employee(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                '}';
    }
}
public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Employee> map = new HashMap<>(); //w nawiasach<> przekazujemy pary klucz->wartość
        //dodamy teraz kilka elementów
        map.put("worker", new Employee("Andrzej"));
        map.put("manager", new Employee("Janina"));
        map.put("HR", new Employee("Stefan"));
        map.put("CEO", new Employee("Kasia"));

        //pobierzemy wartość przechowywaną w kluczu CEO
        Employee emp = map.get("CEO");
        System.out.println(emp);

        //wykonamy teraz iterację
        Iterator i = map.entrySet().iterator();
        //zastosowanie pętli while
        while (i.hasNext()){
            Map.Entry me = (Map.Entry) i.next(); //dokonujemy rzutowania
            String key = (String) me.getKey(); //pobieramy klucz
            Employee value = (Employee) me.getValue();//pobieramy wartość
            System.out.println(key + " - " + value);
        }
        //zastosowanie pętli foreach
        for (Map.Entry<String, Employee> e : map.entrySet()) {
            String key = e.getKey(); //pobieramy klucz
            Employee value = e.getValue();//pobieramy wartość
            System.out.println(key + " - " + value);
        }
    }
}

PriorityQueue

PriorityQueue(czyt. pioriti kju), kolejki

Przykład:

import java.util.PriorityQueue;

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

        //peek - pobiera element z kolejki, ale go nie usuwa
        //poll - wyciąga element z kolejki, usuwa go

        //tworzymy kolejkę priorytetów przechowującą liczby
        PriorityQueue<Integer> pqInt = new PriorityQueue<>();
        //dodajemy elementy do kolejki
        pqInt.add(17);
        pqInt.add(1);
        pqInt.add(66);
        pqInt.add(44);
        System.out.println(pqInt.peek()); //kolejka jest już posortowana, możemy to zobaczyć wyświetlając pierwszy element
        //celowo użyłam peek, aby nie usunąć elementu z kolejki

        //wylistujmy kolejkę
        //użyjemy metody poll, która usuwa elementy z kolejki więc po wylistowaniu wszystkich będzie pusta
        //korzystamy z pętli while, która ma się zatrzymać kiedy nie będzie elementów w kolejce
        while(!pqInt.isEmpty()){//sprawdzamy czy pqInt nie jest pusty
            System.out.println(pqInt.poll());
        }

        //dodamy następne elementy
        for (int i = 13; i > 10; i--) {
            pqInt.add(i) ;
        }

        //wyświetlamy pierwszy element kolejki
        System.out.println("pierwszy element kolejki: " + pqInt.peek());

        while(!pqInt.isEmpty()){//sprawdzamy czy pqInt nie jest pusty
            System.out.println(pqInt.poll());//listujemy kolejkę, widzimy że pierwszy element nadal jest
        }

        //już nic tam nie ma
        System.out.println("Końcowa PriorityQueue: " + pqInt);


        //SORTOWANIE KOLEJEK

        //Comparator - interfejs Javy, który służy do kontroli nad sortowaniem elementów

        //SORTOWANIE ROZSNĄCO
        //tworzymy kolejkę priorytetów przechowującą liczby z komparatorem rosnącym
        PriorityQueue<Integer> pqIntASC = new PriorityQueue<>(new PriorityQueueAndComparatorASC());//musimy przekazać do konstruktora nowy obiekt klasy PriorityQueueAndComparatorASC

        //dodajemy elementy do kolejki
        pqIntASC.add(17);
        pqIntASC.add(1);
        pqIntASC.add(66);
        pqIntASC.add(44);

        //wylistujmy kolejkę
        //użyjemy metody poll, która usuwa elementy z kolejki więc po wylistowaniu wszystkich będzie pusta
        //korzystamy z pętli while, która ma się zatrzymać kiedy nie będzie elementów w kolejce
        System.out.println("kolejka posortowana rosnąco przez komparator");
        while(!pqIntASC.isEmpty()){//sprawdzamy czy pqInt nie jest pusty
            System.out.println(pqIntASC.poll());
        }

        //SORTOWANIE MALEJĄCO
        //tworzymy kolejkę priorytetów przechowującą liczby z komparatorem malejącym
        PriorityQueue<Integer> pqIntDESC = new PriorityQueue<>(new PriorityQueueAndComparatorDESC());//musimy przekazać do konstruktora nowy obiekt klasy PriorityQueueAndComparatorDESC

        //dodajemy elementy do kolejki
        pqIntDESC.add(17);
        pqIntDESC.add(1);
        pqIntDESC.add(66);
        pqIntDESC.add(44);

        //wylistujmy kolejkę
        //użyjemy metody poll, która usuwa elementy z kolejki więc po wylistowaniu wszystkich będzie pusta
        //korzystamy z pętli while, która ma się zatrzymać kiedy nie będzie elementów w kolejce
        System.out.println("kolejka posortowana malejąco przez komparator");
        while(!pqIntDESC.isEmpty()){//sprawdzamy czy pqInt nie jest pusty
            System.out.println(pqIntDESC.poll());
        }

        //SORTOWANIE PO DŁUGOŚCI
        //tworzymy kolejkę przechowującą wpisy i będziemy je sortować wg długości znaków
        PriorityQueue<String> pqIntLength = new PriorityQueue<>(new PriorityQueueAndComparatorLength());//musimy przekazać do konstruktora nowy obiekt klasy PriorityQueueAndComparatorLength

        //dodajemy elementy do kolejki
        pqIntLength.add("mały");
        pqIntLength.add("najdłuższy");
        pqIntLength.add("średni");

        //wylistujmy kolejkę
        //użyjemy metody poll, która usuwa elementy z kolejki więc po wylistowaniu wszystkich będzie pusta
        //korzystamy z pętli while, która ma się zatrzymać kiedy nie będzie elementów w kolejce
        System.out.println("kolejka posortowana rosnąco przez komparator wg długości znaków");
        while(!pqIntLength.isEmpty()){//sprawdzamy czy pqInt nie jest pusty
            System.out.println(pqIntLength.poll());
        }


        //COMPARABLE vs COMPARATOR i SORTOWANIE PO PRIORYTECIE
        /*
        Poznaliście do tej pory Comparator, który pozwala porównać ze sobą 2 różne obiekty, np. gdy trzeba porównać ludzi wg wieku, imienia itp.
        Comparable pozwala porównać "siebie" z innym obiektem
        */
        //tworzymy nową kolejkę
        PriorityQueue<PriorityQueueAndComparable> comparable = new PriorityQueue<>();
        //stwórzmy sobie listę języków do nauczenia się z priorytetami
        comparable.add(new PriorityQueueAndComparable(1, "Python"));
        comparable.add(new PriorityQueueAndComparable(4, "PHP"));
        comparable.add(new PriorityQueueAndComparable(3, "Java"));
        comparable.add(new PriorityQueueAndComparable(2, "C++"));

        //te elementy będą z automatu porównywane z tymi, które znajdują się w kolejce
        while (!comparable.isEmpty()){
            System.out.println(comparable.poll());
        }

        //a teraz rozwiązanie powyższego z użyciem komparatora
        PriorityQueue<PriorityQueueAndComparator> comparator = new PriorityQueue<>();
        //stwórzmy sobie listę języków do nauczenia się z priorytetami
        comparable.add(new PriorityQueueAndComparable(1, "Python"));
        comparable.add(new PriorityQueueAndComparable(4, "PHP"));
        comparable.add(new PriorityQueueAndComparable(3, "Java"));
        comparable.add(new PriorityQueueAndComparable(2, "C++"));

        //te elementy będą z automatu porównywane z tymi, które znajdują się w kolejce
        while (!comparator.isEmpty()){
            System.out.println(comparator.poll());
        }
    }
}

PriorityQueue, Comparable i Comparator

Stworzymy listę priorytetów, którą musimy posortować na kilka sposobów:

plik PriorityQueueAndComparable.java

public class PriorityQueueAndComparable implements Comparable<PriorityQueueAndComparable>{

    //dodajemy 2 pola klasy
    private int priority;//pole z priorytetem zadania
    private String name;

    //dodajemy następujące elementy: konstruktor, gettery i settery oraz toString
    //implementujemy metodę CompareTo, którą musimy lekko zmodyfikować

    public PriorityQueueAndComparable(int priority, String name) {
        this.priority = priority;
        this.name = name;
    }

    public int getPriority() {
        return priority;
    }

    public void setPriority(int priority) {
        this.priority = priority;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "PriorityQueueAndComparable{" +
                "priority=" + priority +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    //będziemy porównywali ten element z tym co przekaże Java w nawiasie
    public int compareTo(PriorityQueueAndComparable o) {
        //ustawiamy wartość z tego obiektu jako "a" i przekazaną jako parametr wartość jako "b" i dokonujemy porównania
        int a = this.priority;
        int b = o.priority;
        if(a==b) return 0;
        if (a>b)
            return 1;
        else
            return -1;
    }
}

plik PriorityQueueAndComparator.java

import java.util.Comparator;

//tworzymy nową klasę, która implementuje metody z Comparator wykorzystując klasę PriorityQueueAndComparable
public class PriorityQueueAndComparator implements Comparator<PriorityQueueAndComparable> {
    //implementujemy metodę Compare

    @Override
    public int compare(PriorityQueueAndComparable o1, PriorityQueueAndComparable o2) {
        //porównamy 2 elementy o1 i o2
        int a = o1.getPriority();
        int b = o2.getPriority();
        if(a==b) return 0;
        if(a>b) //kolejność rosnąca
            return 1;
        else
            return -1;
    }
}

plik PriorityQueueAndComparatorLength.java

import java.util.Comparator;
//będziemy sortować wpisy wg długości znaków
public class PriorityQueueAndComparatorLength implements Comparator<String> {
    @Override
    public int compare(String str1, String str2) {
        return str1.length()-str2.length();//dla kolejności od najkrótszego do najdłuższego
        //return str2.length()-str1.length();//dla kolejności od najkrótszego do najdłuższego
    }
}

plik PriorityQueueAndComparatorASC.java

import java.util.Comparator;

//KOLEJNOŚĆ ROSNĄCA
//tworzymy klasę implementującą komparator
public class PriorityQueueAndComparatorASC implements Comparator<Integer> {
    //ALT+g i implementujemy metodę - compare, którą musimy lekko zmienić
    //sprawdzimy 3 warunki jeżeli elementy są równe, jeden jest mniejszy lub większy
    @Override
    public int compare(Integer x, Integer y) {
        if (x==y) return 0;
        if(x>y)
            return 1;
        else
            return -1;
    }
}

plik PriorityQueueAndComparatorASC.java

import java.util.Comparator;

//KOLEJNOŚĆ MALEJĄCA
//tworzymy klasę implementującą komparator
public class PriorityQueueAndComparatorDESC implements Comparator<Integer> {
    //ALT+g i implementujemy metodę - compare, którą musimy lekko zmienić
    //sprawdzimy 3 warunki jeżeli elementy są równe, jeden jest mniejszy lub większy
    @Override
    public int compare(Integer x, Integer y) {
        if (x==y) return 0;
        if(x<y)
            return 1;
        else
            return -1;
    }
}

Zadanie 1:

Napisz program, który sprawdzi czy podany element (target) znajduje się w posortowanej liście (numbers). Zadeklaruj:

listę postaci [1, 2, 3, 4, 5, 6, 7, 8, 9]

zmienną target = 7

Zasada działania algorytmu:

1. Ustalamy indeks startowy (start) oraz końcowy (end) oraz flagę flag = None.
2. Dopóki indeks startowy jest nie większy niż indeks końcowy wybieramy środkowy indeks (mid) listy (średnia arytmetyczna indeksu startowego i końcowego -> należy pamiętać o skonwertowaniu wyniku funkcją int). Jeżeli indeks startowy jest większy niż indeks końcowy kończymy działanie algorytmu.
3. Sprawdzamy czy element listy dla tak obliczonego indeksu jest naszym szukanym (target). Jeżeli tak, ustawiamy flagę flag na wartość True i kończymy działanie algorytmu. Jeżeli nie -> krok 4.
4. Sprawdzamy, czy wartość elementu listy dla indeksu mid jest mniejsza niż target. Jeśli tak, to zwiększamy indeks startowy o 1. Jeśli nie, zmniejszamy indeks końcowy o 1 i przechodzimy do kroku 2.

Po wykonaniu pętli while w zależności od wartości flagi flag wydrukuj do konsoli tekst: 'Znaleziono’, 'Nie znaleziono’.

Oczekiwany wynik:

Znaleziono

Zadanie 2: Zadeklaruj listę liczb:

items = [1, 3, 4, 5, 6, 9, 10, 17, 23, 24]

Napisz program, który usunie liczby nieparzyste i zwróci pozostałe. Wynik wydrukuj do konsoli.

Oczekiwany wynik:

[4, 6, 10, 24]

Zadanie 3:

Zadeklaruj listę liczb:

items = [1, 5, 3, 2, 2, 4, 2, 4]

Napisz program, który usunie duplikaty z listy (kolejność musi zostać zachowana).

Oczekiwany wynik:

[1, 5, 3, 2, 4]

Zadanie 10:

Podana jest poniższa lista:

project_ids = [’02134′, '24253′]

Sprawdź czy następujące id projektu:

project_id = '02135′

występuje w liście project_ids. Jeśli nie dodaj id tego projektu do listy. Następnie wydrukuj listę project_ids do konsoli.

Oczekiwany wynik:

[’02134′, '24253′, '02135′]

Zadanie 11:

Napisz program, który utworzy histogram – rozkład częstości w postaci słownika z podanych wartości:

items = [’x’, 'y’, 'z’, 'y’, 'x’, 'y’, 'y’, 'z’, 'x’]

W odpowiedzi utworzony słownik wydrukuj do konsoli.

Oczekiwany wynik:

{’x’: 3, 'y’: 4, 'z’: 2}

Zadanie 12:

Podana jest lista indeksów notowanych na GPW:

indexes = [

    „WIG”,

    „WIG-banki”,

    „WIG-budownictwo”,

    „WIG-CEE”,

    „WIG-chemia”,

    „WIG-energia”,

    „WIG-ESG”,

    „WIG-górnictwo”,

    „WIG-informatyka”,

    „WIG-leki”,

    „WIG-media”,

    „WIG-motoryzacja”,

    „WIG-nieruchomości”,

    „WIG-odzież”,

    „WIG-paliwa”,

    „WIG-Poland”,

    „WIG-spożywczy”,

    „WIG-telekomunikacja”,

    „WIG-Ukraine”,

    „WIG.GAMES”,

    „WIG.MS-BAS”,

    „WIG.MS-FIN”,

    „WIG.MS-PET”,

    „WIG20”,

    „WIG20dvp”,

    „WIG20lev”,

    „WIG20short”,

    „WIG20TR”,

    „WIG30”,

    „WIG30TR”,

    „WIGdiv”,

    „WIGtech”,

]

Dokonaj iteracji po liście indexes oraz wydrukuj do konsoli tylko te indeksy, które zwierają w nazwie ’20’ lub ’30’.

Oczekiwany wynik:

WIG20

WIG20dvp

WIG20lev

WIG20short

WIG20TR

WIG30

WIG30TR

Zadanie 13:

Podany jest słownik spółek z indeksu sektorowego WIG.GAMES. Kluczem jest 3-literowy kod spółki (ticker), wartością cena zamknięcia:

gaming = {

    ’11B’: 362.5,

    'CDR’: 297.0,

    'CIG’: 0.85,

    'PLW’: 318.0,

    'TEN’: 300.0

}

Przeprowadź iterację po słowniku. Wydrukuj kody (tickery) tych spółek, których cena zamknięcia jest większa niż 100.00 PLN.

Oczekiwany wynik:

11B

CDR

PLW

TEN

Zadanie 14: Podana jest lista imion wprowadzonych do systemu przez użytkowników (bez procesu walidacji):

names = [’Jack’, 'Leon’, 'Alice’, ’32-3c’, 'Bob’]

Sprawdź, czy każde imię jest poprawne (składa się tylko z liter). Jeżeli tak, wynik wydrukuj do konsoli w następującej postaci, np. Hello Jack!

Wskazówka: Użyj metody str.isalpha().

Oczekiwany wynik:

Hello Jack!

Hello Leon!

Hello Alice!

Hello Bob!

Artykuł 16. JAVA – kolekcje pochodzi z serwisu Kama Kaczmarek.

Mówimy, że wyjątki przechwytują błędy.

Wyjątki wyświetlają stosowną informację dla użytkownika w przypadku błędu i umożliwiają kontynuację pracy skryptu.

Wyjątki są obiektami klasy Exception, które posiadają własny komunikat i kod błędu. Mogą one zostać wyłapane (try), rzucone (throw) i przechwycone (catch).

try…, catch…

Przykład. Obsłużymy wyjątek polegający na odwołaniu się do nieistniejącego elementu w tablicy:

public class TryCatch {
    public static void main(String[] args) {
        int[] numbers = {0,1,2,3,4,5,6};
        try{
            int nr = numbers[7]; //nie ma takiego elementu w tablicy
        } catch(ArrayIndexOutOfBoundsException e) { //możemy w nawiasie podać ogólnie typ klasy "Exception e" lub jak w tym przypadku podać konkretny rodzaj wyjątku
            System.out.println("Wystąpił błąd");
            //jeżeli potrzebujemy dodatkowych informacji na temat błędu warto skorzystać z metody printStackTrace
            e.printStackTrace();
        }
        System.out.println("Po obsłużeniu błędu program kontynuuje swoją pracę");
    }
}

try…, catch…, finally…

Jeżeli chcemy, aby instrukcja zawsze wywołała się bez względu na powstanie wyjątku lub nie, używamy bloku finally. Możemy tą instrukcję wykonać np. gdy chcemy zamknąć dany zasób po wykonaniu operacji na plikach.

Przykład. (modyfikujemy powyższy)

public class TryCatchFinally {
    public static void main(String[] args) {
        int[] numbers = {0,1,2,3,4,5,6};
        try{
            int nr = numbers[7]; //nie ma takiego elementu w tablicy
        } catch(Exception e) {
            System.out.println("Wystąpił błąd: nie ma takiego elementu w tablicy");
        } finally {
            System.out.println("Instrukcja wywołana zawsze");
        }
        System.out.println("Po obsłużeniu błędu program kontynuuje swoją pracę");
    }
}

Przykład. Obsługa więcej niż 1 wyjątku.

public class TryCatchFinallyMoreThanOne {
    public static void main(String[] args) {
        int[] numbers = {0,1,2,3,4,5,6};
        try{
            int divide = 2/numbers[0]; //błąd dzielenia przez 0 - ten wyjątek wystąpi jako pierwszy więc ten komunikat się pojawi: Wystąpił błąd: nie wolno dzielić przez 0
            int nr = numbers[7]; //nie ma takiego elementu w tablicy
        } catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("Wystąpił błąd: nie ma takiego indeksu w tablicy");
        } catch (ArithmeticException e){
            System.out.println("Wystąpił błąd: nie wolno dzielić przez 0");
        } finally {
            System.out.println("Instrukcja wywołana zawsze");
        }
        System.out.println("Po obsłużeniu błędu program kontynuuje swoją pracę");
    }
}

Wiele wyjątków możemy zapisać razem, po znaku „|” np.

catch(ArrayIndexOutOfBoundsException | ArithmeticException e)... 

throw…

W zależności od potrzeb, wyjątki możemy też zgłaszać.

public class Throw {
    public static void main(String[] args) {
        try {
            int l1 = 2;
            int l2 = 0;

            //będziemy wykonywali dzielenie liczb, a jak wiemy nie można dzielić przez 0
            //jeżeli dzielnik będzie 0 to tworzymy nowy obiekt klasy wyjątku
            if (l2 == 0) throw new ArithmeticException();
            int divide = l1 / l2;
        } catch (ArithmeticException ae) {
            System.out.println("Wystąpił błąd arytmetyczny");
            ae.printStackTrace();//wyświetlamy szczegóły
        }
        System.out.println("Program kontynuuje pracę");
    }
}

Możemy zdefiniować własną klasę wyjątku, dziedziczy ona po klasie Exception:

import java.util.Random;

class MyException extends Exception{
    public MyException(){
        System.out.println("Error");
    }
}

public class ThrowClass {
    static void mozeZglosicWyjatek() throws MyException {
        int x = new Random().nextInt(5);
        if (x == 0) throw new MyException();
        System.out.println("Wylosowano " + x);
    }

    public static void main(String[] args) {
        try {
            mozeZglosicWyjatek();
        } catch (MyException me) {
            System.out.println("Wylosowano 0, zgłaszam wyjątek");
        }
        System.out.println("Program kontynuuje pracę");
    }
}

Wyjątki możemy zgłaszać poprzez metodę:

import java.util.Random;

public class ThrowMethod {
    void mozeZglosicWyjatek() throws Exception {
        int x = new Random().nextInt(5);
        if (x == 0) throw new Exception();
        System.out.println("Wylosowano " + x);
    }

    public static void main(String[] args) {

        ThrowMethod z = new ThrowMethod();
        try {
            z.mozeZglosicWyjatek();
        } catch (Exception e) {
            System.out.println("Wylosowano 0, zgłaszam wyjątek");
        }
        System.out.println("Program kontynuuje pracę");
    }
}

Przykład: Kalkulator.

import java.util.Scanner;

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

        System.out.println("Podaj pierwszą liczbę: ");
        String l1 = user_data.nextLine();

        System.out.println("Podaj drugą liczbę: ");
        String l2 = user_data.nextLine();

        System.out.println("Podaj znak: ");
        String sign = user_data.nextLine();

        try {
            int liczba1 = Integer.parseInt(l1);
            int liczba2 = Integer.parseInt(l2);

            switch (sign) {
                case "+":
                    int sum = liczba1 + liczba2;
                    System.out.println(l1+"+"+l2 + "=" +String.valueOf(sum));
                    break;
                case "-":
                    int minus = liczba1 - liczba2;
                    System.out.println(l1+"-"+l2 + "=" +String.valueOf(minus));
                    break;
                case "*":
                    int multi = liczba1 * liczba2;
                    System.out.println(l1+"*"+l2 + "=" +String.valueOf(multi));
                    break;
                case "/":
                    float divide = (float)liczba1 / (float)liczba2;
                    System.out.println(l1+"/"+l2 + "=" +String.valueOf(divide));
                    break;

                default:
                    System.out.println("Nierozpoznany wybór");
                    break;
            }
            /* //to samo tylko z ifami
            if(sign.equals("+")){
                int sum = liczba1 + liczba2;
                System.out.println(l1+"+"+l2 + "=" +String.valueOf(sum));
            } else if(sign.equals("-")){
                int minus = liczba1 - liczba2;
                System.out.println(l1+"-"+l2 + "=" +String.valueOf(minus));
            } else if(sign.equals("*")){
                int multi = liczba1 * liczba2;
                System.out.println(l1+"*"+l2 + "=" +String.valueOf(multi));
            } else if(sign.equals("/")){
                int divide = liczba1 / liczba2;
                System.out.println(l1+"/"+l2 + "=" +String.valueOf(divide));
            }
             */
        } catch (NumberFormatException e) {
            System.out.println("Pierwsza i druga wartość musi być liczbą");
        } catch (ArithmeticException e){
            System.out.println("Nie wolno dzilić przez 0");
        } finally {
            System.out.println("Wyjątki zostały obsłużone, program działa dalej.");
        }

    }
}

Artykuł 15. JAVA – wyjątki pochodzi z serwisu Kama Kaczmarek.

Klasa i obiekt

Kiedy mówimy o klasie musimy wyobrazić ją sobie jak ogólny zarys/opis jakiegoś obiektu, zbiór cech wspólnych dla np. człowieka. Gdybyśmy mieli klasę człowiek moglibyśmy określić ogólne cechy jakie definiują ludzi, czyli np. to że śpi, że ma głos, oczy, włosy, ręce, nogi itd.

Obiekt jest instancją danej klasy, czyli konkretnym człowiekiem np. Janem Kowalskim, który ma brązowe włosy, jest typem „skowronka” i ma niebieskie oczy. Te cechy nie są bezpośrednio związane z klasą, a z obiektem (instancją/wystąpieniem klasy).
Można powiedzieć, że Jan Kowalski jest zmienną typu klasy, czyli obiektem typu człowiek.

W Javie istnieje wiele „gotowych” klas, z których możemy korzystać. Zawierają one konkretne własności oraz metody. Poznaliście już klasę String, Integer i inne.

Już wiecie mniej więcej co to jest obiekt i klasa. Rozszerzając te zagadnienia możemy powiedzieć, że klasa jest schematem na bazie którego będziemy tworzyli obiekty np. mając projekt domu, możemy na jego podstawie stworzyć wiele podobnych do siebie domów.
Klasy możecie Tworzyć samodzielnie, mogą one zawierać zdefiniowane wartości i metody lub wykorzystywać wartości przekazane przez użytkownika.
Podsumowując – za pomocą jednej klasy możemy utworzyć wiele obiektów, czyli instancji naszej klasy, które będą niezależne od siebie.

Należy zapamiętać, że dobrą praktyką jest tworzenie nowej klasy w oddzielnym pliku.

Przykład:

Stwórzmy nowy plik/klasę o nazwie Person ustawimy w niej, że nasze obiekty będą miały imię i wiek:

plik Person.java

public class Person1 {
    String name;
    int age;
}

plik ObjectsAndClasses .java

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

        //tworzymy nową osobę
        Person osoba1 = new Person();
        osoba1.name = "Jan"; //ustawiamy imię
        osoba1.age = 18; //ustawiamy wiek

        //tworzymy jeszcze jedną osobę
        Person osoba2 = new Person();
        osoba2.name = "Anna"; //ustawiamy imię
        osoba2.age = 22; //ustawiamy wiek

        System.out.println(osoba1.name + " ma " + osoba1.age + " lat.");
        System.out.println(osoba2.name + " ma " + osoba2.age + " lat.");
    }
}

Przykład:

Stworzymy nowy obiekt wykorzystując klasę JFrame (należy zaimportować javax.swing.* na samej górze skryptu), dzięki której wywołamy okienko systemowe, czyli utworzymy instancję klasy.

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

        JFrame window = new JFrame();
        //podajemy nazwę typu/klasy + wymyślona nazwa = słówko "new" i nazwa klasy + ()

        //teraz nadamy rozmiar okienka
        //po wpisaniu nazwy zmiennej i postawieniu "." pokaże nam się lista dostępnych opcji
        window.setSize(600,600);

        //ustawimy tytuł
        window.setTitle("Moje pierwsze okienko");

        window.setVisible(true); // ustawiamy widoczność okienka na true
        //po uruchomieniu programu pokaże się małe okienko systemowe

Metody

Klasa może definiować metody, czyli nic innego jak funkcje z podejścia proceduralnego. Kiedy tworzymy obiekt nadajemy mu dostęp do metod danej klasy.

Możemy rozszerzyć powyższy przykład z osobą lub utworzyć nową klasę:

plik Person2.java:

import java.util.*; //import do metody określającej rok urodzenia

public class Person2 {
    String name;
    int age;

    //w Java istnieją tzw. gettery i settery, czyli metody pobierające lub ustawiające wartość, co do ich stosowania zdania są podzielone;
    //możemy zaimplementować je w Intellij automatycznie lub napisać samodzielnie
    //automatycznie: PPM -> Generate... (u mnie skrót Alt+G) -> Getter and Setter...

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name; //słówko this pozwala dostać się do pola w obiekcie, nie musimy go używać jeżeli nazwy argumentów i zmiennych się różnią
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }



    //METODY
    //ustawimy metodę, która wygeneruje powitanie
    public void sayHello(){
        System.out.println("Hello new Person! " + name);
    }

    //stworzymy metodę określającą rok urodzenia
    public void birthYear(){
        Calendar data = Calendar.getInstance();
        int by = data.get(Calendar.YEAR) - age;
        System.out.println("Rok urodzenia to:" + by);
        /*
        musimy zwrócić uwagę na to, że tak skonstruowana metoda nic nam nie zwraca.
        To oznacza, że nie otrzymamy fizycznie wartości, którą możemy wykorzystać gdzieś indziej, otrzymamy jedynie wyświetlony napis. Jeżeli chcemy uzyskać wartość musimy ją zwrócić używając słówka return.
         */
    }

    public int yearsToRetirement(){
        return 65 - age;
    }

    /*
    Pamiętamy z tematu JAVA – instrukcje sterujące, pętle i funkcje(metody), że metody mogą przyjmować argumenty. Czyli możemy przekazać bezpośrednio wartość przy wywołaniu metody
     */
    public void speak(String text){
        System.out.println(text);
    }

    public void move(String direction, double distance){
        System.out.println("Hurra, poszedłem " + direction + ", " + distance + " metrów");
    }

    //przeładujemy metodę
    public void speak(String text, int words){
        System.out.println(text + words + " wyrazy");
    }
}

plik Methods.java

package tutaj.nazwa.waszego.pakietu;

public class Methods {
    public static void main(String[] args) {
        /*
        Klasa może definiować metody, czyli nic innego jak funkcje z podejścia proceduralnego. Kiedy tworzymy obiekt nadajemy mu dostęp do metod danej klasy.
         */
        Person2 osoba2_1 = new Person2();

        /* tak ustawiamy dane bez getterów i setterów*/
        osoba2_1.name = "Ania"; //ustawiamy imię
        osoba2_1.age = 10; //ustawiamy wiek
        osoba2_1.sayHello(); //wyświetli: Hello new Person! Ania
        System.out.println(osoba2_1.name + " ma " + osoba2_1.age + " lat."); //wyświetli: Ania ma 10 lat.

        //wykorzystanie getterów i setterów do ustawiania wartości danych
        Person2 osoba2_2 = new Person2();

        osoba2_2.setName("Jan");
        osoba2_2.setAge(18);
        osoba2_2.sayHello(); //wyświetli: Hello new Person! Jan
        System.out.println(osoba2_2.getName() + " ma " + osoba2_2.getAge() + " lat."); //wyświetli: Jan ma 18 lat.


        //wywołujemy metodę sprawdzającą rok urodzenia
        //ona tylko wyświetla napis
        if (osoba2_1.age > 0) osoba2_1.birthYear();

        //wywołujemy metodę zwracającą lata do emerytury
        int yl = osoba2_1.yearsToRetirement();
        System.out.println("Do emerytury pozostało: " + yl + " lat");

        //wywołujemy metodę z 1 argumentem
        osoba2_1.speak("Cześć, nauczyłem się mówić :)");

        //wywołujemy metodę z 2 argumentami
        osoba2_1.move("prosto", 5);

        //wywołujemy przeładowaną metodę
        osoba2_1.speak("Wypowiedziałam dzisiaj ", 2);

        //argumenty do metody mogą być przekazywane przez zmienne
        String hello = "Hello everybody";
        osoba2_1.speak(hello);

    }
}

Konstruktory

Konstruktory, to metody wywoływane automatycznie w momencie tworzenia obiektu i nie wymagają dodatkowych akcji. Metody te występują tylko w kontekście klas, a ich nazwy są takie same jak nazwa klasy głównej.

Dzięki konstruktorowi możemy przesłać określone wartości do obiektu w momencie jego tworzenia.

plik Person3.java

public class Person3 {
    String name;
    int age;

    //tworzymy konstruktor bezargumentowy
    public Person3() {
        System.out.println("Obiekt klasy Person3 storzony - to ja, konstruktor bezargumentowy");
    }

    //konstruktor przyjmujący 1 argumant: imię lub wiek
    public Person3(String name) {
        this.name = name; //aby zmodyfikować konkretną zmienną w obiekcie możemy użyć słówka "this", ale tylko w sytuacji kiedy argument i zmienna mają takie same nazwy
    }

    //konstruktor przyjmujący 2 argumenty
    public Person3(String name, int age) {
        this.name = name;
        this.age = age;
    }
    /*
    możemy wewnątrz konstruktora wywołać inny konstruktor
    nie używamy wywołania np: Person("Ania",13), tylko zamiast nazwy konstruktora używamy "this"
    np: this("Ania",13)
     */
}

plik Constructors.java

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

        //tworzymy obiekt klasy Person3
        Person3 osoba3_1 = new Person3();
        /*
        wywoła się konstruktor bezargumentowy, bo w nawiasie nie podaliśmy danych
        po uruchomieniu skryptu otrzymamy napis:
        Obiekt klasy Person3 stworzony - to ja, konstruktor bezargumentowy
        został wywołany konstruktor w momencie tworzenia obiektu
        */

        /*
        możemy tworzyć wiele konstruktorów, rozróżniając je ilością przekazywanych argumentów
        */

        //tworzymy obiekt przekazując 1 argument - uruchomi się konstruktor z 1 argumentem
        Person3 osoba3_2 = new Person3("Kama");
        System.out.println("Przypisano imię " + osoba3_2.name);

        //tworzymy obiekt przekazując 2 argumenty - uruchomi się konstruktor z 2 argumentami
        Person3 osoba3_3 = new Person3("Anna", 22);
        System.out.println("Przypisano imię " + osoba3_3.name + " oraz wiek = " + osoba3_3.age);
    }
}

Modyfikatory dostępu

Do tej pory wykonywaliśmy przykłady w oparciu o publiczną dostępność danego elementu, czyli public.
Taka metoda lub właściwość jest publiczna, więc widoczna wszędzie wewnątrz obiektu i poza nim.
Dostęp do pola jest nieograniczony i można je odczytywać i zmieniać dowolnie.

Właściwość lub metoda może być prywatna, czyli private, wówczas może zostać użyta tylko wewnątrz obiektu.

Właściwość lub metoda protected może być użyta tylko wewnątrz obiektu, package, ale może być również dziedziczona.

Metoda domyślna – może być dostępna tylko wewnątrz tego package

Zaleca się w programowaniu i w życiu, nie udostępniać zbyt wiele informacji na zewnątrz, więc tego się trzymajmy – korzystamy z modyfikatorów private.

Kolejność restrykcji:
– private
– default
– protected
– public

np.
public void doSomethingPublic(){}
private void doSomethingPrivate(){}
protected void doSomethingProtected(){}
void doSomething(){}

I tutaj pojawia się pojęcie enkapsulacji, czyli hermetyzacji, która polega na zgrupowaniu danych i metod w obrębie jednej jednostki np. klasy.
Enkapsulacja pozwala również na ograniczenie dostepu do danych.

plik AccessModifiers.java

public class AccessModifiers {
    public static void main(String[] args) {
        //ustawiamy prywatne zmienne za pomocą setterów
        Frog frog1 = new Frog();
        frog1.setName("Bella");
        frog1.setAge(2);
        System.out.println("Żabcia " + frog1.getName() + " ma lat " + frog1.getAge());
    }
}

plik Frog.java

public class Frog {
    private String name;
    private int age;

    //jeżeli modyfikatory zmiennych będą private, nie będziemy mogli ich zmienić poza klasą,
    //jedyne co możemy zrobić to skorzystać z setterów
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Static i Final

Czasami istnieje potrzeba stworzenia zmiennej lub metody statycznej, czyli takiej, która nie jest przypisana do obiektu, a jedynie do klasy i może być wykorzystywana poza klasą.

Metody i właściwości statyczne to takie, które nie wymagają utworzenia obiektu, aby móc się do nich odwołać. Nadawane są dla całej klasy. Tworzymy je przy pomocy modyfikatora static.

plik Static_Final.java

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

        Thing something = new Thing();
        something.name = "Itit";
        something.showName();

        //teraz wykorzystamy static
        Thing.saluton = "Jestem statycznym powitaniem niezależnym od obiektów";
        Thing.showInfo();
        /*
        zwróćmy uwagę, że nie tworzymy nowego obiektu, ani nie odwołujemy się do metody, czy zmiennej przez obiekt.
        Podajemy nazwę klasy i po krropce wywołujemy wartości statyczne.
         */

        something.showNameSaluton();

        //STAŁE
        System.out.println(Thing.LUCK_NR); //ta wartość jest niezmienna

        //działanie statycznego licznika przedstawiam tutaj na dole, jednak należy pamiętać, że już 1 obiekt został stworzony wcześniej
        System.out.println("Stan licznika przed utworzeniem dodatkowych obiektów " + Thing.count);

        Thing something1 = new Thing();
        Thing something2 = new Thing();
        Thing something3 = new Thing();
        System.out.println("Stan licznika po utworzeniu dodatkowych obiektów " + Thing.count);


    }
}

plik Thing.java

public class Thing {
    public String name; //publiczna zmienna
    public static String saluton; //statyczna zmienna

    public void showName(){
        System.out.println(name);
    }

    public void showNameSaluton(){
        System.out.println(saluton + " - " + name);
    }

    public static void showInfo() {
        System.out.println(saluton);
        //System.out.println(name); takie odwołanie wygenerujee błąd, pamiętajmy, że to jest stałe w klasie, a obiekty przyjmują inne wartości
    }
    /*
     we wcześniejszych lekcjach korzystaliśmy ze stałych wbudowanych, np. liczby Pi z biblioteki Math
    stałą możemy stworzyć sami, wystarczy użyć słówka "final"
    Stała to właściwość klasy tylko do odczytu. Jak wiemy, stałe deklarujemy drukowanymi literami, są dostępne public i nie można ich modyfikować w kodzie.
    */
    public final static int LUCK_NR = 7;


    /*
    o ile idea istnienia stałych nikogo nie dziwi o tyle właściwości i metody statyczne już tak. Bo po co? A na przykład dla licznika utworzonych obiektów
     */
    //tworzę konstruktor, który za każdym razem, gdy zostanie utworzony nowy obiekt tej klasy doda 1 do licznika
    public static int count = 0;
    //teraz konstruktor,
    public Thing(){
        /*
        możemy stan licznika przy każdym obiekcie dodać do zmiennej i będziemy mieli np. id konkretnego obiektu
         */
        count++;
    }
}

Dziedziczenie

Inheritance, czyli dziedziczenie. Tak jak w życiu – jako potomkowie dziedziczymy po naszych przodkach pewne cechy (tak naprawdę to 50% od matki i 50% od ojca), tak samo klasy dziedziczą pola i metody, ale mogą zostać uzupełnione o inne elementy, których przodek nie posiada.

Jeżeli klasa przodka posiada pola i metody, które nie są prywatne lub są chronione, to klasa potomna również będzie je posiadać. Aby klasa dziedziczyła po innej należy użyć słówka extends i podać nazwę klasy przodka:

public class Car extends Machine{}

Klasa może dziedziczyć tylko po jednej klasie (rozszerzać tylko jedną klasę bazową ).

plik Machine.java

public class Machine {
    protected String type;

    Machine(){
        System.out.println("Wywołanie konstruktora z klasy nadrzędnej");
    }

    public void start(){
        System.out.println("Maschine started.");
    }
    public void stop(){
        System.out.println("Maschine stopped.");
    }
}

plik Car.java

/*
chcemy aby nasza klasa dziedziczyła wszystko po klasie Maschine
należy użyc słówka "extends"
 */
public class Car extends Machine{
    public void turn(){
        System.out.println("Car turned.");
    }
    //możemy nadpisać klasę dziedziczoną w klasie potomnej
    public void stop(){
        System.out.println("Car stopped.");
    }
    /*
    metody możemy nadpisywać automatycznie klikając (u mnie) Ctrl+o lub ALT+g lub wybierając z menu Code i "override methods"

    @Override
    public void start() {
        super.start(); //tą część możemy wykasować i podmienić na swoją wersję
    }
    */

    //możemy wywołać konstruktor z klasy nadrzędnej
    Car(){
        super();
    }
}

plik Inheritance.java

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

        Machine machine1 = new Machine();
        machine1.start();
        machine1.stop();

        Car car1 = new Car(); //tutaj zostanie wywołany konstruktor z klasy nadrzędnej
        car1.start(); //dostęp do odziedziczonej metody
        car1.turn(); //nowa metoda, tylko dla klasy Car, Maschine nie ma tej funkcjonalności
        car1.stop();//dostęp do odziedziczonej metody

        /*
        jeżeli nie chcemy, aby stworzona klasa była dziedziczona na początku wpisujemy "final", np. final class Example
         */

        //jeżeli zajdzie potrzeba sprawdzenia jakiej klasy instancją jest dany obiekt - oto rozwiązanie
        System.out.println(car1 instanceof Car); //true
        System.out.println(machine1 instanceof Car); //false
    }
}

Przykład:

plik App.java

public class App {
    public static void main(String[] args) {
        Car auto = new Car(270.0f);
        auto.Info();
    }
}

plik Car.java

public class Car extends Vehicle{
    public Car(float topSpeed) {
        //wywołujemy konstruktor klasy nadrzędnej
        super("Auto", topSpeed);
    }
}

plik Vehicle.java

public class Vehicle {
    protected String type;
    protected float topSpeed;

    public Vehicle(){
        type = "basic";
    }

    public Vehicle(String type, float topSpeed) {
        this.type = type;
        this.topSpeed = topSpeed;
    }

    protected void Info(){
        System.out.println("Typ pojazdu " + this.type + ", max szybkość " + this.topSpeed);
    }
}

Przykład:

plik App.java

public class App {
    public static void main(String[] args) {
        School t = new School(3, 316, "Technikum");
    }
}

plik Building.java

public class Building {
    public int numFloors;
    public int numClass;

    public Building(){
        numFloors = 3;
    }

    public Building(int numFloors, int numClass) {
        this.numFloors = numFloors;
        this.numClass = numClass;
        System.out.println("Budynek ma " + numFloors + " pięter oraz " + numClass + " sal lekcyjnych.");
    }
}

plik School.java

public class School extends Building{
    public String type = "Technikum";

    public School(int numFloors, int numClass, String type) {
        super(numFloors, numClass);
        System.out.println("Szkoła ma " + numFloors + " pięter " + numClass + " klas i jest to " + type);
    }
}

Polimorfizm

Polimorfizm to możliwość przybierania różnych form w zależności od wyboru podklasy.
Każdy obiekt klasy dziedziczącej jest tez obiektem klasy nadrzędnej.

plik Polymorphism.java

public class Polymorphism {
    public static void main(String[] args) {
        /*
        Polimorfizm to możliwość przybierania różnych form w zależności od wyboru podklasy
        Każdy obiekt klasy dziedziczącej jest tez obiektem klasy nadrzędnej.
         */

        Vehicle newCar = new Car("Auto");//nie ma dostępu do maxSpeed
        System.out.println(newCar.name);

        Vehicle newBicycle = new Bicycle("Rower"); //ma dostęp tylko do name
        System.out.println(newBicycle.name);

        //poniższy zapis jest nieprawidłowy
        //Car test = new Vehicle("test");

        //tłumacząc prościej - każde auto jest pojazdem, ale nie każdy pojaz jest autem
    }
}

plik Vehicle.java

public class Vehicle {
    public String name;

    public Vehicle(String name) {
        this.name = name;
    }
}

plik Car.java

public class Car extends Vehicle{
    public int maxSpeed;

    public Car(String name) {
        super(name);
    }
}

plik Bicycle.java

public class Bicycle extends Car{
    int numWheels;
    public Bicycle(String name){
        super(name);
    }
}

Przykład:

plik Company.java

public class Company {
    public static void main(String[] args) {
        Employee employee = new Employee("Kama", "Programmer", 10000);
        Manager manager = new Manager("Jan", "Team Leader", 11000, "R&D");
        Ceo ceo = new Ceo("Rafał", "Prezes", 20000, "Board", 100);

        Employee worker = ceo; //każdy ceo jest employee i ma dostęp do metod i własności tej klasy
        worker.doWork();
        Manager person = ceo;
        //wpisując nazwę obiektu po kropce możemy zobaczyć dostęp do metod i właściwości
    }
}

plik Employee.java

public class Employee {
    private String name;
    private String jobTitle;
    private int salary;

    public Employee(){
        name = "unknown";
        jobTitle = "unknown";
        salary = 2500;
    }

    public Employee(String name, String jobTitle, int salary) {
        this.name = name;
        this.jobTitle = jobTitle;
        this.salary = salary;
    }

    public void doWork(){
        System.out.println("Working!");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getJobTitle() {
        return jobTitle;
    }

    public void setJobTitle(String jobTitle) {
        this.jobTitle = jobTitle;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }
}

plik Manager.java

public class Manager extends Employee{
    private String departmentName;

    public Manager() {
        super();
        departmentName = "unknown";
    }

    public Manager(String name, String jobTitle, int salary, String departmentName) {
        super(name, jobTitle, salary);
        this.departmentName = departmentName;
    }

    public void hireEmployee(){
        System.out.println("Employee hired!");
    }
    public void giveRise(Employee employee){
        System.out.println("Employee got rise!");
    }

    public String getDepartmentName() {
        return departmentName;
    }

    public void setDepartmentName(String departmentName) {
        this.departmentName = departmentName;
    }
}

plik Ceo.java

public class Ceo extends Manager{
    private int sharesNumber;

    public Ceo() {
        sharesNumber = 100;
    }

    public Ceo(String name, String jobTitle, int salary, String departmentName, int sharesNumber) {
        super(name, jobTitle, salary, departmentName);
        this.sharesNumber = sharesNumber;
    }

    public void signContract(){
        System.out.println("Contract signed!");
    }

    public int getSharesNumber() {
        return sharesNumber;
    }

    public void setSharesNumber(int sharesNumber) {
        this.sharesNumber = sharesNumber;
    }
}

Przykład:

plik PolymorphismCasting.java

public class PolymorphismCasting {
    public static void main(String[] args) {
        Employee employee[] = new Employee[10];
        employee[0] = new Manager("Dyrektor", 10000); //typ Manager
        employee[0].printName();
        employee[1] = new Employee("Programista", 12000);
        employee[1].printName();

        /*
        w takiej sytuacji jeżeli chcemy, aby dyrektor mógł dać podwyżkę to musimy
        rzutowac jego typ na Managera, bo typ employee nie posiada takiej metody
         */

        Manager manager = (Manager) employee[0];
        manager.giveRise(employee[1], 0.15f);
        employee[1].printName();
    }
}

plik Employee.java

public class Employee {
    protected int salary;
    protected String name;
    public Employee(String name, int salary){
        this.name = name;
        this.salary = salary;
    }
    public void printName(){
        System.out.println("Employee: " + name + ", salary: " + salary);
    }
}

plik Manager.java

public class Manager extends Employee{
    public Manager(String name, int salary) {
        super(name, salary);
    }
    public void printName(){
        System.out.println("Manager: " + name + ", salary: " + salary);
    }
    public void giveRise(Employee e, float percent){
        e.salary+=(int)(e.salary*percent);
    }
}

Klasy i metody abstrakcyjne oraz interfejsy

Klasa abstrakcyjna definiuje pewien model i zachowanie obiektu.
Taka klasa nie posiada definicji tych metod, jedynie ich deklaracje, że gdzieś dalej w kodzie muszą się pojawić. Czyli do czasu rozszerzenia ich o funkcjonalności w klasach dziedziczących, te metody nie istnieją (są abstrakcją).
Metody abstrakcyjne definiujemy w klasie bazowej klauzulą abstract. Wszystkie tego typu zadeklarowane metody będą musiały pojawić się w klasach dziedziczących.
Nie można utworzyć obiektu klasy abstrakcyjnej. Klasa ta jest jedynie „bazą” dla klas potomnych.
Można przypisać podklasę do zmiennej typu abstrakcyjnego.
Pamiętamy, że klasę dziedziczymy i możemy zrobić to tylko raz.

Interfejs jest zbiorem metod jakie wymagamy by posiadała klasa, która go implementuje.
Możemy implementować wiele interfejsów dla jednej klasy.
Wszystkie metody określane w interfejsie są abstrakcyjne.

Przykład:

plik AbstractClassesAndInterfaces.java

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

        //CelestialBody earth = new CelestialBody();
        //powyższe wywołanie generuje błąd, bo nie ma czegoś fizycznego co się nazywa ciało niebieskie. To tylko pojęcie określające różne elementy
        Planet earth = new Planet();
        earth.setName("Ziemia");
        System.out.println(earth.getName());
        earth.round();

        Star sun = new Star();
        sun.round();

        earth.showInfo();
    }
}

plik CelestialBody.java

public abstract class CelestialBody {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //tworzymy nazwę metody, którą musi mieć każda klasa dziedzicząca metodę abstrakcyjną
    public abstract void round();


}

plik Info.java

public interface Info {
    public void showInfo();
}

plik Planet.java

public class Planet extends CelestialBody implements Info {
    @Override
    public void round() {
        System.out.println("jestem planetą - kręce się");
    }

    @Override
    public void showInfo() {
        System.out.println("Implementuję metodę wspólną dla obu klas");
    }
}

plik Star.java

public class Star extends CelestialBody implements Info {

    @Override
    public void round() {
        System.out.println("Jestem gwiazdą - nie kręcę się");
    }

    @Override
    public void showInfo() {
        System.out.println("Implementuję metodę wspólną dla obu klas");
    }
}

Różnice między interfejsem, a klasą abstrakcyjną

• klasa może implementować wiele interfejsów, ale rozszerzać tylko jednego rodzica
• metody w interfejsie są publiczne, w klasie publiczne lub chronione
• interfejs może zawierać tylko deklaracje metod, a klasa też metody zdefiniowane
• klasy abstrakcyjne mogą zawierać atrybuty(pola), interfejsy nie
• w interfejsach wszystkie metody są abstrakcyjne, natomiast w klasie abstrakcyjnej można stworzyć metody posiadające ciało, jak i abstrakcyjne
• klasa abstrakcyjna zazwyczaj jest ściśle związana z klasami dziedziczącymi w sensie logicznym, czyli np. tworzymy klasę abstrakcyjną Planeta po której dziedziczą konkretne klasy planet (np. Ziemia, Mars).
• Interfejs natomiast nie musi być już tak mocno związany z daną klasą, on określa jej cechy, np możesz stworzyć interfejs Zniszczalny, który mówi że dany obiekt może zostać zniszczony. Taki interfejs możesz nadać zarówno klasą Planeta, Gwiazda, Budynek itp.
• interfejs może dziedziczyć jedynie po innych interfejsach, a klasa abstrakcyjna może dziedziczyć po klasach abstrakcyjnych, interfejsach a nawet zwykłych klasach
• interfejs nie może mieć konstruktora, w klasie abstrakcyjnej możemy dostarczyć implementację konstruktora domyślnego

Przykład:

plik Interface.java

public class Interface {
    public static void main(String[] args) {
        Car car = new Car();
        car.move();

        // możemy zapimplementować obiekt tak:
        // Vehicle vehicle = new Car();
        //lub tak:
        Vehicle vehicle = car;
        System.out.println(vehicle.speed());

        Vehicle car2 = new Car();
        car2.turn();

        Car car3 = (Car) car2; //rzutowanie
        car3.stop();

        Train train = new Train();
        Vehicle trainVehicle = train;
        System.out.println(trainVehicle.speed());

        Plain plain = new Plain();
        plain.increaseHeight();

        Vehicle vehicles[] = new Vehicle[4];
        vehicles[0] = car;
        vehicles[1] = car2;
        vehicles[2] = train;
        vehicles[3] = plain;

        vehicles[2].move();

        if (vehicles[2] instanceof Train){
            Train someTrain = (Train) vehicles[2];
            someTrain.turn();
        }

        if (vehicles[3] instanceof Plain){
            Plain somePlain = (Plain) vehicles[3];
            somePlain.decreaseHeight();

            Flying flyingVehicle = somePlain;
            flyingVehicle.increaseHeight();
        }
    }
}

plik Flying.java

public interface Flying {
    void increaseHeight();
    void decreaseHeight();
}

plik Vehicle.java

public interface Vehicle {
    void move(); // nie musimu podawać modyfikatora public
    void stop();
    void turn();
    float speed();
}

plik Car.java

public class Car implements Vehicle{
    @Override
    public void move() {
        System.out.println("Car is moving!");
    }

    @Override
    public void stop() {
        System.out.println("Car stopped!");
    }

    @Override
    public void turn() {
        System.out.println("Car is turning!");
    }

    @Override
    public float speed() {
        return 220;
    }
}

plik Plain.java

//wiele interfejsów
public class Plain implements Vehicle, Flying{
    @Override
    public void move() {
        System.out.println("Plain is moving!");
    }

    @Override
    public void stop() {
        System.out.println("Plain stopped!");
    }

    @Override
    public void turn() {
        System.out.println("Plain turn!");
    }

    @Override
    public float speed() {
        return 900;
    }

    //implementujemy metody z obu interfejsów

    @Override
    public void increaseHeight() {
        System.out.println("Plain up!");
    }

    @Override
    public void decreaseHeight() {
        System.out.println("Plain down!");
    }
}

plik Train.java

public class Train implements Vehicle{
    @Override
    public void move() {
        System.out.println("Train is moving!");
    }

    @Override
    public void stop() {
        System.out.println("Train stopped!");
    }

    @Override
    public void turn() {
        System.out.println("Train turn!");
    }

    @Override
    public float speed() {
        return 180;
    }
}

Przykład:

plik interface_extends_default_static_final.java

public class Train implements Vehicle{
    @Override
    public void move() {
        System.out.println("Train is moving!");
    }

    @Override
    public void stop() {
        System.out.println("Train stopped!");
    }

    @Override
    public void turn() {
        System.out.println("Train turn!");
    }

    @Override
    public float speed() {
        return 180;
    }
}

plik Animal.java

public interface Animal {
    int getNumLegs();
    String getName();
}

plik Bird.java

//rozszerzamy wiele interfejsów
public interface Bird extends Animal,Eating,Flying{

}

plik Eating.java

public interface Eating {
    void eat();
    default void searchForFood(){
        System.out.println("Searching for food.");
    }
}

plik Flying.java

public interface Flying {
    //możemy dodać zmienną statyczną
    static final float DEFAULT_WINGSPAN = 0.7f;
    void fly();

    default void flyHigher(){
        System.out.println("Flying higher.");
    }

    default float getWingspan(){
        return Flying.DEFAULT_WINGSPAN;
    }

    static int getDefaultNumWings(){
        return 2;
    }
}

plik Parrot.java

public class Parrot implements Bird{
    @Override
    public int getNumLegs() {
        return 2;
    }

    @Override
    public String getName() {
        return "Parrot";
    }

    @Override
    public void eat() {
        System.out.println("Eating.");
    }

    @Override
    public void fly() {
        System.out.println("Parrot is flying.");
    }

    //możemy nadpisac metodę domyslną, jeżeli np nam się nie podoba

    @Override
    public void searchForFood() {
        System.out.println("Parrot is searching for food.");
    }
}

Przykład:

plik MouseListenerExample.java

import javax.swing.*;

public class MouseListenerExample {
    public static void main(String[] args) {
        Frame frame = new Frame();
        frame.setSize(300,300); //wielkość okienka
        frame.setTitle("Przykład"); //tytuł okienka
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//co ma zrobić aplikacja jeżeli użytkownik będzie chciał ją zamknąć
        frame.setLayout(null);//wymuszamy położenie na taką pozycję jak my ustawiliśmy
        frame.setVisible(true);//pokazujemy okienko
        frame.addMouseListener(frame);
    }
}

plik Frame.java

//korzystamy z wbudowanej klasy JFrame oraz wbudowanego interfejsu MouseListener
import javax.swing.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class Frame extends JFrame implements MouseListener {

    //jeżeli nie chcemy uzyskiwać wyników kliknięć w konsoli, tylko w okienku musimy dodać JLable
    private JLabel label;
    public Frame(){
        label = new JLabel("---");
        label.setBounds(10,10,250,50);//określamy wielkość pola
        this.add(label);
    }

    //alt+g i implementujemy wszystkie metody
    @Override
    public void mouseClicked(MouseEvent e) {
        //pobieramy współrzędne kliknięcia w okienku
        int x = e.getX();
        int y = e.getY();

        String str = "Kliknięto x: "+x+" y: "+y;
        label.setText(str);

        System.out.println(str);
    }

    @Override
    public void mousePressed(MouseEvent e) {

    }

    @Override
    public void mouseReleased(MouseEvent e) {

    }

    @Override
    public void mouseEntered(MouseEvent e) {

    }

    @Override
    public void mouseExited(MouseEvent e) {

    }
}

Klasy wewnetrzne

W java istnieje opcja zadeklarowania klasy wewnętrznej, czyli klasy w klasie. Istnieje kilka opcji:
– klasa prywatna wewnątrz klasy może być używana tylko w niej
– klasa publiczna może zostać zainicjowana po podaniu nazwy klasy głównej, a następnie po kropce klasy wewnętrznej

Przykład

plik ClassPrvPub.java

public class ClassPrvPub {
    //wewnętrzna prywatna klasa
    private class PrivCls{
        public void printInfo(){
            System.out.println("Jestem z prywatnej wewnętrznej klasy.");
        }
    }

    //wewnętrzna prywatna klasa
    public class PubCls{
        public void printInfo(){
            System.out.println("Jestem z publicznej wewnętrznej klasy.");
        }
    }

    //publiczna metoda wykorzystująca wewnętzną prywatną klasę
    public void run(){
        PrivCls prvCls = new PrivCls();
        prvCls.printInfo();

        //możemy zadeklarować klasę wewnątrz metody
        class ClassInMethod{
            public void printInfo(){
                System.out.println("Klasa wewnątrz metody");
            }
        }
        ClassInMethod innerClass = new ClassInMethod();
        innerClass.printInfo();
    }
}

plik InnerClass.java

public class InnerClass {
    public static void main(String[] args) {
        //tworzymy obiekt klasy ClassPrvPub
        ClassPrvPub privExample = new ClassPrvPub();
        //wywołujemy metodę
        privExample.run();

        //tworzymy obiekt publicznej klasy
        ClassPrvPub.PubCls pubClass = privExample.new PubCls();
        pubClass.printInfo();
    }
}

Klasa Object

Klasa Object jest bazową klasą Javy, każdy nowo tworzony obiekt rozszerza klasę Object.
Klasa ta posiada wiele przydatnych metod, część z nich juz poznaliście np. equals, to String itp.

Przykład

plik CarObject.java

public class CarObject {
    private String manufacturer;
    private String model;
    private String color;

    //dodajemy konstruktor Alt+g lub Alt+Insert lub...
    public CarObject(String manufacturer, String model, String color) {
        this.manufacturer = manufacturer;
        this.model = model;
        this.color = color;
    }

    //przesłonimy teraz metodę toString, żeby wyświetlała więcej czytelnych informacji
    //Alt+g i wybieramy toString
/*
    @Override
    public String toString() {
        return "CarObject{" +
                "manufacturer='" + manufacturer + '\'' +
                ", model='" + model + '\'' +
                ", color='" + color + '\'' +
                '}';
    }*/
}

plik ObjectExample.java

//jak przesłonić metodę toString
public class ObjectExample {
    public static void main(String[] args) {
        CarObject car = new CarObject("Ford", "Focus","blue");
        CarObject car2 = new CarObject("Peugeot", "307SW", "blue");
        System.out.println(car); //zostanie wykorzystana automatycznie metoda toString i wyświetli: all.ObjectClass.CarObject@378bf509, po przesłonięciu metody otrzymamy bardziej czytelne informacje
        System.out.println(car.hashCode());//unikalna liczba na bazie CarObject

        //sprawdzimy czy obiekty wskazują na to samo miejsce w pamięci
        if(car.equals(car2)){
            System.out.println("Obiekty wskazują na tą samą referencję, czyli miejsce w pamięci.");
        } else{
            System.out.println("Obiekty nie wskazują na tą samą referencję");
        }
    }
}

Zadanie1:

Napisz program sortujący tablicę metodą przez wybieranie zgodnie z poniższymi wytycznymi:

Sortowanie przez wybieranie – jedna z prostszych metod sortowania o złożoności O(n²). Polega na wyszukaniu elementu mającego się znaleźć na żądanej pozycji i zamianie miejscami z tym, który jest tam obecnie. Operacja jest wykonywana dla wszystkich indeksów sortowanej tablicy.

Algorytm przedstawia się następująco:

1. wyszukaj minimalną wartość z tablicy spośród elementów od i do końca tablicy
2. zamień wartość minimalną, z elementem na pozycji i

Gdy zamiast wartości minimalnej wybierana będzie maksymalna, wówczas tablica będzie posortowana od największego do najmniejszego elementu.

Założenia do programu:

• program wykonywany w konsoli
• sortowanie odbywa się malejąco, nie wykorzystuje gotowych funkcji do sortowania oraz do szukania maksimum
• sortowana jest tablica 10 liczb całkowitych. Tablica jest polem klasy.
• tablica jest wczytywana z klawiatury po uprzednim wypisaniu odpowiedniego komunikatu
• wszystkie elementy posortowanej tablicy są wyświetlane na ekranie
• klasa zawiera co najmniej dwie metody: sortującą i szukającą wartość najwyższą. Widzialność metody szukającej ogranicza się jedynie do klasy.
• metoda szukająca zwraca wartość, w zależności od przyjętej taktyki może być to wartość maksymalna lub index wartości maksymalnej.
• program powinien być zapisany czytelnie, z zasadami czystego formatowania kodu, należy stosować znaczące nazwy zmiennych i funkcji.

Zadanie2:

Napisz program, który szyfruje podany przez użytkownika tekst szyfrem podstawieniowym zwanym GADERYPOLUKI. Klucz ten zawiera pary zamienników: GA–DE–RY–PO–LU–KI. Pierwsza litera w parze jest zastępowana na drugą, druga na pierwszą. Dla przykładu litera G zastępowana jest literą A, litera A literą G. Litery, których nie ma w kluczu (inne niż GADERYPOLUKI) pozostają bez zmian. Np. słowo PROGRAM po zaszyfrowaniu brzmi OYPAYGM, bo:
P R O G R A M
O Y P A Y G M
Założenia programu:

• Program wykonywany w konsoli
• Jeżeli język programowania tego wymaga, można założyć dla uproszczenia, że tekst do zaszyfrowania ma
  maksymalnie 20 liter i zapisany jest małymi literami oraz nie ma w nim innych znaków, cyfr, spacji
• Program zawiera funkcję szyfrującą, która przyjmuje jako argument wprowadzony tekst
• Funkcja zwraca zaszyfrowany tekst
• W programie głównym występuje wczytanie tekstu z klawiatury po uprzednim wyświetleniu stosownego komunikatu dla użytkownika, a po zaszyfrowaniu wyświetlenie zaszyfrowanej jego wersji 
• Program powinien być zapisany czytelnie, z zasadami czystego formatowania kodu, należy stosować znaczące nazwy zmiennych i funkcji

Artykuł 14. JAVA – obiektowo pochodzi z serwisu Kama Kaczmarek.

System.out.printf("Hello %s %n", "World");

W powyższym przykładzie możemy zauważyć, iż korzystamy ze znaku %, który określa format danych składający się na pewien schemat.
Następnie, po przecinku wypisujemy kolejne argumenty, które będą podstawiane do konkretnego szablonu.
Możliwe formaty to:
%d – format dla liczb całkowitych
%f – format dla liczb rzeczywistych
%s – format dla ciągów znaków
%b – format dla typu logicznego
%n – znak nowej linii
%t.. – format dla dat, który jest rozszerzany o następne formaty:
        A lub a – pełna nazwa dnia tygodnia lub skrócona
        B lub b – pełna nazwa miesiąca lub 3 literowa nazwa miesiąca
        c – cała data i czas
        F – data w formacie 2021-05-27
        T – godzina w formcie 24h / R – bez sekund / H – 2cyfrowa / k – bez zer
        r – godzina w formacie 12h / p – pm/am
        M – minuty 2cyfrowo
        S – sekundy 2cyfrowo
        Y lub y – rok 4cyfrowy lub 2cyfrowy
        m – 2cyfrowy miesiąc
        d lub e – dzień 2cyfrowy lub bez zer
        s – znacznik czasowy/timestamp
        Q – milisekundy
1..n$ – możemy wskazać na konkretny argument do formatowania

Przykłady:

System.out.printf("%d %f %s %b %n", 10, 1.22f, "tekst", true);//10 1,220000 tekst true
System.out.printf("%tA %tb %tc %n", new Date(), new Date(), new Date());//czwartek maj czw. maj 27 20:25:17 CEST 2021
//aby nie powtarzać tego samego argumentu kilka razy, możemy wskazywać konkretny argument
System.out.printf("%1$tA %1$tb %1$tc %n", new Date());//czwartek maj czw. maj 27 20:25:17 CEST 2021

String user = "user";
System.out.printf("Witaj %s, zostałeś zalogowany w %tA %2$tF", user, new Date());

Artykuł 13. JAVA – wyświetlanie danych metodą printf pochodzi z serwisu Kama Kaczmarek.