Association, agrégation et composition en Java
Cet article se concentre sur trois des concepts OOP les plus importants en Java, à savoir l'association, la composition et l'agrégation . Bien qu'il s'agisse de concepts liés, il existe certaines différences dans la manière dont ils sont utilisés pour connecter deux classes. L'association est la relation entre deux classes qui sont basées sur leurs objets. L'agrégation et la composition sont deux types d'association.
Association en Java
Association en Java est la relation établie entre deux classes rendue possible par leurs objets. Cette relation peut être un à un, un à plusieurs, plusieurs à un et plusieurs à plusieurs.
Par exemple, une organisation et un employé sont deux entités différentes, mais la relation entre l'organisation et l'employé est une à beaucoup parce qu'une organisation peut avoir beaucoup d'employés. Cette relation entre les deux entités est appelée association.
Exemple d'association en Java
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
Organ organization = new Organ();
organization.setOrganizationName("Michel Page");
Empl empl1 = new Empl();
empl1.setEmployeeName("Manoj");
Empl empl2 = new Empl();
empl2.setEmployeeName("Raghav");
List<Empl> empList = new ArrayList();
empList.add(empl1);
empList.add(empl2);
organization.setEmployees(empList);
System.out.println(organization.getEmployees()+" are Employees of "+
organization.getOrganizationName());
}
}
class Organ {
private String organizationName;
List<Empl> empl1;
public String getOrganizationName() {
return organizationName;
}
public void setOrganizationName(String organizationName) {
this.organizationName = organizationName;
}
public List<Empl> getEmployees() {
return empl1;
}
public void setEmployees(List<Empl> empl1) {
this.empl1 = empl1;
}
}
class Empl {
private String employeeName;
public String getEmployeeName() {
return employeeName;
}
public void setEmployeeName(String employeeName) {
this.employeeName = employeeName;
}
@Override
public String toString() {
return employeeName;
}
} Sortie
[Manoj, Raghav] are Employees of Michel Page Pourquoi utiliser Association en Java ?
L'association est utilisée pour établir une relation entre des objets de deux classes distinctes qui peuvent être deux entités entièrement différentes. Cette relation indique qu'une classe particulière connaît une autre classe et contient une référence à cette classe.
Quand utiliser Association en Java ?
L'association est appliquée lorsque deux classes doivent interagir l'une avec l'autre via leurs objets pour obtenir un certain résultat. Il établit un moyen de connecter un ou plusieurs objets avec les objets d'autres classes.
Ces connexions multidirectionnelles sont réalisées avec succès à travers deux des formes de l'Association :
- Composition
- Agrégation.
Agrégation en Java
C'est une forme spéciale d'association qui est utilisée pour développer une relation à sens unique entre deux classes. Elle est également appelée association unidirectionnelle et est utilisée pour représenter une relation HAS-A .
Exemple d'agrégation en Java
// Example code of Aggregation:
public class Main {
public static void main(String[] args) {
Add add = new Add();
add.sethouseno("110");
add.setsociety("Gokuldham");
add.setCity("Chandighar");
Emp emp = new Emp();
emp.setId(475);
emp.takeName("Rhagvendra");
emp.setAdd(add);
System.out.println("Employee Details :: " + emp);
}
}
class Emp {
private int id;
private String name;
// define employee's address
private Add add;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String takeName() {
return name;
}
public void takeName(String name) {
this.name = name;
}
public Add getAdd() {
return add;
}
public void setAdd(Add add) {
this.add = add;
}
@Override
public String toString() {
return "Employee{" + "id=" + id + ", Name=" + name + ", Address=" + add + '}';
}
}
class Add {
private String houseno;
private String society;
private String city;
public String gethouseno() {
return houseno;
}
public void sethouseno(String houseno) {
this.houseno = houseno;
}
public String getsociety() {
return society;
}
public void setsociety(String society) {
this.society = society;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
@Override
public String toString() {
return "Address{" + "doorNo=" + houseno + ", society=" + society + ", city=" + city + '}';
}
} Sortie
Employee Details :: Employee{id=475, Name=Rhagvendra, Address=Address{doorNo=110, society=Gokuldham, city=Chandighar}} Exemple 2) L'agrégation peut également être utilisée pour la réutilisation du code.
// show simple aggregation example HAS A relation between car and engine.
class engine{
public void show(){
System.out.println("The Engine is a main part of the car .");
}
}
public class Main {
public static void main(String args[]){
//Engine class object in Car class
engine obj = new engine();
obj.show();
}
} Sortie
The Engine is a main part of the car. Pourquoi utiliser l'agrégation en Java ?
Nous utilisons l'agrégation lorsque nous voulons réutiliser le code dans notre programme. Par exemple, l'objet A1 a une référence à un autre objet appelé objet A2. Ils ont une relation HAS-A entre eux. Comme l'Objet A1 fait référence à l'Objet A2, les fonctionnalités de l'Objet A2 peuvent être utilisées par l'Objet A1. De même, toute classe ayant une référence à l'objet A2 peut utiliser ses méthodes.
Quand utiliser l'agrégation en Java ?
L'agrégation est principalement utilisée pour connecter deux classes où la classe agrégée a une référence à une autre classe. Cette classe est propriétaire de l'autre classe. Lorsque nous voulons éviter d'avoir des références cycliques entre les relations des deux classes, nous utilisons cette forme d'association.
Composer en Java
Une composition est une forme restreinte d'agrégation où les deux objets sont fortement dépendants l'un de l'autre. Lorsqu'une composition existe entre deux objets, l'objet composé ne peut pas exister indépendamment.
Exemple de composition en Java
Dans cet exemple, nous définirons une classe Date to afin de conserver toutes les informations sur la date puis nous définirons une classe Employee qui contiendra non seulement les membres id, name et display() mais contiendra également une variable de référence embaucheDate pour faire référence aux informations d'adhésion sur les objets de la classe Date en tant que membre, qui conserve les détails d'embauche de l'employé.
Au fur et à mesure de l'exécution, la fonction emp.display () affichera l'identifiant, le nom et la hireDate de l'employé . La date de location est obtenue en tant qu'appel implicite à la méthode toString() de la classe Date .
// Example code of Composition
class date
{
private int dy;
private int mnth;
private int yr;
date(int dd, int mm,int yy)
{
System.out.println("Constructor is Called from date Class");
dy=dd;
mnth=mm;
yr=yy;
}
public String toString()
{
return (dy+"/"+mnth+"/"+yr);
}
}
class Employee
{
private int id;
private String name;
private date hiredate; //object of Data class
Employee(int num,String n, date hire)
{
System.out.println(" Constructor is Called of Employee class");
id=num ;
name=n ;
hiredate=hire;
}
public void display()
{
System.out.println("id = "+id);
System.out.println("Name = "+name);
System.out.println("Hiredate = "+hiredate);
}
}
public class Main
{
public static void main(String[] args)
{
date d = new date(31,03,2019);
Employee emp = new Employee(10,"Rahul Tanwar",d);
emp.display();
}
}
Sortie
Constructor is Called from date Class
Constructor is Called of Employee class
id = 10
Name = Rahul Tanwar
Hiredate = 31/3/2019 Exemple 2)
package com.tutorial.javabasic;
class Twowheelar {
public String getDetails() {
return "This is two wheelers details can be bike or scooter";
}
}
class bike extends Twowheelar {
}
public class Main {
public static void main(String[] s) {
bike c = new bike();
String details = c.getDetails();
System.out.println(details);
}
} Sortie :
This is two wheelers details can be bike or scooter Pourquoi utiliser la composition en Java ?
La composition est utilisée lorsque nous voulons établir une PART-OF relation entre deux objets et l'un doit être dépendant de l'autre.
Quand utiliser la composition en Java ?
La composition en Java est utilisée pour rendre le code réutilisable mais le code est préservé et l'encapsulation n'est pas gênée. De plus, la composition permet également de mieux tester les classes, comme les tests unitaires. Dans le développement piloté par les tests, la composition est souvent préférée à l'héritage en raison de sa facilité d'utilisation.
Composition vs agrégation
| Composition |
| Ici, les deux objets sont fortement dépendants l'un de l'autre. La classe enfant ne peut pas fonctionner sans la classe parent. |
| C'est une forme d'association forte. |
| Il a un PART-OF relation entre deux objets. |
Résumé
Tous les concepts évoqués ci-dessus sont utilisés en Java en fonction de leur type de relation à établir entre deux classes. Cependant, toutes les fonctionnalités aident à réutiliser le code écrit une fois et à réduire la complexité globale.
