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 un logiciel fiable, de nouvelles classes peuvent désormais s'inspirer de classes apparentées préexistantes et, si nécessaire, étendre les états et 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

Classe publique Fruit {
// Déclaration de variable
Protégé String seed;
protected String skinColor;
goût de ficelle protégé;
// Constructeur par défaut
public Fruit () {
graine = "";
skinColor = "";
goût = "";
}
// Constructeur principal
public Fruit (String seed, String skinColor, String goût) {
this.seed = graine;
this.skinColor = skinColor;
this.taste = goût;
}
// getters et setters
public String getSeed () {
retourner la graine;
}
public void setSeed (String seed) {
this.seed = graine;
}
public String getSkinColor () {
return skinColor;
}
public void setSkinColor (String skinColor) {
this.skinColor = skinColor;
}
public String getTaste () {
rendre le goût;
}
public void setTaste (goût de la chaîne) {
this.taste = goût;
}
// méthode eat
public void eat () {
// code général sur la façon de manger un fruit
}
// méthode du jus
public void juice () {
// code général sur la façon de presser un 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écouvrez 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

classe publique Orange étend le fruit {
// déclaration de variable
suprêmes int privés;
// constructeur par défaut
public Orange () {
suprêmes = 0;
}
// constructeur principal
public Orange (String seed, String skinColor, String goût, int supremes) {
super (graine, couleur de la peau, goût);
this.supremes = supremes;
}
// getters et setters
public int getsupremes () {
renvoyer les suprêmes;
}
public void setsupremes (int supremes) {
this.supremes = supremes;
}
// méthode eat
public void eat () {
// comment manger une orange
}
// méthode du jus
public void juice () {
// comment jus et orange
}
// méthode peel
public void peel () {
// comment peler une 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 classes parents 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 pas le constructeur par défaut - de la classe fruit parent doit être appelée 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. En outre, vous savez désormais 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

Comment organiser votre code orienté objet avec l'héritage

Obtenir une programmation orientée objet correctement signifie que vous devez connaître l'héritage et comment il peut simplifier le codage et réduire les erreurs.

Lire la suite

A propos de l'auteur