Parliamo insieme di ereditarietà e polimorfismo
In questo blog, Ho intenzione di scrivere un po ‘di profondità all’interno del concetto più importante della programmazione orientata agli oggetti chiamato ereditarietà. Si possono trovare articoli ovunque su questo argomento. Ma ho trovato qualcosa che manca insieme. Significa che molti articoli definiscono solo l’ereditarietà e gli esempi, non spiegano come implementare nei progetti di vita reale. Inoltre, nell’ereditarietà, c’è anche un altro concetto che si chiama polimorfismo. Quindi dico che se volete capire completamente l’ereditarietà, allora dobbiamo capire il concetto di polimorfismo insieme. Questo ci dà una migliore chiarezza su come implementare i progetti. Provo anche a descrivere quando abbiamo bisogno di ereditare e perché. Qui, prendo tutti gli esempi nel linguaggio di programmazione Java perché penso che dia un esempio più chiaro per capire. Iniziamo la definizione:
Definizione:
- Ereditarietà: è un meccanismo in cui un oggetto acquisisce tutte le proprietà e i comportamenti di un oggetto padre. È una parte importante di OOPs (sistema di programmazione orientato agli oggetti).
- sottoclasse (figlio) – la classe che eredita da un’altra classe. E’ anche chiamata classe derivata, classe estesa o classe figlia.
- superclasse (genitore) – la classe da cui viene ereditata, è anche chiamata classe base o classe madre.
Esempio:
class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}
class Pig extends Animal {
public void animalSound() {
System.out.println("The pig says: wee wee");
}
}
class Dog extends Animal {
public void animalSound() {
System.out.println("The dog says: bow wow");
}
}
1.1. Perché usare l’ereditarietà in java
- Per l’override dei metodi (in modo da ottenere il polimorfismo a runtime).
- Per la riusabilità del codice.
1.2. Tipi di eredità in java:
a. Ereditarietà singola
b. Ereditarietà multilivello
c. Ereditarietà gerarchica
d. Ereditarietà multipla
e. Eredità ibrida
Le immagini di tutti i tipi danno più chiarezza. Queste sono
2. Polimorfismo:
Il polimorfismo è la capacità per alcune strutture di codice in un linguaggio OOP di essere trattate come strutture diverse a runtime.
2.1 Polimorfismo degli oggetti:
Quando si discuteva dell’ereditarietà, è stato spiegato che quando la classe B eredita dalla classe A, un oggetto della classe B è anche considerato un oggetto della classe A. Questo è il polimorfismo degli oggetti.
2.2 Polimorfismo dei metodi
Nella maggior parte dei linguaggi OOP, i metodi si differenziano l’uno dall’altro per la loro firma, che è una combinazione del nome del metodo e dei tipi, numero e ordine dei parametri che vengono passati. Questo sistema di differenziazione ci permette di sovrascrivere e sovraccaricare i metodi.
2.3 Tipo di polimorfismo
2.3.1 Polimorfismo in tempo di compilazione
2.3.2 Polimorfismo in tempo di esecuzione
L’esempio precedente, public void animalSound() è polimorfismo in tempo di esecuzione. L’overloading dei metodi è chiamato polimorfismo a tempo di compilazione, perché questi metodi sono differenziati dal compilatore in base ai parametri che gli vengono dati.
Implementazione:
Tutto quanto sopra è definizione di ereditarietà e polimorfismo. Possiamo trovarlo ovunque, e dovremmo saperlo anche noi. Ma qui, voglio discutere l’implementazione di questi concetti a livello di progetto. Voglio anche dire della relazione tra due o più classi quando una classe eredita un’altra classe. In realtà, Ereditarietà significa che ha stabilito una relazione tra di loro. Ci sono due tipi di relazione. L’ereditarietà presenta la relazione “IS-A” e un’altra è la relazione di composizione. Vediamo un esempio prima di andare avanti.
class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}
class Vehicle extends Animal {
public void vehicleSound() {
System.out.println("Vehicle Sound !!");
}
}
Nell’esempio sopra, abbiamo due classi Animal e Vehicle dove la classe Vehicle eredita la classe Animal. Si crea qualche significato logico con l’ereditarietà anche se non c’è nessun errore tecnicamente. Ovviamente, non c’è alcun significato. Quindi dovremmo sempre ereditare in modo appropriato da cui possiamo stabilire una corretta relazione. Facciamo un altro esempio
class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}class Dog extends Animal {
public void animalSound() {
System.out.println("Dog Sound !!");
}
}
Ora la classe cane eredita la classe animale. Quindi l’oggetto della classe cane eredita anche tutte le proprietà e il comportamento della classe animale che danno anche un significato logico. E questo si chiama relazione “IS-A”. Ma quando creiamo un oggetto di qualsiasi classe su un’altra classe, allora la relazione tra l’oggetto creato e la classe si chiama “HAS-A” (composizione).
Esempio:
class Dog {
public void animalSound() {
System.out.println("Dog sound");
}
}class Person {
public static void main(String args) { Dog dogObj = new Dog(); // "HAS-A" relationship dogObj.animalSound();
}
}
Punti importanti in java :
Qui, ho usato tutti gli esempi nel linguaggio di programmazione java. Quindi dobbiamo ricordare alcuni punti importanti in java durante il concetto di ereditarietà.
- Java non permette l’ereditarietà multipla e ibrida nelle classi come il C++ perché Java si confonde con l’override del metodo (run -time Polymorphism) mentre lo stesso nome del metodo appare in entrambe le classi. Esempio
class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}class Mammal {
public void animalSound() {
System.out.println("The mammal makes a sound");
}}// error , multiple class inheritanceclass Dog extends Animal,Mammal {
public void animalSound() {
System.out.println("Dog Sound !!");
}
}
- Ma Java può ereditare interfacce multiple.
Conclusione:
L’ereditarietà e il polimorfismo sono concetti molto importanti che sono usati in ogni singolo passo nei progetti. Abbiamo bisogno di ereditare altre classi definite dall’utente o built-in per risparmiare tempo e gestire correttamente il codice. Senza questi concetti, non possiamo fare alcun progetto di linguaggio di programmazione orientato agli oggetti. E mi sono anche concentrato sull’implementazione, argomento di relazione rispetto alla definizione. Dovremmo essere in grado di distinguere le classi, gli oggetti, le entità, i comportamenti, le proprietà e le relazioni tra loro durante la raccolta dei requisiti dagli utenti. Poi, possiamo organizzare la codifica e i progetti in modo appropriato.