Java - Ereditarietà

L'ereditarietà può essere definita come il processo in cui una classe acquisisce le proprietà (metodi e campi) di un'altra. Con l'uso dell'ereditarietà le informazioni vengono rese gestibili in ordine gerarchico.

La classe che eredita le proprietà di altri è nota come sottoclasse (classe derivata, classe figlia) e la classe le cui proprietà sono ereditate è nota come superclasse (classe base, classe genitore).

estende la parola chiave

extendsè la parola chiave utilizzata per ereditare le proprietà di una classe. Di seguito è riportata la sintassi della parola chiave extends.

Syntax

class Super {
   .....
   .....
}
class Sub extends Super {
   .....
   .....
}

Codice d'esempio

Di seguito è riportato un esempio che dimostra l'ereditarietà Java. In questo esempio, puoi osservare due classi, ovvero Calcolo e Mio_Calcolo.

Utilizzando la parola chiave extends, My_Calculation eredita i metodi addition () e Subtraction () della classe Calculation.

Copia e incolla il seguente programma in un file con nome My_Calculation.java

Example

class Calculation {
   int z;
	
   public void addition(int x, int y) {
      z = x + y;
      System.out.println("The sum of the given numbers:"+z);
   }
	
   public void Subtraction(int x, int y) {
      z = x - y;
      System.out.println("The difference between the given numbers:"+z);
   }
}

public class My_Calculation extends Calculation {
   public void multiplication(int x, int y) {
      z = x * y;
      System.out.println("The product of the given numbers:"+z);
   }
	
   public static void main(String args[]) {
      int a = 20, b = 10;
      My_Calculation demo = new My_Calculation();
      demo.addition(a, b);
      demo.Subtraction(a, b);
      demo.multiplication(a, b);
   }
}

Compila ed esegui il codice sopra come mostrato di seguito.

javac My_Calculation.java
java My_Calculation

Dopo aver eseguito il programma, produrrà il seguente risultato:

Output

The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200

Nel programma dato, quando un oggetto My_Calculationviene creata una classe, una copia del contenuto della superclasse viene creata al suo interno. Ecco perché, utilizzando l'oggetto della sottoclasse, puoi accedere ai membri di una superclasse.

La variabile di riferimento Superclass può contenere l'oggetto sottoclasse, ma usando quella variabile puoi accedere solo ai membri della superclasse, quindi per accedere ai membri di entrambe le classi si consiglia di creare sempre una variabile di riferimento alla sottoclasse.

Se consideri il programma sopra, puoi istanziare la classe come indicato di seguito. Ma usando la variabile di riferimento della superclasse (cal in questo caso) non è possibile chiamare il metodo multiplication(), che appartiene alla sottoclasse My_Calculation.

Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);

Note- Una sottoclasse eredita tutti i membri (campi, metodi e classi nidificate) dalla sua superclasse. I costruttori non sono membri, quindi non vengono ereditati dalle sottoclassi, ma il costruttore della superclasse può essere richiamato dalla sottoclasse.

La super parola chiave

Il super la parola chiave è simile a thisparola chiave. Di seguito sono riportati gli scenari in cui viene utilizzata la parola chiave super.

• È abituato differentiate the members di superclasse dai membri della sottoclasse, se hanno lo stesso nome.

• È abituato invoke the superclass costruttore dalla sottoclasse.

Differenziare i membri

Se una classe eredita le proprietà di un'altra classe. E se i membri della superclasse hanno gli stessi nomi della sottoclasse, per differenziare queste variabili usiamo la parola chiave super come mostrato di seguito.

super.variable
super.method();

Codice d'esempio

Questa sezione fornisce un programma che dimostra l'utilizzo di super parola chiave.

Nel programma dato, hai due classi e cioè Sub_class e Super_class , entrambe hanno un metodo chiamato display () con differenti implementazioni e una variabile chiamata num con valori differenti. Stiamo invocando il metodo display () di entrambe le classi e stampando il valore della variabile num di entrambe le classi. Qui puoi osservare che abbiamo usato la parola chiave super per differenziare i membri della superclasse dalla sottoclasse.

Copia e incolla il programma in un file con nome Sub_class.java.

Example

class Super_class {
   int num = 20;

   // display method of superclass
   public void display() {
      System.out.println("This is the display method of superclass");
   }
}

public class Sub_class extends Super_class {
   int num = 10;

   // display method of sub class
   public void display() {
      System.out.println("This is the display method of subclass");
   }

   public void my_method() {
      // Instantiating subclass
      Sub_class sub = new Sub_class();

      // Invoking the display() method of sub class
      sub.display();

      // Invoking the display() method of superclass
      super.display();

      // printing the value of variable num of subclass
      System.out.println("value of the variable named num in sub class:"+ sub.num);

      // printing the value of variable num of superclass
      System.out.println("value of the variable named num in super class:"+ super.num);
   }

   public static void main(String args[]) {
      Sub_class obj = new Sub_class();
      obj.my_method();
   }
}

Compila ed esegui il codice precedente utilizzando la seguente sintassi.

javac Super_Demo
java Super

Eseguendo il programma, otterrai il seguente risultato:

Output

This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

Invocare Superclass Constructor

Se una classe eredita le proprietà di un'altra classe, la sottoclasse acquisisce automaticamente il costruttore predefinito della superclasse. Ma se vuoi chiamare un costruttore parametrizzato della superclasse, devi usare la parola chiave super come mostrato di seguito.

super(values);

Codice d'esempio

Il programma fornito in questa sezione mostra come utilizzare la parola chiave super per invocare il costruttore parametrizzato della superclasse. Questo programma contiene una superclasse e una sottoclasse, dove la superclasse contiene un costruttore parametrizzato che accetta un valore intero, e abbiamo usato la parola chiave super per invocare il costruttore parametrizzato della superclasse.

Copia e incolla il seguente programma in un file con il nome Subclass.java

Example

class Superclass {
   int age;

   Superclass(int age) {
      this.age = age; 		 
   }

   public void getAge() {
      System.out.println("The value of the variable named age in super class is: " +age);
   }
}

public class Subclass extends Superclass {
   Subclass(int age) {
      super(age);
   }

   public static void main(String args[]) {
      Subclass s = new Subclass(24);
      s.getAge();
   }
}

Compila ed esegui il codice precedente utilizzando la seguente sintassi.

javac Subclass
java Subclass

Eseguendo il programma, otterrai il seguente risultato:

Output

The value of the variable named age in super class is: 24

Relazione IS-A

IS-A è un modo per dire: questo oggetto è un tipo di quell'oggetto. Vediamo come il fileextends la parola chiave viene utilizzata per ottenere l'ereditarietà.

public class Animal {
}

public class Mammal extends Animal {
}

public class Reptile extends Animal {
}

public class Dog extends Mammal {
}

Ora, sulla base dell'esempio precedente, in termini orientati agli oggetti, quanto segue è vero:

• L'animale è la superclasse della classe Mammal.
• Animal è la superclasse della classe Reptile.
• Mammifero e Rettile sono sottoclassi della classe Animale.
• Il cane è la sottoclasse di entrambe le classi Mammiferi e Animali.

Ora, se consideriamo la relazione IS-A, possiamo dire:

• Il mammifero è un animale
• Il rettile è un animale
• Il cane è un mammifero
• Quindi: anche il cane è un animale

Con l'uso della parola chiave extends, le sottoclassi potranno ereditare tutte le proprietà della superclasse tranne le proprietà private della superclasse.

Possiamo assicurare che Mammal è effettivamente un Animale con l'uso dell'operatore di istanza.

Example

class Animal {
}

class Mammal extends Animal {
}

class Reptile extends Animal {
}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

Questo produrrà il seguente risultato:

Output

true
true
true

Poiché abbiamo una buona conoscenza di extends parola chiave, esaminiamo come la implements la parola chiave viene utilizzata per ottenere la relazione IS-A.

In generale, il implementsla parola chiave viene utilizzata con le classi per ereditare le proprietà di un'interfaccia. Le interfacce non possono mai essere estese da una classe.

Example

public interface Animal {
}

public class Mammal implements Animal {
}

public class Dog extends Mammal {
}

L'istanza della parola chiave

Usiamo il file instanceof operatore per verificare se il mammifero è effettivamente un animale e il cane è effettivamente un animale.

Example

interface Animal{}
class Mammal implements Animal{}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

Questo produrrà il seguente risultato:

Output

true
true
true

Relazione HAS-A

Queste relazioni si basano principalmente sull'utilizzo. Questo determina se una certa classeHAS-Acerta cosa. Questa relazione aiuta a ridurre la duplicazione del codice e i bug.

Vediamo un esempio:

Example

public class Vehicle{}
public class Speed{}

public class Van extends Vehicle {
   private Speed sp;
}

Questo mostra quella classe Van HAS-A Speed. Avendo una classe separata per Speed, non dobbiamo inserire l'intero codice che appartiene a speed all'interno della classe Van, il che rende possibile riutilizzare la classe Speed ​​in più applicazioni.

Nella funzionalità orientata agli oggetti, gli utenti non devono preoccuparsi di quale oggetto sta facendo il lavoro reale. Per ottenere ciò, la classe Van nasconde i dettagli di implementazione agli utenti della classe Van. Quindi, in pratica, ciò che accade è che gli utenti chiedono alla classe Van di eseguire una determinata azione e la classe Van farà il lavoro da sola o chiederà a un'altra classe di eseguire l'azione.

Tipi di ereditarietà

Esistono vari tipi di ereditarietà come illustrato di seguito.

Un fatto molto importante da ricordare è che Java non supporta l'ereditarietà multipla. Ciò significa che una classe non può estendere più di una classe. Quindi seguire è illegale -

Example

public class extends Animal, Mammal{}

Tuttavia, una classe può implementare una o più interfacce, il che ha aiutato Java a sbarazzarsi dell'impossibilità di ereditarietà multipla.