Komposition und Aggregation in Java

Java stellt die verschiedenen Beziehungen zwischen den Objekten bereit, die als real und programmiert betrachtet werden können. Manchmal ist es sehr schwierig, die Beziehungen zu verstehen, oder man könnte es so sagen, umzusetzen. Daher stellt Java dem Benutzer die Zusammensetzungs- und Aggregationsbeziehung zur Verfügung. In der Komposition können wir eine Beziehung aufbauen, die wir „gehört zu“-Beziehung nennen; Logischerweise können wir sagen, dass ein Objekt größer ist als andere Objekte. Durch Aggregation können wir eine Beziehung aufbauen, die wir „hat eine“-Beziehung nennen, in der jedes Objekt unabhängig voneinander agiert. Aggregationsbeziehungen betrachten wir als schwache Assoziation und Zusammensetzung als starke Assoziation.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax der Komposition und Aggregation

Syntax der Komposition wie folgt:

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

Erklärung:

• In der obigen Syntax betrachten wir ein Beispiel für ein Gebäude. Daher erstellen wir zunächst die Klasse mit dem Namen „Gebäude“ und der Raum ist der obligatorische Teil des Gebäudes, wie in der obigen Syntax gezeigt.
• Dies ist die Syntax der Kompositionsbeziehung, und hier zeigen wir, dass sie zur Beziehung gehört.

Syntax der Aggregation wie folgt:

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

Erklärung:

• In der obigen Syntax betrachten wir das Studentenbeispiel, in dem wir zunächst eine öffentliche Klasse mit dem Namen „Student“ erstellen und anschließend die Liste der Studenten erstellen, da die Studenten 0 oder mehr sein können, wie in gezeigt obige Syntax.
• Hier zeigen wir auch die „hat eine“-Beziehung zwischen den Objekten.

Wie funktionieren Komposition und Aggregation in Java?

Das Folgende zeigt, wie Komposition und Aggregation in Java funktionieren:

Zusammensetzung wird verwendet, um die „Zugehörigkeit“ einer Beziehung anzugeben. Dies impliziert, dass einer der Gegenstände intelligenterweise größer als die anderen Gegenstände ist, oder wir können von einem Objekt sprechen. Betrachten Sie beispielsweise einen Raum als Teil eines Gebäudes, oder wir können sagen, dass ein Gebäude einen Raum hat. Im Grunde ist es also nur eine Frage der Perspektive, ob wir es „gehört zu“ oder „hat-a“ nennen.

Grundsätzlich ist die Komposition eine starke Beziehung angesichts der Tatsache, dass das enthaltende Objekt sie beansprucht. Wenn wir also den Objektlebenszyklus entfernen, bedeutet dies, dass beim Entfernen des übergeordneten Knotens automatisch auch die untergeordneten Knoten entfernt werden. Wir können zum Beispiel darüber nachdenken, wann wir Räume zerstören; dann wird auch das Gebäude zerstört. Beachten Sie, dass dies nicht bedeutet, dass das enthaltende Objekt mit keinem seiner Teile existieren kann. Wir können beispielsweise alle Trennwände innerhalb einer Struktur zerstören und so die Räume vernichten. Wie dem auch sei, die Struktur wird auf jeden Fall existieren. Was die Kardinalität betrifft, kann ein enthaltender Artikel beliebig viele Teile haben, wie wir benötigen. Die Gesamtheit der Teile muss jedoch genau ein Fach haben.

Funktionsweise der Aggregation in Java wie folgt:

Wir wissen, dass Komposition „eine“ Beziehung hat. In ähnlicher Weise gibt es auch bei der Aggregation eine „Hat ein“-Beziehung. Der grundlegende Unterschied besteht darin, dass die Aggregation den übergeordneten Knoten oder das übergeordnete Objekt umfasst. In dieser Beziehung ist jedes einzelne Objekt unabhängig voneinander. Zum Beispiel können wir ein Auto und seine verschiedenen Räder betrachten. Das gleiche Rad können wir problemlos in ein anderes Auto einbauen und dann in die Arbeitsdatei aufnehmen. Wir wissen, dass ein Auto ohne Räder nicht nützlich ist. Aus diesem Grund setzen wir alle Teile des Objekts zusammen, was die Aggregationsbeziehung darstellt.

Beispiele für Komposition und Aggregation in Java

Im Folgenden finden Sie Beispiele für Zusammensetzungs- und Aggregationsbeziehungen:

Beispiel #1: Komposition

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);
}
}
}

Erklärung:

• Im obigen Beispiel versuchen wir, Kompositionsbeziehungen in Java zu implementieren.
• Die endgültige Ausgabe des obigen Programms veranschaulichen wir anhand des folgenden Schnappschusses.

Ausgabe:

Beispiel #2: Aggregationsbeziehung

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());
}
}

Erklärung:

• Im obigen Beispiel versuchen wir, eine Aggregationsbeziehung in Java zu implementieren.
• Die endgültige Ausgabe des obigen Programms veranschaulichen wir anhand des folgenden Schnappschusses.

Ausgabe:

Fazit

Wir haben die grundlegende Syntax der Komposition und Aggregation aus dem obigen Artikel gesehen und auch verschiedene Beispiele für Komposition und Aggregation gesehen. In diesem Artikel haben wir gesehen, wie und wann wir die Zusammensetzung und Aggregation in Java verwenden.

Das obige ist der detaillierte Inhalt vonKomposition und Aggregation in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!