Exemple d’héritage en Java

L’héritage en Java est l’un des concepts de base de la programmation orientée objet. L’héritage en Java est utilisé lorsque nous avons une relation est-un entre les objets. L’héritage en Java est implémenté en utilisant le mot-clé extends.

L’héritage en Java

L’héritage en Java est la méthode permettant de créer une hiérarchie entre les classes en héritant d’autres classes.

L’héritage en Java est transitif – donc si Sedan étend Car et Car étend Vehicle, alors Sedan est également hérité de la classe Vehicle. Le Vehicle devient la superclasse à la fois de Car et de Sedan.

L’héritage est largement utilisé dans les applications Java, par exemple en étendant la classe Exception pour créer une classe Exception spécifique à l’application qui contient plus d’informations telles que des codes d’erreur. Par exemple, NullPointerException.

Exemple d’héritage Java

Chaque classe en Java étend implicitement la classe java.lang.Object. Ainsi, la classe Object est au sommet de la hiérarchie d’héritage en Java.

Voyons comment implémenter l’héritage en Java avec un exemple simple.

Superclasse : Animal

package com.journaldev.inheritance;

public class Animal {

	private boolean vegetarian;

	private String eats;

	private int noOfLegs;

	public Animal(){}

	public Animal(boolean veg, String food, int legs){
		this.vegetarian = veg;
		this.eats = food;
		this.noOfLegs = legs;
	}

	public boolean isVegetarian() {
		return vegetarian;
	}

	public void setVegetarian(boolean vegetarian) {
		this.vegetarian = vegetarian;
	}

	public String getEats() {
		return eats;
	}

	public void setEats(String eats) {
		this.eats = eats;
	}

	public int getNoOfLegs() {
		return noOfLegs;
	}

	public void setNoOfLegs(int noOfLegs) {
		this.noOfLegs = noOfLegs;
	}

}

La classe Animal est la classe de base ici. Créons une classe Cat qui hérite de la classe Animal.

Sous-classe: Chat

package com.journaldev.inheritance;

public class Cat extends Animal{

	private String color;

	public Cat(boolean veg, String food, int legs) {
		super(veg, food, legs);
		this.color="White";
	}

	public Cat(boolean veg, String food, int legs, String color){
		super(veg, food, legs);
		this.color=color;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

}

Remarquez que nous utilisons le mot-clé extends pour implémenter l’héritage en Java.

Programme de test d’héritage en Java

Écrivons une classe de test simple pour créer un objet Cat et utiliser certaines de ses méthodes.

package com.journaldev.inheritance;

public class AnimalInheritanceTest {

	public static void main(String[] args) {
		Cat cat = new Cat(false, "milk", 4, "black");

		System.out.println("Cat is Vegetarian?" + cat.isVegetarian());
		System.out.println("Cat eats " + cat.getEats());
		System.out.println("Cat has " + cat.getNoOfLegs() + " legs.");
		System.out.println("Cat color is " + cat.getColor());
	}

}

Sortie :

La classe Cat n’a pas de méthode getEats(), mais le programme fonctionne toujours car elle est héritée de la classe Animal.

Points importants

1. La réutilisation du code est le principal avantage de l’héritage car les sous-classes héritent des variables et méthodes de la superclasse.

2. Les membres privés de la superclasse ne sont pas directement accessibles à la sous-classe. Comme dans cet exemple, la variable Animal noOfLegs n’est pas accessible à la classe Cat, mais elle peut être indirectement accessible via les méthodes getter et setter.

3. Les membres de la superclasse avec un accès par défaut sont accessibles à la sous-classe UNIQUEMENT s’ils se trouvent dans le même package.

4. Les constructeurs de la superclasse ne sont pas hérités par la sous-classe.

5. Si la superclasse n’a pas de constructeur par défaut, alors la sous-classe doit également avoir un constructeur explicite défini. Sinon, cela générera une exception de temps de compilation. Dans le constructeur de la sous-classe, l’appel au constructeur de la superclasse est obligatoire dans ce cas et il doit être la première instruction dans le constructeur de la sous-classe.

6. Java ne prend pas en charge l’héritage multiple, une sous-classe peut étendre uniquement une classe. La classe Animal étend implicitement la classe Object et la classe Cat étend la classe Animal, mais en raison de la nature transitive de l’héritage en Java, la classe Cat étend également la classe Object.

7. Nous pouvons créer une instance de sous-classe et ensuite l’assigner à une variable de superclasse, ceci est appelé upcasting. Voici un exemple simple d’upcasting :

   Cat c = new Cat(); // instance de sous-classe
   Animal a = c; // upcasting, c'est acceptable car Cat est aussi un Animal
   

8. Lorsqu’une instance de Superclasse est assignée à une variable de Sous-classe, on parle de downcasting. Nous devons le convertir explicitement en Sous-classe. Par exemple;

   Chat c = new Chat();
   Animal a = c;
   Chat c1 = (Chat) a; //casting explicite, fonctionne bien car "c" est en réalité de type Chat
   

   Remarquez que le compilateur ne se plaindra même pas si nous faisons une erreur, en raison du casting explicite. Voici quelques cas où il générera une ClassCastException à l’exécution.

   Chien d = new Chien();
   Animal a = d;
   Chat c1 = (Chat) a; //ClassCastException à l'exécution
   
   Animal a1 = new Animal();
   Chat c2 = (Chat) a1; //ClassCastException car a1 est en réalité de type Animal à l'exécution
   

9. Nous pouvons substituer la méthode de la Superclasse dans la Sous-classe. Cependant, nous devrions toujours annoter la méthode substituée avec @Override. Le compilateur saura que nous substituons une méthode et si quelque chose change dans la méthode de la superclasse, nous obtiendrons une erreur de compilation plutôt que des résultats indésirables à l’exécution.

10. Nous pouvons appeler les méthodes de la superclasse et accéder aux variables de la superclasse en utilisant le mot-clé super. Cela est pratique lorsque nous avons une variable/méthode du même nom dans la sous-classe mais que nous voulons accéder à la variable/méthode de la superclasse. Cela est également utilisé lorsque des constructeurs sont définis dans la superclasse et la sous-classe, et que nous devons appeler explicitement le constructeur de la superclasse.

11. Nous pouvons utiliser l’instruction instanceof pour vérifier l’héritage entre les objets, voyons cela avec l’exemple ci-dessous.

```
Cat c = new Cat();
Dog d = new Dog();
Animal an = c;

boolean flag = c instanceof Cat; //normal case, returns true

flag = c instanceof Animal; // returns true since c is-an Animal too

flag = an instanceof Cat; //returns true because a is of type Cat at runtime

flag = an instanceof Dog; //returns false for obvious reasons.
```

12. Nous ne pouvons pas étendre les classes finales en java.
13. Si vous n’utilisez pas la Superclasse dans le code, c’est-à-dire si votre Superclasse est simplement une base pour conserver du code réutilisable, vous pouvez les garder comme une classe abstraite pour éviter une instanciation inutile par les classes clientes. Cela limitera également la création d’instances de la classe de base.

Tutoriel Vidéo sur l’Héritage en Java

I have recently published two videos on YouTube explaining Inheritance in detail with sample programs, you should watch them below.

Vous pouvez consulter plus d’exemples d’héritage sur notre Dépôt GitHub.

Référence : Documentation Oracle