Héritage unique en Java

L'héritage unique peut être défini comme une classe dérivée pour hériter des méthodes de base (données membres et variables) et du comportement d'une superclasse. C’est un concept de base de relation qui existe ici. Java n'utilise qu'un seul héritage comme sous-classe et ne peut pas étendre plusieurs superclasses.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

L'héritage correspond aux propriétés de base de la programmation orientée objet. L'héritage a tendance à utiliser les propriétés d'un objet de classe dans un autre objet. Java utilise l'héritage pour la réutilisabilité du code afin de réduire le temps en améliorant la fiabilité et en réalisant le polymorphisme d'exécution. Comme les codes sont réutilisés, cela réduit les coûts de développement et de maintenance. Java propose différents types d'héritage, à savoir l'héritage unique, multiniveau, multiple et hybride. Cet article présentera brièvement une compréhension de base du concept d'héritage unique en Java avec un exemple de programmation. Ici, nous aurons une implémentation complète en java.

Syntaxe :

La syntaxe générale pour cela est donnée ci-dessous. Les concepts d'héritage utilisent le mot-clé « extend » pour hériter d'une classe spécifique. Ici, vous apprendrez comment utiliser des mots-clés d'extension pour dériver une classe. Après le nom de la classe, nous déclarons un mot-clé étendu suivi d'un autre nom de classe.

Code :

class base class
{…. methods
}
class derived class name extends base class
{
methods … along with this additional feature
}

Java utilise le mot-clé « extends » pour créer une nouvelle classe dérivée de la classe existante. Nous appelons la classe héritée une classe de base ou une superclasse, et nous appelons la classe nouvellement créée une classe dérivée ou une sous-classe. La classe de base fournit des données membres et des méthodes, tandis que la classe enfant hérite de ces méthodes.

Comment fonctionne l'héritage unique en Java ?

L'héritage unique spécifie les relations de classe enfant-parent lorsqu'elles s'étendent et le type le plus simple de toutes les méthodes, comme la poire et la pomme héritant des fruits. Dans les mécanismes d'héritage, les objets sont traités de manière descendante. Auparavant, nous avons appris la syntaxe et sa déclaration. Il est nécessaire de lire la notion de spécificateurs d'accès, à savoir privé, public et protégé. La classe ne peut accéder à toutes les données membres qu’une fois déclarée privée. Le public est accessible dans n’importe quelle classe. La protection se fait avec le même package ; cela aussi est applicable uniquement par héritage.

Code :

class fruits
{private int f;
int g;
private void mmm ()
{
System.out.println(“….”);
}
}
class M extends fruits
{void method ();
………
}}
class Main
{
public static void main (String [] args)
{
M ob= new M ();
Ob.f=3;   // here the variable cannot be accessed
Ob.mmm();
}

Explication du code ci-dessus : Dans l'exemple de code ci-dessus, l'instruction ob.=3, la classe enfant ne peut pas accéder aux membres privés d'une classe de base, ce qui rend impossible leur assignation. Par conséquent, il génère une erreur qui ne parvient pas à trouver un symbole (erreur de compilation). Pour travailler avec, il est nécessaire de rendre publiques les données membres de la classe parent.

Utiliser Protégé

Dans l'exemple ci-dessous, nous avons déclaré protégé dans la superclasse, à laquelle la sous-classe peut accéder directement.

Code :

class pgm
{
protected int I,k;
method ( int m,int n)
{
…
}
class  R extends pgm
{ private  int f;
// methods
}
public class protected Main
{
public static void main()
{
// methods and objects access
}

L'organigramme de l'héritage unique est donné ci-dessous :

La classe Y hérite de la classe X, n'étendant qu'une seule classe.

Exemples d'implémentation de l'héritage unique en Java

Cette section verra l'implémentation de l'héritage unique où la classe enfant fait référence aux propriétés et comportements des parents à l'aide de mots-clés étendus.

Remarque : J'ai utilisé Main comme nom de classe dans tous ces exemples. Vous devez enregistrer le nom du fichier sous Main.java lors de l'exécution.

Exemple n°1

Calcul du salaire d'un employé en utilisant l'héritage unique avec la classe d'objet.

Code :

class Employee
{
float sal=60000;
}
class Main extends Employee
{
float b=1500;
float temp= sal + b;
public static void main(String args[])
{
Main ob=new Main();
System.out.println("Salary amount is:"+ob.sal);
System.out.println(" Extra Bonous is:"+ob.temp);
}
}

Sortie :

Exemple n°2

Implémentation d'une calculatrice utilisant les méthodes de somme, de soustraction et de multiplication par division.

Code :

class Calc{
int sum(int i , int j)
{
return i+j;
}
int subract(int i , int j)
{
return i-j;
}
}
public class Main extends Calc {
int mul(int xx , int yy)
{
return xx*yy;
}
int divide(int xx , int yy)
{
return xx/yy;
}
public static void main(String args[]) {
Main c= new Main();
System.out.println(c.sum(2,2));
System.out.println(c.subract(2,6));
System.out.println(c.mul(8,9));
System.out.println(c.divide(2,2));
}
}

Sortie :

Exemple #3

Calcul de la zone du rectangle et du triangle à l'aide de l'héritage unique.

Code :

class Rectdemo
{
int le,be;
void Sval(int a,int b)
{
le=a;
be=b;
}
int GetR()
{
return le*be;
}
}
class Tri extends Rectdemo
{
int b,h;
float t;
void Sdata(int q,int r)
{
b=r;
h=q;
}
float GetT()
{
t=(float)le/2*b*h;
return (t);
}
}
class Main
{
public static void main(String args[])
{
Tri Tr=new Tri();
Tr.Sval(40,8);
Tr.Sdata(10,6);
System.out.println("Area of Rectangle is calculated as :" +Tr.GetR());
System.out.println("Area of Triangle is calculated As :"+Tr.GetT());
}
}

Sortie :

Exemple n°4

Utilisation d'un super mot-clé dans un héritage unique. Le Super Keyword fait référence à la classe parent d'un objet et agit en tant que constructeur.

Code :

class Library
{
String lname;
public Library(String m)
{
lname = m;
}
}
public class Main extends Library {
String lname;
public Main(String x1, String x2)
{
super(x1);       //passing argument to parent class constructor
this.lname = x2;
}
public void display()
{
System.out.println(super.lname+" and "+lname);
}
public static void main(String[] args)
{
Main c = new Main("library name","library id");
c.display();
}
}

Sortie :

Exemple #5

Méthode Over Ridden appelée par la sous-classe en utilisant l'héritage.

Code :

class even {
void display()
{
System.out.println(" Even Nos,4 2");
}
}
class odd extends even {
void display()
{
super.display();
System.out.println(" Odd Nos ,1 3");
}
}
class Main {
public static void main(String[] args)
{
even e = new odd();
e.display();
}
}

Sortie :

Conclusion

Ainsi, pour arriver à la fin, cet article explique divers concepts d'héritage et comment travailler avec l'héritage unique disponible en Java. Vous apprendrez également à connaître l’implémentation fonctionnelle à l’aide du mot-clé extend. J'espère que cet article est très informatif et ajoute des connaissances aux débutants.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!