hlmod.hu

Sziasztok!

10) Java - Object Oriented Programming - Konstruktor

A tutoriálsorozat előző részében már volt szó a konstruktorról, azonban korántsem érintettük teljes kihasználtságát.

Beszéltünk az üres konstruktorról, amit a JVM generál nekünk, ha nem írjuk be saját magunk, valamint készítettünk egy egyszerű konstruktort, ami az objektum létrejöttekor tudatja velünk konzolban, hogy a "kutya" létrejött.

Vannak paraméterezett konstruktorok, amelyek példányosításkor várnak egy, vagy több paramétert, amivel aztán dolgozhatunk. A leggyakoribb típusa ennek, amikor az összes tulajdonságot megadjuk példányosításkor, így a kutya nem csak kutya lesz, hanem lesz neve, színe stb.

Példa:

class Dog {
    private String name;
    private int age;
    private String color;
    
    public void Bark() {
        System.out.println("Vau-vau!");
    }
    
    public void Eat() {
        System.out.println("A kutya eszik!");
    }
    
    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
        System.out.println("Kutya létrehozva!");
    }
    
}



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

        Dog dog1 = new Dog("Enzo", 3, "Grey");
        
    }
}
 

Így mostmár van egy kutya objektumunk, Enzo, aki három éves és szürke a bundája. Feltűnhetett, hogy ugyanazok voltak a konstruktor paramétereinek nevei mint az osztály field nevei és még sincs zűrzavar belőle. Valóban, mivel a paraméter nevei lokális változókként szerepeltek, amik csak a konstruktoron belül éltek, így amikor egyszerűen a name-re hivatkoztam, akkor a paraméter értékét használtam. A this kulcsszó segítségével pedig az osztály változójára. A this kulcsszó mindig az aktuális osztályt / objektumot jelenti, erre érdemes odafigyelni a későbbiekben, főleg amikor anoním objektumot hozunk létre, akkor a this kulcsszó nem az aktuális osztályra fog mutatni, ahol dolgozunk, hanem az anoním objektumra.

Tegyük fel, hogy nem az objektum létrehozásakor akarunk értékeket adni a tulajdonságainak, hanem mondjuk a program futásának egy későbbi fázisában, viszont lesznek olyan esetek, ahol egyből szeretnénk értéket adni.

Tehát összefoglalva, megeshet, hogy egy programon belül egy osztály konstruktorát kétféleképpen szeretnénk meghívni, egyszer paraméterrel, egyszer anélkül.

Ilyenkor megadhatunk osztályon belül több konstruktort is, melyeknek neve ugyanaz, viszont paraméterei változnak. Eddigi példánk kibővítése ez alapján:

class Dog {
    private String name;
    private int age;
    private String color;
    
    public void Bark() {
        System.out.println("Vau-vau!");
    }
    
    public void Eat() {
        System.out.println("A kutya eszik!");
    }
    
    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
        System.out.println("Kutya létrehozva!");
    }
    
    public Dog() {
        System.out.println("Kutya létrehozva!");
    }
    
}



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

        Dog dog1 = new Dog("Enzo", 3, "Grey");
        
        Dog dog2 = new Dog();
        
        /* Pár sor kód */
        
        /* Majd Setterek segítségével beállítjuk az értékeket*/
        
    }
}

Nem kell foglalkoznunk azzal, hogy most melyik konstruktort hívjuk éppen meg, mivel a Java elvégzi a döntést helyettünk és a megfelelő konstruktort fogja meghívni, amennyiben illik hozzá bármelyik is a paraméterezésünk alapján. Nyilván, ha négy stringet adunk meg paraméternek a fenti példában, akkor nem fog fordulni, mivel nincs olyan konstruktor, amelyik négy stringet várna el.


A toString() metódus és az Override annotáció

Amennyiben egy származtatott osztályon belül vagyunk, lehetőségünk van a szülőosztályok metódusait felülírni. Ehhez csak meg kell hívnunk ugyanazt a függvényt, ugyanolyan paraméterekkel és visszatérési érték típussal. Lehetőségünk van használni az Override annotációt. Két okból is érdemes használni, az egyik az, hogy a fordító jelezni fogja, ha az adott metódusunk igazából nem is ír felül semmit, mert félreírtuk a nevét, vagy az ősosztályának nincs is ilyen metódusa.
A másik ok pedig az átláthatóság, hiszen többnyire nem egyedül dolgozunk, így ha egy másik fejlesztő kapja meg a kódunkat, egyből levágja, hogy ez a függvény a szülőosztálytól jött és az lett felülírva.


A toString() az osztály hierarchia legmagasabb osztálya, az Object metódusa. Tehát minden Java osztály implementálni fogja ezt a metódust, azonban felül lehet írni.

Alapértelmezettként, ha nem írjuk felül, majd megpróbáljuk kiíratni a dog1 változót, akkor valami ilyesmit kell kapjunk:

com.optimaster.silent.dev.Dog@15db9742

Nyilván nekünk nem ő kell, hanem a kutyánk adatai. Így hát írjuk felül a toString metódust a Dog osztályunkban.

class Dog {
    private String name;
    private int age;
    private String color;
    
    
    @Override
    public String toString() {
        return "Név: " + name + ", Kor: " 
                + age + ", Szín: " + color;
    }
    
    public void Bark() {
        System.out.println("Vau-vau!");
    }
    
    public void Eat() {
        System.out.println("A kutya eszik!");
    }
    
    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
        System.out.println("Kutya létrehozva!");
    }
    
    public Dog() {
        System.out.println("Kutya létrehozva!");
    }
    
}



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

        Dog dog1 = new Dog("Enzo", 3, "Grey");
        System.out.println(dog1);
    }
}

Konzol eredményünk:

Kutya létrehozva!
Név: Enzo, Kor: 3, Szín: Grey

Mint azt már feljebb írtam, nem feltétlen szükséges a @Override annotáció, hiszen a Javaban mindegyik (nem-final, nem-static) függvény felülírható, ha valaki esetleg C#-ban használt virtual metódusokat, akkor úgy tudnám elmagyarázni, hogy Javaban mindegyik(nem-final, nem-static) függvény az.


Egy kis záróként, ha olvasod a tutoriáljaimat, légyszíves nyomj egy szavazás gombot valamelyik opcióra, hogy lássam, hogy megéri-e írogatnom oldalakat, vagy feleslegesen koptatom a billentyűket. Amennyiben van rá igény, folytatom szívesen, hiszen ezen az oldalon már mindenféle programozási tutoriál elindult, amik általában az elágazásokig, esetleg függvényekig jutottak el, így nem ártana egy sorozat, ami picit mélyebb áttekintést nyújt az objektum orientáltságról és annak "gyönyöreiről".
Természetesen nem minden rész tökéletesen megfogalmazott, eléggé konyhanyelven írtam a topikokat, amennyiben szükség van inkább a szakszavakra, azt is jelezzétek valamilyen formában, hiszen akkor írom picit hozzáértőbb, "senior fejlesztősebb" nyelven, ha valaki úgy jobban szeretné.

Köszönöm, ha elolvastad.
Következő lecke a getterekről és setterekről szól, amennyiben úgy döntötök, hogy van rá szükség.
Addig is,
Happy Coding! :)