Java - Héritage

L'héritage peut être défini comme le processus par lequel une classe acquiert les propriétés (méthodes et champs) d'une autre. Avec l'utilisation de l'héritage, les informations sont gérables dans un ordre hiérarchique.

La classe qui hérite des propriétés des autres est appelée sous-classe (classe dérivée, classe enfant) et la classe dont les propriétés sont héritées est appelée superclasse (classe de base, classe parent).

étend le mot-clé

extendsest le mot-clé utilisé pour hériter des propriétés d'une classe. Voici la syntaxe du mot-clé extend.

Syntax

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

Exemple de code

Voici un exemple illustrant l'héritage Java. Dans cet exemple, vous pouvez observer deux classes à savoir Calculation et My_Calculation.

En utilisant le mot clé extend, le My_Calculation hérite des méthodes addition () et Subtraction () de la classe Calculation.

Copiez et collez le programme suivant dans un fichier avec le nom 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);
   }
}

Compilez et exécutez le code ci-dessus comme indiqué ci-dessous.

javac My_Calculation.java
java My_Calculation

Après avoir exécuté le programme, il produira le résultat suivant -

Output

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

Dans le programme donné, lorsqu'un objet à My_Calculationclasse est créée, une copie du contenu de la superclasse y est faite. C'est pourquoi, en utilisant l'objet de la sous-classe, vous pouvez accéder aux membres d'une superclasse.

La variable de référence Superclass peut contenir l'objet de sous-classe, mais en utilisant cette variable, vous ne pouvez accéder qu'aux membres de la superclasse, donc pour accéder aux membres des deux classes, il est recommandé de toujours créer une variable de référence pour la sous-classe.

Si vous considérez le programme ci-dessus, vous pouvez instancier la classe comme indiqué ci-dessous. Mais en utilisant la variable de référence de superclasse (cal dans ce cas) vous ne pouvez pas appeler la méthode multiplication(), qui appartient à la sous-classe My_Calculation.

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

Note- Une sous-classe hérite de tous les membres (champs, méthodes et classes imbriquées) de sa superclasse. Les constructeurs ne sont pas des membres, ils ne sont donc pas hérités par les sous-classes, mais le constructeur de la superclasse peut être appelé à partir de la sous-classe.

Le super mot-clé

le super mot-clé est similaire à thismot-clé. Voici les scénarios dans lesquels le mot-clé super est utilisé.

  • Il est utilisé pour differentiate the members de la superclasse des membres de la sous-classe, s'ils ont les mêmes noms.

  • Il est utilisé pour invoke the superclass constructeur de la sous-classe.

Différencier les membres

Si une classe hérite des propriétés d'une autre classe. Et si les membres de la superclasse ont les mêmes noms que la sous-classe, pour différencier ces variables, nous utilisons le mot clé super comme indiqué ci-dessous.

super.variable
super.method();

Exemple de code

Cette section vous propose un programme illustrant l'utilisation du super mot-clé.

Dans le programme donné, vous avez deux classes à savoir Sub_class et Super_class , les deux ont une méthode nommée display () avec des implémentations différentes, et une variable nommée num avec des valeurs différentes. Nous invoquons la méthode display () des deux classes et imprimons la valeur de la variable num des deux classes. Ici, vous pouvez observer que nous avons utilisé un mot clé super pour différencier les membres de la superclasse de la sous-classe.

Copiez et collez le programme dans un fichier avec le nom 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();
   }
}

Compilez et exécutez le code ci-dessus en utilisant la syntaxe suivante.

javac Super_Demo
java Super

Lors de l'exécution du programme, vous obtiendrez le résultat suivant -

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

Invoquer le constructeur de superclasse

Si une classe hérite des propriétés d'une autre classe, la sous-classe acquiert automatiquement le constructeur par défaut de la superclasse. Mais si vous souhaitez appeler un constructeur paramétré de la superclasse, vous devez utiliser le mot clé super comme indiqué ci-dessous.

super(values);

Exemple de code

Le programme donné dans cette section montre comment utiliser le mot clé super pour invoquer le constructeur paramétré de la superclasse. Ce programme contient une superclasse et une sous-classe, où la superclasse contient un constructeur paramétré qui accepte une valeur entière, et nous avons utilisé le mot-clé super pour appeler le constructeur paramétré de la superclasse.

Copiez et collez le programme suivant dans un fichier avec le nom 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();
   }
}

Compilez et exécutez le code ci-dessus en utilisant la syntaxe suivante.

javac Subclass
java Subclass

Lors de l'exécution du programme, vous obtiendrez le résultat suivant -

Output

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

Relation IS-A

IS-A est une façon de dire: cet objet est un type de cet objet. Voyons comment leextends Le mot-clé est utilisé pour obtenir l'héritage.

public class Animal {
}

public class Mammal extends Animal {
}

public class Reptile extends Animal {
}

public class Dog extends Mammal {
}

Maintenant, sur la base de l'exemple ci-dessus, en termes orientés objet, ce qui suit est vrai -

  • L'animal est la superclasse de la classe des mammifères.
  • L'animal est la superclasse de la classe Reptile.
  • Les mammifères et les reptiles sont des sous-classes de la classe animale.
  • Le chien est la sous-classe des classes de mammifères et d'animaux.

Maintenant, si nous considérons la relation IS-A, nous pouvons dire -

  • Mammifère IS-A Animal
  • Reptile IS-A Animal
  • Chien IS-A Mammal
  • Par conséquent: le chien est aussi un animal

Avec l'utilisation du mot-clé extend, les sous-classes pourront hériter de toutes les propriétés de la superclasse à l'exception des propriétés privées de la superclasse.

Nous pouvons garantir que Mammal est en fait un animal avec l'utilisation de l'opérateur d'instance.

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);
   }
}

Cela produira le résultat suivant -

Output

true
true
true

Puisque nous avons une bonne compréhension de la extends mot-clé, voyons comment le implements Le mot clé est utilisé pour obtenir la relation IS-A.

Généralement, le implementsLe mot-clé est utilisé avec des classes pour hériter des propriétés d'une interface. Les interfaces ne peuvent jamais être étendues par une classe.

Example

public interface Animal {
}

public class Mammal implements Animal {
}

public class Dog extends Mammal {
}

L'instance de mot-clé

Utilisons le instanceof l'opérateur pour vérifier si le mammifère est réellement un animal et si le chien est en fait un animal.

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);
   }
}

Cela produira le résultat suivant -

Output

true
true
true

Relation HAS-A

Ces relations sont principalement basées sur l'usage. Cela détermine si une certaine classeHAS-Acertaine chose. Cette relation permet de réduire la duplication du code ainsi que les bogues.

Regardons un exemple -

Example

public class Vehicle{}
public class Speed{}

public class Van extends Vehicle {
   private Speed sp;
}

Cela montre que la classe Van HAS-A Speed. En ayant une classe distincte pour Speed, nous n'avons pas à mettre tout le code appartenant à speed dans la classe Van, ce qui permet de réutiliser la classe Speed ​​dans plusieurs applications.

Dans la fonction orientée objet, les utilisateurs n'ont pas besoin de se soucier de quel objet fait le vrai travail. Pour ce faire, la classe Van masque les détails d'implémentation aux utilisateurs de la classe Van. Donc, fondamentalement, ce qui se passe, c'est que les utilisateurs demanderaient à la classe Van de faire une certaine action et la classe Van fera le travail par elle-même ou demandera à une autre classe d'exécuter l'action.

Types d'héritage

Il existe différents types d'héritage comme indiqué ci-dessous.

Un fait très important à retenir est que Java ne prend pas en charge l'héritage multiple. Cela signifie qu'une classe ne peut pas étendre plus d'une classe. Par conséquent, suivre est illégal -

Example

public class extends Animal, Mammal{}

Cependant, une classe peut implémenter une ou plusieurs interfaces, ce qui a aidé Java à se débarrasser de l'impossibilité d'héritage multiple.