Sziasztok!
Az objektum orientált programozás egyik legalapvetőbb pillére az inheritence, az öröklődés. Az osztályoknak lehetnek child osztályai, azoknak még child osztályai és így tovább. Fontos hozzátenni, hogy ebben a leckében egyelőre csak is a nem absztrakt osztályokról lesz szó.
Kezdjünk egy teljesen új példát, hagyjuk egyelőre a kutya osztályt. Hozzunk létre a Main classon kívül egy Person fájlt (benne Person osztály), amiben adjunk meg alapvető fieldeket (name, age) és alapvető metódusokat (eat, sleep, getterek, setterek, konstruktorok).
public class Person {
private String name;
private int age;
public Person() {
}
public Person(final String name, final int age) {
this.name = name;
this.age = age;
}
public void eat() {
System.out.println("Person " + name + " is eating.");
}
public void sleep() {
System.out.println("Person " + name + " is sleeping now.");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Ezt ha leteszteljük, működik. Most hozzunk létre egy Woman osztályt is, amely származzon a Person osztályból. Származtatni az 'extends' kulcsszóval tudunk. Syntax: class ChildClass extends ParentClass { }
A Woman osztály egyelőre üresen.
public class Woman extends Person {
}
Példányosítsunk a Main osztályban egy Woman típuső objektumot, próbáljuk meg besettelni a nevét, majd hívjuk meg az eat() metódusát.
public class Main {
public static void main(String[] args) {
Woman woman = new Woman();
woman.setName("Katherine");
woman.eat();
}
}
Alapesetben, ha a Woman nem származna a Personből, nem tudnánk ezt megtenni, mivel a Woman nem rendelkezik semmivel sem. De mivel származtattuk a Personből, ezért minden fieldjét és metódusát megörökölte. Ezért lesz most az eredmény: "Person Katherine is eating".
Lehetőségünk van azonban felülírni a megörökölt metódusokat. Furcsán néz ki Katherine előtt a Person, az legyen inkább Woman, valamint a nők többnyire szeretik a salátát, ezért a Woman osztályunk salátát egyen.
Ezt ugyanúgy, mint amikor a toString()-et felülírtuk, most is az @Override annotációval és a függvény újra leimplementálásával lehet megtenni.
public class Woman extends Person {
@Override
public void eat() {
System.out.println("Woman " + getName() + " is eating salad now.");
}
}
Hangsúlyozom, hogy a @Override nem kötelező, amikor overrideolunk metódusokat. Ezt főképp azért használjuk, mert először is jelzi, ha a függvényünk nem is ír semmit felül, mert pl. elgépeltük, valamint így átláthatóbbá teszi egy másik fejlesztőnek a kódodat, mert tudni fogja, hogy ez a függvény már létezik feljebbi rétegben is.
Feltűnhet, hogy itt nem name fieldre hivatkoztam, hanem a getName() gettert hívtam meg. Ez azért van, mert amit már tanultunk itt is előjön. A private modifierrel ellátott elemek még a childclassban SEM elérhetőek. Ezzel ellentétben a publikus getName() bárhonnan elérhető.
A javaban minden osztály az Object classból származik, ezért rendelkezik minden saját osztályunk az Object függvényeivel, amiket overrideolni is tudunk ha szükséges (pl equals, hashcode, toString etc).
Ez volt az inheritence in a nutshell.