In questo tutorial, impareremo l'ereditarietà di Java e i suoi tipi con l'aiuto di example.
L'ereditarietà è una delle caratteristiche chiave di OOP che ci consente di creare una nuova classe da una classe esistente.
La nuova classe creata è nota come sottoclasse (figlio o classe derivata) e la classe esistente da cui deriva la classe figlia è nota come superclasse (genitore o classe base).
La extendsparola chiave viene utilizzata per eseguire l'ereditarietà in Java. Per esempio,
class Animal ( // methods and fields ) // use of extends keyword // to perform inheritance class Dog extends Animal ( // methods and fields of Animal // methods and fields of Dog )
Nell'esempio precedente, la classe Dog viene creata ereditando i metodi e i campi dalla classe Animal.
Qui, Dog è la sottoclasse e Animal è la superclasse.
Esempio 1: ereditarietà Java
class Animal ( // field and method of the parent class String name; public void eat() ( System.out.println("I can eat"); ) ) // inherit from Animal class Dog extends Animal ( // new method in subclass public void display() ( System.out.println("My name is " + name); ) ) class Main ( public static void main(String() args) ( // create an object of the subclass Dog labrador = new Dog(); // access field of superclass labrador.name = "Rohu"; labrador.display(); // call method of superclass // using object of subclass labrador.eat(); ) )
Produzione
Il mio nome è Rohu posso mangiare
Nell'esempio sopra, abbiamo derivato una sottoclasse Dog dalla superclasse Animal. Notare le dichiarazioni,
labrador.name = "Rohu"; labrador.eat();
Qui, il labrador è un oggetto di Dog. Tuttavia, nome e eat()sono i membri della classe Animal.
Poiché Dog eredita il campo e il metodo da Animal, siamo in grado di accedere al campo e al metodo utilizzando l'oggetto del cane.
Implementazione dell'ereditarietà Java
è una relazione
In Java, l'ereditarietà è una relazione. Cioè, usiamo l'ereditarietà solo se esiste una relazione è-una tra due classi. Per esempio,
- L'auto è un veicolo
- L'arancia è un frutto
- Il chirurgo è un dottore
- Il cane è un animale
Qui, Car può ereditare da Vehicle , Orange può ereditare da Fruit e così via.
Sostituzione del metodo nell'ereditarietà Java
In Esempio 1 , si vede l'oggetto della sottoclasse può accedere al metodo della superclasse.
Tuttavia, se lo stesso metodo è presente sia nella superclasse che nella sottoclasse, cosa succederà?
In questo caso, il metodo nella sottoclasse sovrascrive il metodo nella superclasse. Questo concetto è noto come override del metodo in Java.
Esempio 2: sovrascrittura del metodo in Java Inheritance
class Animal ( // method in the superclass public void eat() ( System.out.println("I can eat"); ) ) // Dog inherits Animal class Dog extends Animal ( // overriding the eat() method @Override public void eat() ( System.out.println("I eat dog food"); ) // new method in subclass public void bark() ( System.out.println("I can bark"); ) ) class Main ( public static void main(String() args) ( // create an object of the subclass Dog labrador = new Dog(); // call the eat() method labrador.eat(); labrador.bark(); ) )
Produzione
Mangio cibo per cani che posso abbaiare
Nell'esempio sopra, il eat()metodo è presente sia nella superclasse Animal che nella sottoclasse Dog.
Qui abbiamo creato un oggetto labrador di Dog.
Ora, quando chiamiamo eat()using l'oggetto labrador, viene chiamato il metodo all'interno di Dog. Questo perché il metodo all'interno della classe derivata sovrascrive il metodo all'interno della classe base.
Questo è chiamato override del metodo. Per ulteriori informazioni, visita Sostituzione del metodo Java.
Nota : abbiamo usato l' @Overrideannotazione per dire al compilatore che stiamo sovrascrivendo un metodo. Tuttavia, l'annotazione non è obbligatoria. Per saperne di più, visita Annotazioni Java.
super parola chiave in eredità Java
In precedenza abbiamo visto che lo stesso metodo nella sottoclasse sovrascrive il metodo nella superclasse.
In una tale situazione, la superparola chiave viene utilizzata per chiamare il metodo della classe genitore dal metodo della classe figlia.
Esempio 3: super parola chiave in ereditarietà
class Animal ( // method in the superclass public void eat() ( System.out.println("I can eat"); ) ) // Dog inherits Animal class Dog extends Animal ( // overriding the eat() method @Override public void eat() ( // call method of superclass super.eat(); System.out.println("I eat dog food"); ) // new method in subclass public void bark() ( System.out.println("I can bark"); ) ) class Main ( public static void main(String() args) ( // create an object of the subclass Dog labrador = new Dog(); // call the eat() method labrador.eat(); labrador.bark(); ) )
Produzione
Posso mangiare Mangio cibo per cani che posso abbaiare
Nell'esempio precedente, il eat()metodo è presente sia nella classe base Animal che nella classe derivata Dog. Notare la dichiarazione,
super.eat();
Qui, la superparola chiave viene utilizzata per chiamare il eat()metodo presente nella superclasse.
Possiamo anche usare la superparola chiave per chiamare il costruttore della superclasse dal costruttore della sottoclasse. Per saperne di più, visita Java super keyword .
Membri protetti in eredità
In Java, se una classe include protectedcampi e metodi, questi campi e metodi sono accessibili dalla sottoclasse della classe.
Example 4: protected Members in Inheritance
class Animal ( protected String name; protected void display() ( System.out.println("I am an animal."); ) ) class Dog extends Animal ( public void getInfo() ( System.out.println("My name is " + name); ) ) class Main ( public static void main(String() args) ( // create an object of the subclass Dog labrador = new Dog(); // access protected field and method // using the object of subclass labrador.name = "Rocky"; labrador.display(); labrador.getInfo(); ) )
Output
I am an animal. My name is Rocky
In the above example, we have created a class named Animal. The class includes a protected field: name and a method: display().
We have inherited the Dog class inherits Animal. Notice the statement,
labrador.name = "Rocky"; labrador.display();
Here, we are able to access the protected field and method of the superclass using the labrador object of the subclass.
Why use inheritance?
- The most important use of inheritance in Java is code reusability. The code that is present in the parent class can be directly used by the child class.
- Method overriding is also known as runtime polymorphism. Hence, we can achieve Polymorphism in Java with the help of inheritance.
Types of inheritance
There are five types of inheritance.
1. Single Inheritance
Nell'ereditarietà singola, una singola sottoclasse si estende da una singola superclasse. Per esempio,
Ereditarietà singola Java
2. Ereditarietà multilivello
Nell'ereditarietà multilivello, una sottoclasse si estende da una superclasse e quindi la stessa sottoclasse agisce come una superclasse per un'altra classe. Per esempio,
Ereditarietà multilivello Java
3. Eredità gerarchica
Nell'ereditarietà gerarchica, più sottoclassi si estendono da una singola superclasse. Per esempio,
Ereditarietà gerarchica Java
4. Ereditarietà multipla
Nell'ereditarietà multipla, una singola sottoclasse si estende da più superclassi. Per esempio,
Ereditarietà multipla Java
Nota : Java non supporta l'ereditarietà multipla. Tuttavia, possiamo ottenere più eredità utilizzando le interfacce. Per saperne di più, visita Java implementa l'ereditarietà multipla.
5. Ereditarietà ibrida
L'ereditarietà ibrida è una combinazione di due o più tipi di ereditarietà. Per esempio,
Ereditarietà ibrida Java
Qui, abbiamo combinato l'ereditarietà gerarchica e multipla per formare un'eredità ibrida.
