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 rendues gérables dans un ordre hiérarchique.
La classe qui hérite des propriétés de other 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é
étend est le mot clé utilisé pour hériter des propriétés d'une classe. Voici la syntaxe du mot clé extend.
Syntaxe
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}
Exemple de code
Voici un exemple démontrant l'héritage Java. Dans cet exemple, vous pouvez observer deux classes, à savoir Calculation et My_Calculation.
En utilisant le mot clé extend, My_Calculation hérite des méthodes addition() et Subtraction() de la classe Calculation.
Copiez et collez le programme suivant dans un fichier nommé My_Calculation.java
Exemple
Démo en direct
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 −
Sortie
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 de My_Calculation classe est créée, une copie du contenu de la superclasse est faite à l'intérieur de celle-ci. C'est pourquoi, en utilisant l'objet de la sous-classe, vous pouvez accéder aux membres d'une super-classe.
La variable de référence de la superclasse peut contenir l'objet de la 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 à 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);
Remarque − Une sous-classe hérite de tous les membres (champs, méthodes et classes imbriquées) de sa super-classe. 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 invoqué à partir de la sous-classe.
Le super mot-clé
Le super le mot-clé est similaire à ceci mot-clé. Voici les scénarios dans lesquels le super mot-clé est utilisé.
-
Il est utilisé pour différencier les membres de la superclasse parmi les membres de la sous-classe, s'ils ont le même nom.
-
Il est utilisé pour invoquer la superclasse 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 fournit un programme qui démontre l'utilisation du super mot-clé.
Dans le programme donné, vous avez deux classes à savoir Sub_class et Super_classe , 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é le 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.
Exemple
Démo en direct
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
En exécutant le programme, vous obtiendrez le résultat suivant −
Sortie
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 voulez 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 invoquer le constructeur paramétré de la superclasse.
Copiez et collez le programme suivant dans un fichier nommé Subclass.java
Exemple
Démo en direct
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
En exécutant le programme, vous obtiendrez le résultat suivant −
Sortie
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 le s'étend 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, les éléments suivants sont vrais −
- Animal est la superclasse de la classe Mammifère.
- Animal est la superclasse de la classe Reptile.
- Mammifère et Reptile sont des sous-classes de la classe Animal.
- Chien est la sous-classe des classes Mammifère et Animal.
Maintenant, si nous considérons la relation IS-A, nous pouvons dire −
- Mammifère EST UN Animal
- Le reptile est un animal
- Le chien est un mammifère
- Par conséquent :le chien est également 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 bien un Animal grâce à l'utilisation de l'opérateur d'instance.
Exemple
Démo en direct
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 −
Sortie
true true true
Puisque nous avons une bonne compréhension des extensions mot-clé, examinons comment le implémente mot-clé est utilisé pour obtenir la relation IS-A.
Généralement, les outils Le 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.
Exemple
public interface Animal {
}
public class Mammal implements Animal {
}
public class Dog extends Mammal {
}
L'instance du mot clé
Utilisons l'instanceof opérateur pour vérifier si le mammifère est en fait un animal et si le chien est en fait un animal.
Exemple
Démo en direct
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 −
Sortie
true true true
Relation A-A
Ces relations sont principalement basées sur l'utilisation. Ceci détermine si une certaine classe HAS-A certaine chose. Cette relation permet de réduire la duplication de code ainsi que les bugs.
Prenons un exemple −
Exemple
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
}
Cela montre que la classe Van A-A Speed. En ayant une classe distincte pour la vitesse, nous n'avons pas à mettre tout le code qui appartient à la vitesse à l'intérieur de la classe Van, ce qui permet de réutiliser la classe Speed dans plusieurs applications.
Dans la fonctionnalité orientée objet, les utilisateurs n'ont pas besoin de se soucier de l'objet qui 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 demandent à 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'effectuer l'action.
Types d'héritage
Il existe différents types d'héritage, comme illustré 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 −
Exemple
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é de l'héritage multiple.
Java