Exploration de l’héritage dans le langage de programmation Java

L'héritage est l'un des concepts fondamentaux de la programmation orientée objet. En programmation, le mot héritage représente une relation dans laquelle une classe enfant assume l'état et le comportement d'une classe parent.

Le but de l'héritage dans le développement de logiciels est de faciliter la réutilisation de logiciels sûrs et fiables. L'un des principaux avantages de l'utilisation de l'héritage est qu'il élimine le code redondant dans vos programmes.

Comment fonctionne l'héritage

L'idée derrière l'héritage est que de nombreuses classes ou objets ont une partie du même ensemble d'attributs et de méthodes. Par conséquent, dans l'esprit de produire des logiciels fiables, de nouvelles classes peuvent désormais s'inspirer de classes apparentées préexistantes et, si nécessaire, s'étendre sur des états et des comportements existants.

Un exemple concret du fonctionnement de l'héritage serait de considérer les fruits. Il s'agit d'une large étiquette qui sert à encapsuler une gamme d'éléments différents.

Une pomme est un fruit, tout comme une orange. Cependant, une orange n'est pas une pomme, vous n'auriez donc pas de fruits en stock si vous possédiez un magasin. Peut-être que vous pourriez avoir une section de fruits dans votre inventaire, et sous cette section, vous auriez des articles plus spécifiques comme les pommes et les oranges.

C'est ainsi que fonctionne l'héritage.

Utilisation de l'héritage en Java

L'héritage peut être utilisé dans n'importe quel langage de programmation qui utilise le paradigme de programmation orientée objet . Cependant, la manière exacte dont l'héritage est utilisé dépend du langage de programmation spécifique.

Par exemple, C ++ est également un langage de programmation orienté objet . C ++ prend en charge ce que l'on appelle l'héritage multiple, tandis que Java ne prend en charge que l'héritage unique.

Cela signifie qu'en Java, une classe parente peut avoir de nombreuses classes enfants, mais chaque classe enfant ne peut avoir qu'une seule classe parente (héritage unique). Cependant, il existe un moyen d'obtenir un héritage multiple indirect en Java, en créant une relation grand-parent, parent et enfant.

Création de la classe parent en Java

Le processus de sélection d'une classe parente à partir d'un document d'exigences logicielles est appelé analyse orientée objet. Au cours de ce processus, l'expression «est un» est souvent utilisée pour identifier les relations d'héritage possibles. En vous inspirant de notre exemple ci-dessus, vous devriez être en mesure de voir que le fruit serait notre classe parente.

Exemple de classe de parents de fruits

 
public class Fruit {
 //Variable Declaration
 protected String seed;
 protected String skinColor;
 protected String taste;
 //Default Constructor
 public Fruit(){
 seed = "";
 skinColor ="";
 taste ="";
 }
 //Primary Constructor
 public Fruit(String seed, String skinColor, String taste){
 this.seed = seed;
 this.skinColor = skinColor;
 this.taste = taste;
 }
 //getters and setters
 public String getSeed() {
 return seed;
 }
 public void setSeed(String seed) {
 this.seed = seed;
 }
 public String getSkinColor() {
 return skinColor;
 }
 public void setSkinColor(String skinColor) {
 this.skinColor = skinColor;
 }
 public String getTaste() {
 return taste;
 }
 public void setTaste(String taste) {
 this.taste = taste;
 }
 //eat method
 public void eat(){
 //general code on how to eat a fruit
 }
 //juice method
 public void juice() {
 //general code on how to juice a fruit
 }
 }

L'un des aspects les plus notables de la classe parente ci-dessus est le modificateur d'accès utilisé avec chaque déclaration de variable. Le modificateur d'accès «protégé» est idéal pour une utilisation dans les classes parentes car il empêche les classes non enfants d'accéder aux attributs de données de la classe parente.

Plus bas dans le code, vous découvrirez les constructeurs, les getters et les setters qui sont des blocs de construction généraux pour toute classe Java. Enfin, vous découvrirez deux méthodes (jus et manger) qui sont créées dans la classe parent de notre programme car elles sont universelles pour tous les fruits – tous les fruits peuvent être mangés et pressés.

Création de classes enfants en Java

Les classes enfants sont généralement appelées classes spécialisées ou dérivées car elles héritent de l'état et du comportement d'un parent et personnalisent souvent ces attributs pour être plus spécifiques.

En continuant avec notre exemple, vous devriez être en mesure de voir pourquoi l'orange serait une classe enfant appropriée de la classe de fruits ci-dessus.

Exemple de classe enfant orange

 
public class Orange extends Fruit{
 //variable declaration
 private int supremes;
 //default constructor
 public Orange() {
 supremes = 0;
 }
 //primary constructor
 public Orange(String seed, String skinColor, String taste, int supremes){
 super(seed, skinColor, taste);
 this.supremes = supremes;
 }
 //getters and setters
 public int getsupremes() {
 return supremes;
 }
 public void setsupremes(int supremes) {
 this.supremes = supremes;
 }
 //eat method
 public void eat(){
 //how to eat an orange
 }
 //juice method
 public void juice() {
 //how to juice and orange
 }
 //peel method
 public void peel(){
 //how to peel an orange
 }
 }

Il y a une différence entre ce à quoi ressemble une déclaration de classe Java standard et ce que nous avons dans notre code ci-dessus. Le mot-clé «extend» est ce qui est utilisé en Java pour rendre l'héritage possible.

Dans notre exemple ci-dessus, la classe enfant (orange) étend la classe parent (fruit). Par conséquent, l'état et le comportement de la classe fruit sont désormais accessibles et modifiés par la classe orange.

L'attribut unique de notre classe orange est identifié avec le nom de variable supremes (qui est le nom officiel des petits segments trouvés dans les oranges). C'est là que la spécialisation entre en jeu; tous les fruits n'ont pas de suprêmes, mais toutes les oranges en ont, il est donc logique de réserver la variable suprême pour la classe orange.

L'ajout de la méthode «peler» aux méthodes préexistantes «manger» et «jus» est également logique car bien que tous les fruits ne puissent pas être pelés, les oranges sont souvent pelées.

Vous devez garder à l'esprit que si nous n'avions pas l'intention de modifier les méthodes existantes «manger» et «jus», nous n'aurions pas besoin de les inclure dans notre classe orange. Les méthodes de la classe orange remplacent toute méthode similaire de la classe fruit. Donc, si tous les fruits étaient consommés et pressés de la même manière, nous n'aurions pas besoin de créer ces méthodes dans la classe orange.

Les constructeurs de rôle jouent dans l'héritage

Par défaut, les constructeurs de classe parent sont hérités par les classes enfants. Par conséquent, si un objet de classe enfant est créé, cela signifie qu'un objet de classe parent est également créé automatiquement.

Pour revenir à notre exemple, chaque fois qu'un nouvel objet orange est créé, un objet fruit est également créé car une orange est un fruit.

Dans les coulisses, lorsqu'un objet de classe enfant est créé, le constructeur de la classe parent est appelé en premier, suivi du constructeur de la classe enfant. Dans notre classe enfant orange ci-dessus, si un objet orange est créé sans aucun paramètre, notre constructeur de classe fruit par défaut sera appelé, suivi de notre entrepreneur de classe orange par défaut.

La méthode «super» dans notre constructeur principal ci-dessus est nécessaire car elle spécifie que le constructeur principal – et non le constructeur par défaut – de la classe fruit parent doit être appelé chaque fois qu'un objet orange avec des paramètres est créé.

Vous pouvez désormais utiliser l'héritage en Java

À partir de cet article, vous avez pu découvrir ce qu'est l'héritage, comment il fonctionne et pourquoi il s'agit d'un concept si important en programmation. Vous pouvez maintenant créer vos relations d'héritage à l'aide du langage de programmation Java. De plus, vous savez maintenant comment contourner la règle d'héritage unique de Java en créant une relation grand-parent.

Crédit d'image: Andreas Wohlfahrt / Pexels