what is inheritance java tutorial with examples
Questo tutorial spiega il concetto di ereditarietà in Java, termini correlati come 'estende' e 'super' parole chiave, sottoclasse, superclasse, relazioni Is-A, HAS-A e così via:
Dopo aver appreso i tre pilastri dell'OOP, ovvero Astrazione, Incapsulamento e Polimorfismo in Java, arriviamo all'ultimo pilastro dell'OOP, ovvero l'ereditarietà.
A partire da questo tutorial discuteremo dell'ereditarietà in Java nei prossimi due tutorial.
=> Leggere attraverso la serie di formazione Easy Java.
Cosa imparerai:
Ereditarietà in Java
L'ereditarietà in Java può essere definita come una tecnica o un processo in cui un oggetto di una classe acquisisce il comportamento e le proprietà di un altro oggetto. Questo viene fatto ereditando la classe o stabilendo una relazione tra due classi.
Per esempio, una rana è un anfibio. Come altri animali della classe degli anfibi, la rana potrebbe avere molte caratteristiche comuni ad altri animali. Quindi qui un anfibio è una specie e animali come le rane sono i suoi membri.
Se dobbiamo rappresentare la specie di anfibi e i suoi membri in una rappresentazione software utilizzando OOP, allora quello che faremo è sviluppare una classe 'Anfibio' contenente proprietà o comportamenti comuni agli anfibi in generale.
In questo modo non dobbiamo duplicare le proprietà e il comportamento comuni per ogni animale anfibio che descriviamo. Creeremo direttamente una classe ciascuno per gli animali anfibi ed erediteremo dalla classe Anfibi come mostrato di seguito.
Quindi un'idea generale alla base della funzionalità 'Ereditarietà' è che possiamo creare nuove classi ereditando dalle classi già esistenti. Ereditando dalle classi già esistenti, possiamo utilizzare le proprietà e il comportamento di queste classi. Inoltre, possiamo aggiungere più proprietà e / o comportamenti nella nostra nuova classe.
La funzione di ereditarietà rappresenta un ' genitore-figlio 'Connessione o relazione in Java. La classe da cui viene ereditata la nuova classe è chiamata ' Classe genitore 'Mentre la nuova classe si chiama' Classe bambino '.
L'ereditarietà viene utilizzata principalmente:
- Per sovrascrittura del metodo in modo che possiamo ottenere polimorfismo a runtime .
- Per riutilizzare il codice . Ereditando dalle classi già esistenti, garantiamo il riusabilità di codice.
Terminologia comune utilizzata nell'ereditarietà
- Riusabilità: Meccanismo mediante il quale le nuove classi riutilizzano campi o proprietà e metodi di una classe esistente.
- Classe: Una classe è una raccolta di oggetti che hanno proprietà comuni. Una classe può essere vista come un modello o una stampa blu per gli oggetti.
- Sottoclasse / Classe bambino: Una classe che eredita da un'altra classe è una sottoclasse o una classe figlia o una classe derivata.
- Super classe / classe genitore: Una classe ereditata da un'altra classe per acquisire proprietà e metodi è chiamata classe Parent o superclasse o classe base.
La seguente gerarchia di ereditarietà è un esempio che mostra una superclasse e una sottoclasse.
Abbiamo una classe Employee con i campi OrganisationName e EmployeeId. Può anche avere altri campi come il nome del dipendente, il reparto e altri dettagli del dipendente.
Quindi deriviamo un'altra classe denominata 'SoftwareDeveloper' con lo stipendio e i vantaggi del campo. La classe SoftwareDeveloper eredita dalla classe Employee e quindi acquisisce anche le proprietà della classe Employee.
Come mostrato nel diagramma sopra, qui la classe Employee è una classe Super o Base e SoftwareDeveloper è una sottoclasse o una classe derivata.
Parola chiave 'extends' in Java
In Java, la parola chiave 'extends' viene utilizzata per ereditare la classe.
Di seguito viene fornita la sintassi generale dell'ereditarietà Java:
class SubClass extends SuperClass { //subclass methods and fields }Come mostrato sopra, la parola chiave 'extends' appare dopo il nome della classe nella sintassi della dichiarazione della classe.
La parola chiave 'extends' indica che stiamo creando una nuova classe 'SubClass' che erediterà le proprietà e il comportamento da 'SuperClass'. In altre parole, la parola chiave extends indica che stiamo costruendo una nuova classe SubClass sulle funzionalità esistenti della SuperClass.
L'ereditarietà implementata con la parola chiave 'extends' è l'ereditarietà della classe. Nel prossimo tutorial, discuteremo di un'altra parola chiave 'implementa' utilizzando la quale possiamo ereditare le interfacce.
Un esempio della classe Employee-SoftwareDeveloper che abbiamo spiegato sopra può essere rappresentato come:
class Employee{ String OrganizationName; int EmployeeId; } class SoftwareDeveloper extends Employee{ float Salary; float Perks; } Relazione IS-A e HA-A
Considera la seguente struttura di classe:
class Mammal{ } class Cow extends Mammal{ }Allora come possiamo interpretare la struttura di cui sopra? Poiché la classe Cow estende o eredita Mammal, possiamo dire 'Cow È UN Mammifero 'o' Mucca È una specie di Mammifero'. Quindi ogni volta che esprimiamo tali relazioni, quella particolare relazione è la relazione 'IS_A'.
Nella struttura sopra, abbiamo utilizzato la gerarchia di ereditarietà per esprimere il fatto che un tipo è di un altro tipo. Quindi, nella struttura sopra, abbiamo usato un'eredità per indicare la relazione tra Mucca e Mammifero.
Allo stesso modo, possiamo esprimere altre relazioni IS-A come segue:
Dati sopra sono alcuni degli esempi comuni di relazioni che possiamo esprimere usando l'ereditarietà in Java.
In generale, il tipo di relazione IS-A può essere espresso utilizzando l'ereditarietà.
Ora vediamo l'esempio di seguito:
Nel diagramma sopra, vediamo che un veicolo ha due parti, ovvero motore e freno. Allora come possiamo esprimere a parole questo scenario?
Possiamo dire che “un veicolo contiene un motore e un veicolo contiene un freno ”.
Quindi ciò che stiamo esprimendo qui non è la relazione “IS-A” ma una relazione di contenimento in cui specifichiamo un oggetto come parte di un altro oggetto.
domande e risposte intervista controllo qualità pdf
Nell'esempio sopra, un motore è un file parte di veicolo. Non è un ' tipo 'Veicolo. Questo è il ' HA UN 'O relazione di contenimento o composizione in Java. La relazione Has-a in Java viene espressa includendo un oggetto come membro della classe.
Quindi, se seguiamo lo stesso esempio di veicolo sopra, possiamo esprimerlo come di seguito:
class Engine{ } class Brake { } class Vehicle{ Engine e; Brake b; } Quindi un veicolo ha un motore e un freno. Esprimendo il rapporto nel modo sopra, non siamo interessati all'implementazione interna di Motore o freno. La classe del veicolo consentirà alle classi di motore e freno di sapere cosa è necessario e quelle classi lo forniranno.
Come la relazione IS-A, anche la relazione HAS-A è utile per riutilizzare il codice.
In questo tutorial, discuteremo in dettaglio dell'ereditarietà (IS-A) e nel prossimo tutorial discuteremo del contenimento o della composizione (HAS-A).
Esempio di ereditarietà Java
Implementiamo un semplice esempio in Java per dimostrare l'ereditarietà.
//example class demonstrating Inheritance in Java class BaseClass { public void display() { System.out.println('BaseClass::Display'); } } //create a new class from BaseClass class DerivedClass extends BaseClass { public void print() { System.out.println('DerivedClass::print'); } } class Main { public static void main(String() args) { //create an object of DerivedClass DerivedClass d1 = new DerivedClass(); d1.display(); //call BaseClass method d1.print(); //call DerivedClass method } }Produzione:
Il programma sopra mostra un semplice esempio di ereditarietà. Viene dichiarata una BaseClass con un metodo. Quindi viene dichiarata un'altra classe DerivedClass che estende BaseClass. Questa classe ha anche un metodo.
Nel metodo principale del programma, creiamo un oggetto DerivedClass e usando questo oggetto chiamiamo BaseClass così come il metodo DerivedClass.
L'output mostra i messaggi stampati con entrambi i metodi. Poiché DerivedClass estende il metodo BaseClass e BaseClass è pubblico, è visibile a DerivedClass.
Parola chiave 'super' in Java
In Ereditarietà, ci occupiamo di superclassi o classi genitore e classi figlie. Se dobbiamo accedere in modo intermedio ai membri della superclasse incluse variabili, metodi o costruttori, allora abbiamo bisogno di un meccanismo. Questo meccanismo di accesso ai membri della classe di base è fornito in Java utilizzando una parola chiave 'super'.
Quindi in quali scenari utilizziamo la parola chiave 'super' in Java?
Di seguito sono elencati gli scenari in cui una parola chiave 'super' può essere utile.
- Quando la classe super / base e la classe sub / derivata hanno lo stesso nome per i membri e vogliamo accedere ai membri della superclasse, utilizziamo la parola chiave super.
- Quando vogliamo accedere al costruttore della superclasse dalla sottoclasse, utilizziamo la parola chiave super per richiamare la parola chiave della superclasse.
Nella figura sopra, abbiamo mostrato una struttura di ereditarietà. Nella classe base e in quella derivata, abbiamo una variabile String myStr. Nella provenClass, abbiamo una funzione printStr (). In questo metodo, abbiamo utilizzato la parola chiave 'super' per accedere alla variabile myStr dalla classe base.
Nella figura, abbiamo mostrato le frecce che puntano alla variabile del membro della classe di base e alla variabile della classe derivata.
Vediamo ora gli esempi di programmazione dell'utilizzo della parola chiave super per accedere ai vari membri della superclasse.
# 1) Accedi alla variabile membro Superclass
Il seguente programma Java dimostra l'uso di una parola chiave 'super' per accedere alle variabili dalla classe base.
class Baseclass { String myStr; } class Subclass extends Baseclass { String myStr; public void printdetails() //Baseclass and Subclass have variables with same name { super.myStr = 'Super'; //refers to parent class member myStr = 'Sub'; System.out.println('Superclass myStr :' + super.myStr+' and Subclass myStr:'+myStr); } } class Main{ public static void main(String() args) { Subclass cobj = new Subclass(); cobj. printdetails (); } } Produzione:
Il programma precedente mostra come accedere alle variabili membro della classe base dalla classe derivata quando le variabili membro sono dichiarate con lo stesso nome sia nella classe base che in quella derivata.
Qui abbiamo la variabile myStr dichiarata nella classe base e derivata. Nel metodo printdetails, si fa riferimento alla variabile myStr della classe base utilizzando 'super.myStr' mentre si accede direttamente alla variabile della classe derivata myStr senza qualificatori.
# 2) Accedi al metodo Superclass
Successivamente, vedremo come chiamare il metodo della classe base quando il metodo nella classe base e il metodo nella classe derivata hanno gli stessi nomi.
Il seguente programma lo dimostra.
class Parent { String myStr; public void print() //parent class method { myStr = 'Parent class myStr'; System.out.println(myStr); } } class Child extends Parent { String myStr; public void print() //child class method with same name as parent { super.print(); //call Parent class print() method myStr = 'Child class myStr'; System.out.println(myStr); } } class Main{ public static void main(String() args) { Child c_obj = new Child(); c_obj.print (); } } Produzione:
# 3) Accedi a Superclass Constructor
miglior pulizia del disco per Windows 10
Quando ereditiamo una classe da un'altra, nota che i costruttori non vengono ereditati.
Se vogliamo eseguire qualsiasi istruzione dai costruttori della superclasse prima di eseguire il costruttore della classe derivata, allora possiamo anche chiamare il costruttore della superclasse usando la parola chiave 'super'.
Per chiamare il costruttore della superclasse usiamo la chiamata al metodo.
super (lista parametri ...)
Il seguente metodo dimostra l'accesso ai super costruttori in Java.
class Parent { String myStr; public Parent(String name) //base class constructor { myStr = name; } } class Child extends Parent { String myStr; public Child(String name1, String name2) { super(name1); //call base class constructor and pass argument value this.myStr = name2; } public void printDetails() //print details of both constructors { System.out.println('From base class constructor: ' +super.myStr); System.out.println('From derived class constructor: ' + myStr); } } class Main{ public static void main(String() args) { Child cobj = new Child('Super constructor string','Child constructor string'); cobj.printDetails(); } }Produzione:
Come possiamo vedere dal programma sopra, abbiamo chiamato il costruttore della superclasse dal costruttore della classe derivata. Nota che per convenzione, ogni volta che vogliamo accedere al costruttore della superclasse, dovrebbe essere la prima istruzione nel costruttore della classe derivata.
Poiché la classe base ha un costruttore parametrizzato, passiamo anche il parametro appropriato alla super chiamata durante la chiamata al costruttore.
Se non viene effettuata alcuna chiamata esplicita al super costruttore come sopra, il compilatore aggiunge sempre una chiamata implicita a super () automaticamente. Ma nota che questa sarà una chiamata al costruttore predefinito della superclasse.
Domande frequenti
D # 1) Cos'è l'ereditarietà in Java?
Risposta: Un processo mediante il quale una classe acquisisce le proprietà e il comportamento di un'altra classe è chiamato ereditarietà. In Java, una classe viene ereditata da un'altra classe utilizzando la parola chiave 'extends'.
L'ereditarietà promuove la riusabilità del codice poiché ereditando possiamo acquisire e utilizzare le proprietà e il comportamento già esistenti di una classe ereditata senza dover scrivere codice duplicato.
D # 2) Perché l'ereditarietà viene utilizzata in Java?
Risposta: L'ereditarietà viene utilizzata principalmente per migliorare la riutilizzabilità dell'applicazione. Usando l'ereditarietà possiamo usare classi pronte nella nostra applicazione. Non dobbiamo scrivere il nostro codice se abbiamo la funzionalità pronta.
Il secondo uso dell'ereditarietà è nell'override del metodo. Per implementare il polimorfismo a runtime utilizziamo l'ereditarietà.
D # 3) Quali sono i vantaggi dell'ereditarietà?
Risposta: La riusabilità è il vantaggio chiave dell'ereditarietà. La condivisione del codice tramite l'ereditarietà si traduce anche in una migliore leggibilità e una migliore organizzazione del codice.
Possiamo anche ottenere il polimorfismo di runtime attraverso l'override del metodo usando l'ereditarietà.
Q # 4) Quali sono le caratteristiche dell'ereditarietà?
Risposta: Qualsiasi caratteristica o caratteristica acquisita dalla vecchia generazione è ottenuta tramite eredità. Per esempio, il tratto dell'occhio chiaro che si manifesta in molte famiglie è un esempio di eredità.
Dal punto di vista della programmazione, l'ereditarietà fornisce la caratteristica della riusabilità e dell'override del metodo.
Q # 5) È necessario super ()?
Risposta: No. Perché se non chiamiamo super (), il compilatore lo fa implicitamente per noi. Ma allora l'invocazione implicita di super () è il costruttore della classe base predefinito. Quindi, se abbiamo bisogno di un costruttore parametrizzato da una classe base, dovremmo chiamarlo esplicitamente.
Conclusione
In questo tutorial, abbiamo introdotto il concetto di ereditarietà in Java. L'ereditarietà è il processo di acquisizione delle proprietà e del comportamento di una classe in un'altra classe. Abbiamo discusso la definizione di base e la terminologia che usiamo nell'ereditarietà qui.
Abbiamo anche discusso le relazioni Is-A e Has-A in Java. L'ereditarietà viene utilizzata per implementare una relazione È-A.
Quindi abbiamo discusso le parole chiave 'extends' e 'super' in Java utilizzate in relazione all'ereditarietà. Extends viene utilizzato per implementare l'ereditarietà. La parola chiave super viene utilizzata per fare riferimento al costruttore della classe di base, al metodo o alla variabile dalla classe derivata.
=> Dai un'occhiata alla guida di formazione Java perfetta qui.
Lettura consigliata
- Tutorial di classe per scanner Java con esempi
- Cos'è Java Vector | Tutorial Java Vector Class con esempi
- Java Enum: Tutorial sull'enumerazione Java con esempi
- Metodo Java String length () con esempi
- Tutorial Java Float con esempi di programmazione
- Ereditarietà in C ++
- Tipi di ereditarietà in C ++
- Concetti di Python OOPs (classi, oggetti ed ereditarietà Python)