TechCodeview

1. Eredità
2. Tipi di eredità
3. Perché l'ereditarietà multipla non è possibile in Java in caso di classe?

Eredità in Java è un meccanismo in cui un oggetto acquisisce tutte le proprietà e i comportamenti di un oggetto genitore. È una parte importante di Ops (Sistema di programmazione orientato agli oggetti).

L'idea alla base dell'ereditarietà in Java è che puoi crearne di nuovi classi che sono costruiti su classi esistenti. Quando erediti da una classe esistente, puoi riutilizzare metodi e campi della classe genitore. Inoltre, puoi anche aggiungere nuovi metodi e campi nella tua classe attuale.

L'ereditarietà rappresenta il È-Una relazione che è anche conosciuto come a genitore-figlio relazione.

Perché usare l'ereditarietà in Java

• Per Metodo prioritario (COSÌ polimorfismo di esecuzione può essere raggiunto).
• Per la riusabilità del codice.

Termini utilizzati in Eredità

Classe:Una classe è un gruppo di oggetti che hanno proprietà comuni. È un modello o un progetto da cui vengono creati gli oggetti.Sottoclasse/Classe secondaria:La sottoclasse è una classe che eredita l'altra classe. È detta anche classe derivata, classe estesa o classe figlia.Super Classe/Classe Genitore:La superclasse è la classe da cui una sottoclasse eredita le funzionalità. È anche chiamata classe base o classe genitore.Riutilizzabilità:Come specifica il nome, la riusabilità è un meccanismo che facilita il riutilizzo dei campi e dei metodi della classe esistente quando si crea una nuova classe. Puoi utilizzare gli stessi campi e metodi già definiti nella lezione precedente.

La sintassi dell'ereditarietà Java

 class Subclass-name extends Superclass-name { //methods and fields } 

IL estende la parola chiave indica che stai creando una nuova classe che deriva da una classe esistente. Il significato di 'estende' è aumentare la funzionalità.

array di oggetti in Java

Nella terminologia di Java, una classe ereditata è chiamata genitore o superclasse, e la nuova classe è chiamata figlia o sottoclasse.

Esempio di eredità Java

Come mostrato nella figura sopra, Programmatore è la sottoclasse e Dipendente è la superclasse. La relazione tra le due classi è Programmatore IS-A Dipendente . Significa che il Programmatore è un tipo di Dipendente.

lupo contro volpe

 class Employee{ float salary=40000; } class Programmer extends Employee{ int bonus=10000; public static void main(String args[]){ Programmer p=new Programmer(); System.out.println('Programmer salary is:'+p.salary); System.out.println('Bonus of Programmer is:'+p.bonus); } } 

 Programmer salary is:40000.0 Bonus of programmer is:10000 

Nell'esempio sopra, l'oggetto Programmatore può accedere al campo della propria classe e della classe Impiegato, ovvero alla riusabilità del codice.

Tipi di ereditarietà in Java

In base alla classe, in Java possono esserci tre tipi di ereditarietà: singola, multilivello e gerarchica.

Nella programmazione Java, l'ereditarietà multipla e ibrida è supportata solo tramite l'interfaccia. Impareremo le interfacce più tardi.

Nota: l'ereditarietà multipla non è supportata in Java tramite la classe.

Quando una classe eredita più classi, si parla di ereditarietà multipla. Per esempio:

Esempio di eredità singola

Quando una classe eredita un'altra classe, è nota come a eredità unica . Nell'esempio riportato di seguito, la classe Dog eredita la classe Animal, quindi esiste un'ereditarietà singola.

File: TestInheritance.java

 class Animal{ void eat(){System.out.println('eating...');} } class Dog extends Animal{ void bark(){System.out.println('barking...');} } class TestInheritance{ public static void main(String args[]){ Dog d=new Dog(); d.bark(); d.eat(); }} 

Produzione:

 barking... eating... 

Esempio di ereditarietà multilivello

Quando esiste una catena ereditaria, è nota come eredità multilivello . Come puoi vedere nell'esempio riportato di seguito, la classe BabyDog eredita la classe Dog che eredita a sua volta la classe Animal, quindi esiste un'ereditarietà multilivello.

File: TestInheritance2.java

gestione delle stringhe in c++

 class Animal{ void eat(){System.out.println('eating...');} } class Dog extends Animal{ void bark(){System.out.println('barking...');} } class BabyDog extends Dog{ void weep(){System.out.println('weeping...');} } class TestInheritance2{ public static void main(String args[]){ BabyDog d=new BabyDog(); d.weep(); d.bark(); d.eat(); }} 

Produzione:

 weeping... barking... eating... 

Esempio di ereditarietà gerarchica

Quando due o più classi ereditano una singola classe, è nota come eredità gerarchica . Nell'esempio riportato di seguito, le classi Cane e Gatto ereditano la classe Animale, quindi esiste un'ereditarietà gerarchica.

File: TestInheritance3.java

 class Animal{ void eat(){System.out.println('eating...');} } class Dog extends Animal{ void bark(){System.out.println('barking...');} } class Cat extends Animal{ void meow(){System.out.println('meowing...');} } class TestInheritance3{ public static void main(String args[]){ Cat c=new Cat(); c.meow(); c.eat(); //c.bark();//C.T.Error }} 

Produzione:

finestra.apri javascript

 meowing... eating... 

D) Perché l'ereditarietà multipla non è supportata in Java?

Per ridurre la complessità e semplificare il linguaggio, Java non supporta l'ereditarietà multipla.

Considera uno scenario in cui A, B e C sono tre classi. La classe C eredita le classi A e B. Se le classi A e B hanno lo stesso metodo e lo chiami dall'oggetto della classe figlio, ci sarà ambiguità nel chiamare il metodo della classe A o B.

Poiché gli errori in fase di compilazione sono migliori degli errori di runtime, Java restituisce un errore in fase di compilazione se si ereditano 2 classi. Quindi, indipendentemente dal fatto che tu abbia lo stesso metodo o un metodo diverso, si verificherà un errore in fase di compilazione.

 class A{ void msg(){System.out.println('Hello');} } class B{ void msg(){System.out.println('Welcome');} } class C extends A,B{//suppose if it were public static void main(String args[]){ C obj=new C(); obj.msg();//Now which msg() method would be invoked? } } 

 Compile Time Error