14. JAVA - obiektowo - Kama Kaczmarek

Programowanie obiektowe – OOP (object-oriented programming) – pozwala na przedstawienie rzeczywistości i relacji w niej zachodzących za pomocą obiektów.

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:

wyszukaj minimalną wartość z tablicy spośród elementów od i do końca tablicy
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

Kama Kaczmarek

Strona z materiałami dla uczniów i nauczycieli

Strona z materiałami dla uczniów i nauczycieli

14. JAVA – obiektowo

Klasa i obiekt

Przykład:

Przykład:

Metody

Konstruktory

Modyfikatory dostępu

Static i Final

Dziedziczenie

Przykład:

Przykład:

Polimorfizm

Przykład:

Przykład:

Klasy i metody abstrakcyjne oraz interfejsy

Przykład:

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

Przykład:

Przykład:

Przykład:

Klasy wewnetrzne

Przykład

Klasa Object

Przykład

Zadanie1:

Zadanie2: