Polimorfismo spiegato semplicemente!

I quattro concetti base dell’OOP (Object Oriented Programming) sono Ereditarietà, Astrazione, Polimorfismo e Incapsulamento. Per qualcuno che è nuovo all’OOP può essere un po’ difficile all’inizio afferrare gli ultimi 3 dei concetti base dell’OOP (dato che l’Ereditarietà è un po’ facile da capire).

Polimorfismo è la capacità di un oggetto di assumere molte forme.

Ogni oggetto Java che può passare più di un test IS-A è considerato polimorfico- tutorialspoint. Questo significa che qualsiasi oggetto di classe figlio può assumere qualsiasi forma di una classe nella sua gerarchia madre e naturalmente anche se stesso. Ciò significa che l’oggetto della classe figlio può essere assegnato a qualsiasi riferimento di classe nella sua gerarchia genitore e naturalmente anche a se stesso.

Eg: Diciamo che la classe Student è figlia della classe Person

Student student = new Student()
Person person = new Student()

L’uso più comune del polimorfismo in OOP si verifica quando un riferimento di classe genitore è usato per riferirsi a un oggetto di classe figlio. In realtà qui si parla di polimorfismo dinamico (che descriverò in seguito).

Ci sono 2 tipi di polimorfismo che sono comunemente menzionati.

1. Polimorfismo Dinamico
2. Polimorfismo Statico

Polimorfismo Dinamico

Questo è anche menzionato come polimorfismo Run-Time, Dynamic binding, Run-Time binding, Late binding e Method overriding. Qui, avendo molte forme sta accadendo in diverse classi.

Questo è ciò che è comunemente noto come il cosiddetto “polimorfismo”. Lasciatemi spiegare MOLTO SEMPLICEMENTE –

Immaginiamo che ci siano metodi con la stessa firma di metodo nelle classi in una gerarchia di classi (relazioni genitore-figlio), questi metodi sono in forme diverse (questo è noto come metodo di override).

Quindi quando un oggetto è assegnato a una classe di riferimento e quando un metodo dell’oggetto viene chiamato, viene eseguito il metodo nella classe dell’oggetto. Non il metodo della classe di riferimento (se il riferimento è una classe padre).

Quello che succede qui è che siccome la creazione dell’oggetto è fatta a run-time la forma del metodo che dovrebbe essere eseguito (il metodo nell’oggetto) può essere decisa solo a run-time.

Eg: Codice Java

class Person { 
public void teach(){
System.out.println("Person can teach");
}
}
class Teacher extends Person {
public void teach() {
System.out.println("Teacher can teach in a school");
}
}
public class TestTeacher {
public static void main(String args) {
Person person = new Person(); //Person reference and object
Person another_person = new Teacher(); //Person reference, Teacher object
Teacher teacher = new Teacher(); //Teacher reference and obj. person.teach();//output: Person can teach // Here you can see Teacher object's method is executed even-
// -though the Person reference was used 
another_person.teach();//output: Teacher can teach in a school teacher.teach();//output: Teacher can teach in a school
}
}

Polimorfismo statico

Questo è anche menzionato come Compile-Time polymorphism, Static binding, Compile-Time binding, Early binding e Method overloading. Qui, avere molte forme sta accadendo nella stessa classe.

Se lo spiego SEMPLICEMENTE..

Questo è effettivamente il sovraccarico del metodo. Il sovraccarico del metodo è avere più di un metodo con lo stesso nome ma con argomenti diversi (il tipo di ritorno può essere o meno lo stesso). Qui quando si chiamano i metodi il compilatore sceglie quale metodo chiamare a seconda dei parametri passati al momento della chiamata. Questo avviene a tempo di compilazione.

Eg: codice Java

class Calculator {
void add(int a, int b) {
System.out.println(a+b);
}
void add(int a, int b, int c) {
System.out.println(a+b+c);
}
}public class Demo {
public static void main(String args) {
Calculator calculator = new Calculator(); // method with 2 parameters is called
calculator.add(10, 20); //output: 30 // method with 3 parameters is called
calculator.add(10, 20, 30); //output: 60
}
}

Alcuni dicono che il sovraccarico dei metodi non è veramente polimorfismo. Ma penso che possa essere categorizzato come un tipo di polimorfismo poiché nel sovraccarico del metodo c’è un metodo in molte forme.

Spero che questo abbia aiutato a capire il polimorfismo semplicemente.

Cheeers! 😀

Ecco alcuni utili link

• Method overriding
• Method overloading
• Tipi di polimorfismo
• Differenza tra polimorfismo di runtime e polimorfismo di compilazione