Eredità in Java (con esempio)
James Hartmann
Che cos'è l'ereditarietà?
Eredità è un meccanismo in cui una classe acquisisce la proprietà di un'altra classe. Ad esempio, un bambino eredita le caratteristiche dei suoi genitori. Con l'ereditarietà possiamo riutilizzare i campi e i metodi della classe esistente. Pertanto, l'ereditarietà facilita la riusabilità ed è un concetto importante degli OOP.
Che cosa è l'ereditarietà in Java?
Java Eredità è un meccanismo in cui una classe acquisisce la proprietà di un'altra classe. In Java, quando esiste una relazione "Is-A" tra due classi, utilizziamo l'ereditarietà. La classe genitore è chiamata superclasse e la classe ereditata è chiamata sottoclasse. La parola chiave extends viene utilizzato dalla sottoclasse per ereditare le caratteristiche della superclasse. L'ereditarietà è importante perché porta alla riutilizzabilità del codice.
Java Sintassi dell'ereditarietà:
class subClass extends superClass
{
//methods and fields
}
Tipi di eredità in Java
Ecco i diversi tipi di eredità in Java:
- Ereditarietà singola
- Ereditarietà multipla
- Ereditarietà multilivello
- Ereditarietà gerarchica
- Eredità ibrida
1. Eredità unica:
Nell'ereditarietà singola una classe estende un'altra classe (solo una classe).
Nel diagramma sopra, la Classe B estende solo la Classe A. La Classe A è una superclasse e la Classe B è una sottoclasse.
2. Ereditarietà multipla:
L'ereditarietà multipla è una delle eredità in Java tipi in cui una classe estende più di una classe. Java non supporta l'ereditarietà multipla.
Come da diagramma sopra, la Classe C estende sia la Classe A che la Classe B.
3. Ereditarietà multilivello:
Nell'ereditarietà multilivello, una classe può ereditare da una classe derivata. Pertanto, la classe derivata diventa la classe base per la nuova classe.
Come mostrato nel diagramma, la Classe C è la sottoclasse di B e B è la sottoclasse di Classe A.
4. Ereditarietà gerarchica:
Nell'ereditarietà gerarchica, una classe viene ereditata da molte sottoclassi.
Come nell'esempio sopra, le classi B, C e D ereditano la stessa classe A.
5. Ereditarietà ibrida:
L'ereditarietà ibrida è uno dei tipi di ereditarietà in Java che è una combinazione di ereditarietà singola e multipla.
Come nell'esempio sopra, tutti i membri pubblici e protetti della Classe A vengono ereditati nella Classe D, prima tramite la Classe B e poi tramite la Classe C.
Nota: Java non supporta l'ereditarietà ibrida/multipla
Eredità in Java Esempio
Ecco un esempio di eredità in Java:
class Doctor {
void Doctor_Details() {
System.out.println("Doctor Details...");
}
}
class Surgeon extends Doctor {
void Surgeon_Details() {
System.out.println("Surgen Detail...");
}
}
public class Hospital {
public static void main(String args[]) {
Surgeon s = new Surgeon();
s.Doctor_Details();
s.Surgeon_Details();
}
}
Parola chiave eccellente
La parola chiave super è simile alla parola chiave "this". La parola chiave super può essere usata per accedere a qualsiasi membro dati o metodo della classe padre. La parola chiave super può essere usata a variabile, metodo e livello di costruttore.
Sintassi:
super.<method-name>();
Controlla anche: - questa parola chiave in Java: Che cos'è e come utilizzarlo con l'esempio
Impara l'ereditarietà negli OOP con l'esempio
Considera la stessa applicazione bancaria di esempio precedente.
Dovremmo aprire due diversi tipi di conto, uno per il risparmio e un altro per il controllo (noto anche come corrente).
Confrontiamo e studiamo come possiamo affrontare la codifica da a prospettiva di programmazione strutturata e orientata agli oggetti.
Approccio strutturale: Nella programmazione strutturata, creeremo due funzioni:
- Uno da ritirare
- E l'altro per l'azione di deposito.
Poiché il funzionamento di queste funzioni rimane lo stesso in tutti gli account.
L'approccio dell'OOP: Durante l'utilizzo di OOP approccio di programmazione. Creeremmo due classi.
- Ciascuno ha l'implementazione delle funzioni di deposito e prelievo.
- Ciò renderà superfluo il lavoro extra.
Richiesta di modifica nel software
Ora c'è un cambiamento nelle specifiche dei requisiti per qualcosa che è così comune nell'industria del software. Dovresti aggiungere la funzionalità Conto bancario privilegiato con possibilità di scoperto. Tanto per cominciare, lo scoperto è una struttura in cui puoi prelevare un importo superiore a quello disponibile sul saldo del tuo conto.
Approccio strutturale: Utilizzando un approccio funzionale, devo modificare la mia funzione di ritiro, che è già testata e di riferimento. E aggiungere un metodo come quello di seguito si occuperà dei nuovi requisiti.
L'approccio dell'OOP: Utilizzando l'approccio OOP, devi solo scrivere una nuova classe con un'implementazione unica della funzione di prelievo. Non abbiamo mai toccato il pezzo di codice testato.
Un'altra richiesta di modifica
Cosa succede se i requisiti cambiano ulteriormente? Vorrei aggiungere un conto di carta di credito con i propri requisiti unici di depositi.
Approccio strutturale: Utilizzando l'approccio strutturale è necessario modificare nuovamente la parte testata del codice di deposito.
L'approccio dell'OOP: Ma usando un approccio orientato agli oggetti, creerai semplicemente una nuova classe con la sua implementazione unica del metodo di deposito (evidenziato in rosso nell'immagine sottostante). Quindi, anche se la programmazione strutturale sembra un approccio facile all'inizio, la OOP vince a lungo termine.
Vantaggi dell'ereditarietà negli OOP
Ma si potrebbe sostenere che in tutte le classi ci sono pezzi di codice ripetuti.
Per superare questo problema, si crea una classe padre, diciamo "account" e si implementa la stessa funzione di deposito e prelievo. E si fa in modo che le classi figlio ereditino la classe "account". In modo che abbiano accesso alle funzioni di prelievo e deposito nella classe account. Non è necessario che le funzioni siano implementate individualmente. Questo è Eredità in Java. .
