Composition et agrégation en Java

Java fournit les différentes relations entre les objets qui peuvent être considérés comme réels et la programmation. Parfois, c’est très difficile à comprendre, ou on peut dire cela à mettre en œuvre les relations. Java fournit donc la composition et la relation d'agrégation à l'utilisateur. En composition, nous pouvons construire une relation que nous appelons « appartient à » ; logiquement, on peut dire qu’un objet est plus grand que les autres objets. En agrégation, nous pouvons construire une relation que nous appelons une relation « a un », dans laquelle chaque objet agit indépendamment les uns des autres. Relation d'agrégation que nous considérons comme une association faible et composition que nous considérons comme une association forte.

Commencez votre cours de développement de logiciels libres

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

Syntaxe de composition et d'agrégation

Syntaxe de composition comme suit :

public class building {
private final Room room;
public building () {
room = new room ();
}
}
class Room { }

Explication :

• Dans la syntaxe ci-dessus, nous considérons un exemple de bâtiment, donc d'abord, nous créons la classe avec le nom building, et la pièce est la partie obligatoire du bâtiment comme indiqué dans la syntaxe ci-dessus.
• C'est la syntaxe de la relation de composition, et nous montrons ici qu'elle appartient à la relation.

Syntaxe d'agrégation comme suit :

public class student {
private List students;
public student () {
students = new list_students();
}
}
class student { }

Explication :

• Dans la syntaxe ci-dessus, nous considérons l'exemple d'étudiant, dans lequel nous créons d'abord une classe publique avec le nom d'étudiant, puis nous créons la liste des étudiants car les étudiants peuvent avoir 0 ou plus, comme indiqué dans le syntaxe ci-dessus.
• Ici, nous montrons également la relation « a une » entre les objets.

Comment fonctionnent la composition et l'agrégation en Java ?

Ce qui suit montre comment fonctionnent la composition et l'agrégation en Java :

La composition est utilisée pour préciser « appartient à » d'une relation. Cela implique que l’un des éléments est intelligemment plus grand que les autres éléments, ou nous pouvons dire un objet. Par exemple, considérons une pièce comme faisant partie d’un bâtiment, ou nous pouvons dire qu’un bâtiment a une pièce. Donc, fondamentalement, que nous l'appelions « appartient à » ou « a un », c'est juste une question de perspective.

Au fond, la composition est une relation forte compte tenu du fait que l'objet qui la contient la revendique. De cette manière, lorsque nous supprimons le cycle de vie de l'objet, cela signifie que lorsque nous supprimons le nœud parent, il supprime automatiquement les nœuds enfants. Par exemple, nous pouvons considérer quand nous détruisons des pièces ; alors le bâtiment est également détruit. Notez que cela ne signifie pas que l’objet conteneur ne peut exister avec aucune de ses parties. Par exemple, nous pouvons détruire toutes les cloisons à l’intérieur d’une structure, oblitérant ainsi les pièces. Quoi qu’il en soit, la structure existera de toute façon. En ce qui concerne la cardinalité, un article contenant peut avoir autant de parties que nécessaire. Néanmoins, l’ensemble des pièces doit avoir précisément un seul compartiment.

Fonctionnement du fonctionnement de l'agrégation en Java comme suit :

On sait que la composition « a une » relation. De même, l'agrégation a également une relation « A ». La différence fondamentale est que l'agrégation inclut le nœud ou l'objet parent. Dans cette relation, chaque objet est indépendant les uns des autres. Par exemple, nous pouvons considérer une voiture et ses différentes roues, la même roue que nous pouvons installer dans une autre voiture alors c'est un fichier de travail sans aucun problème. Nous savons qu'une voiture sans roues n'est pas utile, c'est pourquoi nous assemblons toutes les parties de l'objet, ce qui constitue la relation d'agrégation.

Exemples de composition et d'agrégation en Java

Vous trouverez ci-dessous les exemples de composition et de relation d'agrégation :

Exemple n°1 : Composition

Code :

import java.io.*;
import java.util.*;
class Lib
{
public String name_book;
public String bk_author;
Lib(String name_book, String bk_author)
{
this.name_book = name_book;
this.bk_author = bk_author;
}
}
class Library
{
private final List<Lib> Lib_books;
Library (List<Lib> Lib_books)
{
this.Lib_books =Lib_books;
}
public List<Lib> book_details(){
return Lib_books;
}
}
class composition
{
public static void main (String[] args)
{
Lib book1 = new Lib("Database management", "Rajiv Chopra ");
Lib book2 = new Lib("MySql", "Rajiv Chopra l");
Lib book3 = new Lib("oracle", "Donald Burleson");
List<Lib> Lib_books = new ArrayList<Lib>();
Lib_books.add(book1);
Lib_books.add(book2);
Lib_books.add(book3);
Library library = new Library(Lib_books);
List<Lib> bks = library.book_details();
for(Lib bk : bks){
System.out.println("name_book : " + bk.name_book + " and "
+" bk_author : " + bk.bk_author);
}
}
}

Explication :

• Dans l'exemple ci-dessus, nous essayons d'implémenter des relations de composition en Java.
• Le résultat final du programme ci-dessus est illustré à l'aide de l'instantané suivant.

Sortie :

Exemple n°2 : Relation d'agrégation

Code :

import java.io.*;
import java.util.*;
class stud_class
{
String stud_name;
int roll_no ;
String stud_dept;
stud_class(String stud_name, int roll_no, String stud_dept)
{
this.stud_name = stud_name;
this.roll_no = roll_no;
this.stud_dept = stud_dept;
}
}
class Depofcollege
{
String stud_name;
private List<stud_class> students;
Depofcollege(String stud_name, List<stud_class> students)
{
this.stud_name = stud_name;
this.students = students;
}
public List<stud_class> getStudentsDetails()
{
return students;
}
}
class college
{
String collegeName;
private List<Depofcollege> departments;
college(String collegeName, List<Depofcollege> departments)
{
this.collegeName = collegeName;
this.departments = departments;
}
public int totalstudents()
{
int noOfStudents = 0;
List<stud_class> students;
for(Depofcollege dept : departments)
{
students = dept.getStudentsDetails();
for(stud_class s : students)
{
noOfStudents++;
}
}
return noOfStudents;
}
}
class aggregation
{
public static void main (String[] args)
{
stud_class stud1 = new stud_class("Sameer", 5, "IT");
stud_class stud2 = new stud_class("Pooja", 6, "IT");
stud_class stud3 = new stud_class("Sanddep", 8, "Mech");
stud_class stud4 = new stud_class("Jenny", 2, "Mech");
List <stud_class> i_students = new ArrayList<stud_class>();
i_students.add(stud1);
i_students.add(stud2);
List <stud_class> me_students = new ArrayList<stud_class>();
me_students.add(stud3);
me_students.add(stud4);
Depofcollege IT = new Depofcollege("IT", i_students);
Depofcollege Mech = new Depofcollege("Mech", me_students);
List <Depofcollege> departments = new ArrayList<Depofcollege>();
departments.add(IT);
departments.add(Mech);
college college= new college("MIT", departments);
System.out.print("Count of students: ");
System.out.print(college.totalstudents());
}
}

Explication :

• Dans l'exemple ci-dessus, nous essayons d'implémenter une relation d'agrégation en Java.
• Le résultat final du programme ci-dessus est illustré à l'aide de l'instantané suivant.

Sortie :

Conclusion

Nous avons vu la syntaxe de base de la composition et de l'agrégation dans l'article ci-dessus, et nous avons également vu différents exemples de composition et d'agrégation. À partir de cet article, nous avons vu comment et quand utiliser la composition et l'agrégation en Java.

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!