okej, tá sľúbená esej
prv máš parametrický polymorfizmus... to znamená toľko, že môžeš mať v jednej triede viacero metód s rovnakým názvom alebo viacero konštruktorov, každý s inými parametrami (typ alebo počet)... kompiler potom podľa počtu parametrov pri volaní metódy vyberá tú konkrétnu, ktorá sa použije...
toto je myslím pomerne jednoduché a jasné...
class Car {
public Car(string color) {...}
public Car(string color, int doorsCount) {...}
public Car(int doorsCount) {...}
pubilc Car(string color, string engine) {...}
...
}
druhá možnosť, a asi to, čo ťa zaujíma viac, je polymorfizmus pri dedení...
tam ide hlavne o to, že ak máš niekde v predpise použitú base triedu (triedu predka), tak vieš namiesto nej použiť akýkoľvek objekt jej potomkov (odvodených tried)...
nejak takto:
class Person {...}
class Student extends Person {...}
class Employee extends Person {...}
...
// máš v niektorej triede nejakú metódu, ktorá ako parameter berie typ Person...
public void RegisterPerson(Person personToRegister) {...}
...
// teraz pri volaní tejto metódy môžeš použiť ako objekty triedy Person, tak aj objekty odvodených tried, teda Student a Employee...
public void execute() {
Student student = new Student();
register.registerPerson(student); // toto je okej, pretože Student dedí od Person (takže je súčasne typu Student aj typu Person) - podobne vieš použiť aj Employee
}
...
// tiež platí, že do premennej typu Person vieš priradiť aj odvodené triedy (opačne to neplatí - do premennej typu odvodenej triedy, napr. Student nevieš priradiť objekty triedy predka, tj. Person)
// takže máš napr.
private Person person;
// a metódu, ktorá inicializuje túto premennú:
public void init(string personType) {
// typ student
if (personType == "student") {
person = new Student();
}
// typ employee
else if (personType == "employee") {
person = new Employee();
}
// ani jeden z predchádzajúcich, takže nastaví generický typ - tj. triedu predka
else {
person = new Person();
}
}
toto sa vo veľkom používa... pri unit testoch, pri design patternoch (napr. tá metóda init je trochu zjednodušení pattern FactoryMethod), pri pluginovaní, etc., etc...
takisto toto platí aj pre interface-i a abstraktné triedy (s tým, že samotný interface ani abs. trieda sa nedajú vytvoriť... ale priradiť do objektu typu interfaceu sa dajú všetky triedy, ktoré interface implementujú)
okej... ešte taká tabuľka, že čo je vlasnte akého typu...
Person student = new Student();
Person person = new Person();
Person employee = new Employee();
...
student instanceof Student => true
student instanceof Person => true
student instanceof Employee => false
person instanceof Person => true
person instanceof Student => false
person instanceof Employee => false
snáď všetko, aj keď mám pocit, že som na niečo zabudol... keď si spomeniem, tak dopíšem... hmm...
plus, dúfam, že sa to dá aspoň trochu pochopiť, a že to pomohlo...
samozrejme, kľudne sa pýtaj, keby niečo... možno to tak aj bude lepšie, keď sa budeš pýtať na nejaké konkrétne veci, čo nevieš...
aspoň mne sa to tak lepšie potom chápe...
