javamPokaze || Co Java ma wspólnego z genetyką? || Część 1 || Dziedziczenie

Poruszone zagadnienia

• Dziedzieczenie

• Testy IS-A oraz HAS-A

• Overload

• Override

• Klasa abstrakcyjna

• Klasa o konkretnej implementacji

Wstęp

Dziedziczenie

// Klasa nadrzędna Car (superclass)
public class Car {
    String brand;
    String model;

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

    public void startEngine() {
        System.out.println("Uruchamiam silnik samochodu " + brand + ", model: " + model);
    }
}
-------------------------------------------------------------------------------------------

// Klasa podrzędna Combi dziedzicząca po klasie Car (subclass)
public class Combi extends Car {

    public Combi(String brand, String model) { 
        super(brand, model);
    }

    public void openTrunk() {
        System.out.println("Otwieram bagażnik w samochodzie " + brand + ", model: " + model);
    }
}
-------------------------------------------------------------------------------------------

// Klasa podrzędna SUV dziedzicząca po klasie Car (subclass)
public class SUV extends Car {
    
    public SUV(String brand, String model) {
        super(brand, model);
    }

    public void activate4WD() {
        System.out.println("Aktywuję napęd na cztery koła w " + brand + ", model: " + model);
    }
}
-------------------------------------------------------------------------------------------
public class TestCar {
    public static void main(String[] args) {
        Combi combi = new Combi("Opel", "Astra");
        SUV suv = new SUV("Jeep", "Wrangler");

        combi.startEngine();
        // Uruchamiam silnik samochodu Opel, model: Astra

        combi.openTrunk();
        // Otwieram bagażnik w samochodzie Opel, model: Astra

        suv.startEngine();
        // Uruchamiam silnik samochodu marki Jeep, model: Wrangler

        suv.activate4WD();
        // Aktywuję napęd na cztery koła w Jeep, model: Wrangler
    }
}

class Combi extends Car{ // auto combi rozszerza właściwości auta standardowego
}

class Tiger extends Animals{ // t
tygrys rozszerza swoje cechy o cechy klasy Animals 
}

class Fastfood extends Food{ // śmieciowe żarcie rozszerza właściwości żywności
}                            // hmm.. to chyba zły przykład... 

public Combi(String brand, String model) { 
        super(brand, model); //super oznacza wywołanie konsturtowa klasy Car
    }

Testy IS-A oraz HAS-A, czyli jak tworzć genetyczne drzewo dziedziczenia

//Klasa nadrzędza 
public class Dog {
    public void bark() {
        System.out.println("Woof! Woof!"); 
    }
}
--------------------------------------------------------------------------------------
//Klasa podrzędna 
public class Puppy extends Dog {
    public void play() {
        System.out.println("The puppy is playing");
    }
}
--------------------------------------------------------------------------------------
public class TestDog {
    public static void main(String[] args) {
		Dog dog = new Dog();
		dog.bark();  // Output: Woof! Woof!

		Puppy puppy = new Puppy();
		puppy.bark(); // Output: Woof! Woof!
		puppy.play(); // Output: The puppy is playing.

IS-A (jest)

• Puppy IS-A Dog (Szczeniak jest Psem)

• Puppy extends Dog

• Rex extends Puppy

HAS-A (ma/posiada)

• Car HAS-A Engine (Samochód ma/posiada Silnik w swoim ciele)

Overload oraz @Override

public class Car {

		public void acceletarte(){
				System.out.println("Car is acceletating");
		}
}		
-------------------------------------------------------------------------------------------

public class ElectricCar extends Car {

// Wykonujemy override metody acceletarte()
@Override
public void acceletarte(){                 
				System.out.println("Electric car is acceletating");
		}
 } 
-------------------------------------------------------------------------------------------

public class GasolineCar extends Car {

// Wykonujemy overload metody acceletarte()
public void acceletarte(int speed){                 
				System.out.println("Gasoline car is acceletating at " + speed + " km/h");
		}
}

Override

Overload

Klasa abstrakcyjna

Abstract clas - klasy abstrakcyjne:

• Klasy abstrakcyjne w Javie są oznaczane słowem kluczowym abstract

• Nie można tworzyć obiektów (instancji) klasy abstrakcyjnej (jest to tzw. klasa szablonowa)

• Klasa abstrakcyjna może zawierać zarówno abstrakcyjne metody (bez implementacji), jak i metody z implementacją (z ciałem)

• Jeśli klasa abstrakcyjna zawiera abstrakcyjne metody, klasy dziedziczące (subclass) są zobowiązane do zaimplementowania tych metod (przez słowo kluczowe @Override) lub też same muszą być oznaczona jako abstrakcyjne, jeśli nie chcemy zaimplementować w nich tych metod (abstract methods must be implemented by the first concrete subclass). To, co umieścisz w cele tych metod zależy już tylko od Ciebie

• Klasa abstrakcyjna może służyć jako punkt wyjścia (szablon) dla dziedziczących po niej klas, które w ten sposób mogą dziedziczyć pewne cechy i metody. Aby nasza KlasaA odziedziczyła pewne cechy od nadrzędnej klasy abstrakcyjnej KlasaB musimy użyć słowa kluczowego extends

public class KlasaA extends KlasaB {
 //Pole klasy
}

Concrete class - klasy o konkretnej implementacji:

• Klasy konkretne to zwykłe klasy, które nie są oznaczone jako abstrakcyjne

• Z takich klas można tworzyć obiekty (instancje), gdyż mają one pełną implementację swoich metod

• Klasy konkretne mogą dziedziczyć po klasach abstrakcyjnych, ale zobowiązane są do dostarczenia implementacji dla wszystkich abstrakcyjnych metod dziedziczonej klasy

abstract class Car {
    String brand;
    String model;

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

    // Abstrakcyjna metoda do opisu, która musi być zaimplementowana w klasach podrzędnych
    public abstract String getDescription(); // metoda abstrakcyjna na ma ciała
}

abstract class SportsCar extends Car {
    int maxSpeed;

	public SportsCar(String brand, String model, int maxSpeed) {
        super(brand, model);
        this.maxSpeed = maxSpeed;
    }

    // Własna implementacja metody getDescription w SportsCar
    @Override
    public String getDescription() {
       return "SportsCar - Brand: " + brand + ", Model: " + model + ", Max Speed: " + maxSpeed + " km/h";
    }
}
--------------------------------------------------------------------------------------

abstract class Combi extends Car {
    int trunkCapacity;

	 public Combi(String brand, String model, int trunkCapacity) {
        super(brand, model);
        this.trunkCapacity = trunkCapacity;
    }

    // Własna implementacja metody getDescription w Combi
    @Override
    public String getDescription() {
        return "Combi - Brand: " + brand + ", Model: " + model + ", Trunk Capacity: " + trunkCapacity + " liters";
    }
}

class Lamborghini extends SportsCar {
    public Lamborghini(String model, int maxSpeed) {
        super("Lamborghini", model, maxSpeed);
    }

class Ferrari extends SportsCar {
    public Ferrari(String model, int maxSpeed) {
        super("Ferrari", model, maxSpeed);
    }
}

class Volvo extends Combi {
    public Volvo(String model, int trunkCapacity) {
        super("Volvo", model, trunkCapacity);
    }

class Renault extends Combi {
    public Renault(String model, int trunkCapacity) {
        super("Renault", model, trunkCapacity);
    }
}

Śledź mnie na LinkedIn

Newsletter