Composition en Java

La composition est un type d'association utilisé pour représenter la relation « PART-OF » entre deux objets. La composition en Java est une forme restreinte d'un autre type d'association-agrégation où les deux entités dans une relation « Has-a » ont leur propre existence et ne dépendent pas l'une de l'autre. En composition, l'une des entités est contenue dans d'autres entités et ne peut exister seule. Contrairement à l'héritage qui est utilisé pour représenter une relation.

Par exemple, il existe deux classes Car et Engine, Car est composé d'un objet moteur, et l'entité moteur n'aurait pas existé sans Car.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe :

class C1{
// A class represents the dependent entity
}
class C2{
//This class represents the entity that contains the dependent entity by declaring the object of the above class as one of its member variables.
private C1 a;
}

En utilisant la syntaxe ci-dessus, nous sommes capables d'établir la relation « isPart-Of » entre les deux entités ci-dessus où C1 dépend de l'autre entité pour son existence. Aussi, on peut illustrer que l'existence d'un objet dépendant est facultative.

Pourquoi avons-nous besoin d'une composition en Java ?

En utilisant l'héritage pour la représentation de 2 entités, on voit que seule la relation IS-A peut exister. Mais dans le cas où deux entités contiennent une relation entre elles, alors une agrégation est requise. L'agrégation est de 2 types différents :

1. Association

Ceci est utilisé pour représenter la relation où 2 entités existent avec une relation HAS-A, mais l'une ne dépend pas des autres pour son existence. Il s’agit également d’un type d’association unidirectionnel. Par exemple, la banque et les employés sont deux entités où l'entité unique de la banque peut être liée à plus d'un employé ; ainsi, une banque a des relations un-à-plusieurs avec le salarié, mais l'inverse n'existe pas.

2. Composition

Il s'agit d'un type d'association restrictif utilisé lorsqu'une des 2 entités est composée au sein d'une autre entité conteneur. L'entité composée ne peut pas exister sans un objet conteneur. Mais on peut avoir une entité composée nulle. Ainsi, il est utilisé pour représenter la relation PART-OF qui est bidirectionnelle ; ainsi, les deux entités dépendent l'une de l'autre.

Comment fonctionne la composition en Java ?

Puisque la composition est utilisée pour implémenter le type de relation PART-OF entre deux entités, une entité est dite être un conteneur et l'autre est une entité composée.  L'entité composée est comme un objet conteneur complet, qui possède ses propres propriétés et opérations, ce qui en fait une entité distincte. Cela facilite également la réutilisation du code car cette classe peut être utilisée dans d'autres classes de conteneurs en tant qu'entité composée. Par exemple, Engine est une classe composée, et Car, TwooWheeler, etc., peuvent être une classe conteneur pour celle-ci.

Étant donné que la classe composée fait partie d'une entité conteneur, les deux ont des dépendances l'une par rapport à l'autre. Mais quand même, une classe composée peut être nulle, c'est-à-dire qu'une voiture n'a pas besoin d'avoir un moteur obligatoire. Avec cela, la classe Composed dépend entièrement de la classe conteneur pour son existence. De plus, puisque Composition est une association de types, la relation PART-OF est également considérée comme une sous-classe de la relation HAS-A. De cette façon, Composition permet de mettre en œuvre une relation entre deux entités dépendantes l'une de l'autre sans utiliser l'héritage.

Exemple d'implémentation de la composition en Java

Considérons le cas d'Office qui est composé des différentes listes telles que Bureau, Salles de réunion. L'objet bureau est en outre composé d'un objet téléphone, car chaque bureau possède un téléphone de bureau.

Téléphone.Java

Code :

package Try;
public class Phone {
private String Model;
private String contactNum;
Phone (String model, String num){
this.Model=model;
this.contactNum=num;
}
public void getPhoneDetails(){
System.out.println("Phone Model "+ this.Model);
System.out.println("Desk Number " + this.contactNum);
}
}

Bureau.Java

Code :

package Try;
public class Desk {
private String id;
private String Mid;
private Phone deskNum;
private String personName;
Desk(String id,String mid,Phone contact,String name){
this.id=id;
this.Mid = mid;
this.deskNum=contact;
this.personName=name;
}
public void getDeskDetails(){
System.out.println("Desk Details :-");
System.out.println("Id " + this.id);
System.out.println("Machine ID "+ this.Mid);
System.out.println("Allocated To " + this.personName);
this.deskNum.getPhoneDetails();
}
}

Salle de réunion.Java

Code :

package Try;
public class MeetingRoom {
private String name;
private Phone contact;
private String location;
private int numChairs;
private int numTables;
MeetingRoom(String name,Phone contact,String location,int nChairs, int nTables){
this.name=name;
this.contact=contact;
this.location=location;
this.numChairs=nChairs;
this.numTables=nTables;
}
public void getMeetingRoomDetails(){
System.out.println("Meeting Room Details :-");
System.out.println("Name " +this.name);
System.out.println("Location "+ this.location);
System.out.println("Number OF Chairs " + this.numChairs);
System.out.println("Number OF Tables "+this.numTables);
contact.getPhoneDetails();
}
}

Office.java

Code :

package Try;
import java.util.List;
public class Office {
private String offcName;
private List<Desk> deskList;
private List<MeetingRoom> roomList;
private int pantryNum;
public Office(String name , List<Desk> dList, List<MeetingRoom> mList,int pnum){
this.offcName = name;
this.deskList = dList;
this.roomList = mList;
this.pantryNum =pnum;
}
public void getDetails(){
System.out.println("Below are details of "+ offcName +"Office");
for(Desk a:deskList){
a.getDeskDetails();
}
for(MeetingRoom m:roomList){
m.getMeetingRoomDetails();
}
System.out.println("Number Of pantry " + pantryNum );
}
}

Démo.Java

Code :

package Try;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.ArrayList;
import java.util.List;
public class Demo extends Frame {
public static void main(String[] args){
List<Desk> dList =new ArrayList<Desk>();
List<MeetingRoom> mList =new ArrayList<MeetingRoom>();
Phone p1=new Phone("NOTOROLA","12346");
Phone p2=new Phone("NOTOROLA","35235");
Phone p3=new Phone("BSNL","23233");
Phone p4=new Phone("BSNL","123346");
Desk d1 =new Desk("S121","M12",p1,"Tom");
Desk d2 =new Desk("S122","M14",p2,"Pam");
dList.add(d1);
dList.add(d2);
MeetingRoom m1=new MeetingRoom("Kurukshetra",p3,"Floor_10",10, 2);
MeetingRoom m2=new MeetingRoom("Karnal",p4,"Floor_9",20, 3);
mList.add(m1);
mList.add(m2);
Office o1= new Office("Banglore" , dList,  mList,20);
o1.getDetails();
}
}

Sortie :

Explication : Dans le programme ci-dessus, l'objet Office est composé d'une liste d'entités Bureaux et Salle de réunion, où d'autres entités Bureau et Salle de réunion sont composées d'une entité Téléphone. Ici, le Téléphone est toujours lié à l'objet Bureau ou Salle de réunion, n'ayant donc aucune existence. De plus, les salles de réunion et les bureaux dépendent des objets Office. Ici, une classe de téléphone unique peut être utilisée comme une entité composée dans le bureau et la salle de réunion, contribuant ainsi à la réutilisabilité du code.

Conclusion

Il s'agit d'un type d'agrégation restrictif utilisé pour implémenter la relation PART-OF entre 2 entités qui ont une relation bidirectionnelle et dont l'entité composée n'existe pas sans l'entité conteneur. C'est bénéfique car les modifications apportées à la classe composée n'affectent pas le reste du code et la réutilisation du code.

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!