Comment implémenter l'abstraction de données en Java ?

L'abstraction, le polymorphisme, l'encapsulation et l'héritage sont les quatre éléments de base de la programmation orientée objet. L'un d'eux, Data Abstraction, sera discuté en détail dans l'article suivant. Nous apprendrons également comment effectuer une abstraction de données en Java.

Qu'est-ce que l'abstraction de données ?

L'abstraction des données est la caractéristique où seuls les détails les plus importants sont présentés à l'utilisateur. L'utilisateur est tenu dans l'ignorance des détails anodins ou non essentiels. Par exemple, une automobile est considérée comme un tout plutôt que comme ses parties distinctes. La pratique consistant à identifier uniquement les attributs nécessaires d'un élément tout en supprimant les informations superflues est connue sous le nom d'abstraction de données.

En termes simples, l'abstraction de données affiche les éléments importants pour l'utilisateur tout en cachant les éléments insignifiants.

Nous utilisons le mot-clé "abstract" pour implémenter l'abstraction à l'aide de classes et d'interfaces. Nous pouvons avoir à la fois des méthodes abstraites et concrètes dans des classes abstraites.

Que sont les classes abstraites ?

En programmation orientée objet, une classe abstraite est une classe qui déclare une ou plusieurs méthodes abstraites. La seule distinction entre les classes Java abstraites et régulières est que les classes abstraites contiennent le mot-clé abstract, contrairement aux classes Java régulières. Pour la déclaration d'une classe abstraite, nous utilisons le mot clé abstract devant son nom de classe. Il peut y avoir à la fois des méthodes abstraites et concrètes dans les classes. Cependant, les méthodes abstraites ne peuvent pas être présentes dans les classes régulières. Une classe avec au moins une méthode abstraite est appelée une classe abstraite.

Sa syntaxe est :

classe abstraite publique Name_of_Class

{

résumé public Name_of_Method();

}

Un exemple d'implémentation d'une classe abstraite est :

// nommage abstrait des classes

classe abstraite DemoClass

{

// nommage abstrait de la méthode

abstract void disp();

}

//continuer avec la classe abstraite

la classe publique MainClass étend DemoClass

{

//définition du corps de la méthode de la classe abstraite

annuler l'affichage()

{

System.out.println("Méthode abstraite appelée.");

}

public static void main(String[] args)

{

Obj MainClass = nouvelle MainClass ();

//invoquer la méthode abstraite

obj.display();

}

}

Pour lister point par point :

• Une classe doit être définie comme abstraite si elle a au moins une méthode abstraite.
• Une classe qui a été déclarée abstraite ne peut pas être instanciée.
• Vous devez hériter d'une classe abstraite d'une autre classe et fournir des implémentations pour que ses méthodes abstraites l'utilisent.
• Vous devez fournir des implémentations pour toutes les méthodes abstraites d'une classe abstraite si vous en héritez.

Que sont les méthodes abstraites ?

Une méthode abstraite n'a que la déclaration de méthode et aucune implémentation. Une méthode abstraite peut être représentée par une méthode sans corps propre. Les méthodes abstraites doivent être déclarées exclusivement dans des classes abstraites.

Si vous voulez qu'une classe ait une méthode mais que l'implémentation réelle de cette méthode soit déterminée par les classes enfants, désignez la méthode comme un abstrait dans la classe parent.

Avantages de l'abstraction de données dans la programmation orientée objet

• Dans la programmation orientée objet, l'abstraction réduit la complexité de la conception du programme et le processus de sa mise en œuvre sur le logiciel.
• Le principal avantage de la mise en œuvre de l'abstraction dans la programmation Java est que les utilisateurs peuvent alors facilement organiser des classes basées sur des similitudes, telles que des frères et sœurs, et par conséquent, l'héritage des données et la migration des données deviennent faciles et réalisables.
• L'héritage est possible. Par exemple:

/* Nom du fichier : DemoAbstract.java */

classe publique DemoAbstract {

public static void main(String [] args) {

/* les éléments suivants ne peuvent pas être écrits et génèrent des erreurs */

employé e = nouvel employé (« Peter D. », « Hartford, CT », 35) ;

System.out.println(“\n Utiliser la référence de l'employé et appeler MailCheck–“);

e.mailCheck();

}

}

Cela affiche l'erreur suivante :

Employee.java:46 : Employee est abstrait ; ne peut pas être instancié

employé e = nouvel employé (« Peter D. », « Hartford, CT », 35) ;

^

1 erreur

Nous utilisons donc l'utilisation de la classe abstraite comme :

/* Nom du fichier : employé.java */

employé de classe abstraite publique {

chaîne privée N ;

Ajouter une chaîne privée ;

Num int privé ;

public Employee(String N, String Add, int Num) {

System.out.println("Construire un employé");

this.name = N;

this.address=Ajouter ;

this.number = Num;

}

public double calculate_pay() {

System.out.println ("Inside employee compute_pay");

renvoie 0.0 ;

}

public void Mailcheck() {

System.out.println(“Envoi d'un chèque à ” + this.name + ” ” + this.address);

}

public String toString() {

retourner N + ” ” + Ajouter + ” ” + N ;

}

chaîne publique getName() {

retour N ;

}

chaîne publique getAddress() {

retour Ajouter ;

}

public void setAddress(String newAddress) {

Ajouter = nouvelleAdresse ;

}

public int getNumber() {

retourner Num ;

}

}

Quand utilise-t-on des classes abstraites ou des méthodes abstraites ?

Lorsque l'on considère l'exemple général des « formes », on peut imaginer qu'il soit utilisé en référence à un système de conception assistée par ordinateur ou à une simulation de jeu vidéo. Le type fondamental auquel il est fait référence ici est une "forme", chaque forme ayant ses propres attributs de couleur, sa taille, etc. Des classes spécifiques de formes - cercle, carré, triangle, etc., en sont dérivées (héritées), chacune d'entre elles peuvent avoir des propriétés et des comportements uniques supplémentaires. Certaines formes, par exemple, peuvent être symétriques, d'autres non. Les similitudes et les différences distinctes entre les formes sont incorporées dans la hiérarchie des types.

Par conséquent, la forme peut être analogue à une classe abstraite, tandis que les différents types de formes peuvent être désignés comme des classes concrètes.

Voici un scénario réel pour expliquer les classes abstraites :

// Programme Java pour démontrer l'abstraction

forme de classe abstraite {

Couleur de chaîne ;

zone double abstraite ();

public abstract String toString();

// la classe abstraite peut avoir le constructeur

forme publique (couleur de la chaîne)

{

System.out.println("Constructeur de forme appelé");

this.couleur = couleur;

}

// c'est une méthode concrète

public String getColour() { renvoie la couleur ; }

}

la classe Cercle étend la forme {

r double ;

cercle public(couleur de la chaîne, double(r)

{

// appel du constructeur Shape

super(couleur);

System.out.println("Constructeur de cercle appelé");

this.r = r;

}

@Remplacer la zone double()

{

return Math.PI * Math.pow(r, 2);

}

@Override public String toString()

{

return "La couleur du cercle est" + super.getColor()

+ "et l'aire est : " + aire();

}

}

class Rectangle étend la forme {

double longueur;

double largeur;

public Rectangle(Couleur de la chaîne, double longueur,

double largeur)

{

// appel du constructeur Shape

super(couleur);

System.out.println("Constructeur Rectangle appelé");

this.length = longueur ;

this.width = largeur;

}

@Override double area() { return length * width; }

@Override public String toString()

{

return "La couleur du rectangle est" + super.getcolor()

+ "et l'aire est : " + aire();

}

}

test de classe publique {

public static void main(String[] args)

{

Forme s1 = new Circle("Red", 2.2);

Forme s2 = new Rectangle("Jaune", 2, 4);

System.out.println(s1.toString());

System.out.println(s2.toString());

}

}

Ce segment de code est une version modifiée de celui ici .

Un extrait de code d'un programme où l'abstraction de données en Java est utilisée :

// Abstraction en Java

classe abstraite ElecBill

{

//méthode abstraite

flotteur abstrait compBill();

}

la classe Comm étend ElecBill

{

float compBill() {

retour 1.00*100 ;

}

}

la classe Domestique étend ElecBill

{

float compBill() {

retour 0.50*75 ;

}

}

Conclusion

L'abstraction de données est un aspect important de la programmation orientée objet. Pour des langages comme Java, l'abstraction et d'autres concepts POO tels que l'héritage, l'encapsulation et le polymorphisme jouent un rôle crucial dans l'écriture de programmes efficaces.

Si vous souhaitez apprendre la POO en profondeur et acquérir des compétences en programmation de premier ordre, nous vous recommandons de rejoindre la certification PG liée à l'emploi d'upGrad en génie logiciel, conçue pour aider les étudiants à acquérir des compétences en Java, OODAP, DSA, HTML5, CSS3. , JavaScript, MERN, AWS, bases de données SQL et NoSQL, Spring Boot, etc. Le cours de 5 mois couvre deux spécialisations - la spécialisation MERN Stack et la spécialisation Cloud-Native et donne accès à des sessions d'orientation professionnelle upGrad 360°.

Apprenez des cours de développement de logiciels en ligne dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.