Zusammensetzung ist eine Art von Assoziation, die verwendet wird, um die „TEIL-VON“-Beziehung zwischen zwei Objekten darzustellen. Die Komposition in Java ist eine eingeschränkte Form einer anderen Art der Assoziationsaggregation, bei der die beiden Entitäten in einer „Has-a“-Beziehung ihre eigene Existenz haben und nicht voneinander abhängig sind. In der Zusammensetzung ist eine der Entitäten in anderen Entitäten enthalten und kann nicht alleine existieren. Im Gegensatz zur Vererbung, die zur Darstellung einer Ist-Beziehung verwendet wird.
Zum Beispiel gibt es zwei Klassen „Auto“ und „Motor“. „Auto“ besteht aus einem Motorobjekt und die Motorentität existiert nicht ohne „Auto“.
Starten Sie Ihren kostenlosen Softwareentwicklungskurs
Webentwicklung, Programmiersprachen, Softwaretests und andere
Syntax:
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;
}Mithilfe der obigen Syntax können wir die „isPart-Of“-Beziehung zwischen den beiden oben genannten Entitäten herstellen, wobei C1 für seine Existenz von der anderen Entität abhängt. Außerdem lässt sich veranschaulichen, dass die Existenz eines abhängigen Objekts optional ist.
Wenn wir die Vererbung für die Darstellung von zwei Entitäten verwenden, können wir sehen, dass nur eine IS-A-Beziehung existieren kann. Wenn jedoch zwei Entitäten eine „has-a“-Beziehung zwischen enthalten, ist eine Aggregation erforderlich. Es gibt zwei verschiedene Arten der Aggregation:
Dies wird verwendet, um die Beziehung darzustellen, bei der zwei Entitäten mit HAS-A-Beziehung existieren, eine davon jedoch für ihre Existenz nicht von anderen abhängig ist. Außerdem handelt es sich um eine unidirektionale Art der Assoziation. Beispielsweise sind „Bank“ und „Mitarbeiter“ zwei Einheiten, wobei die einzelne Einheit „Bank“ mit mehr als einem Mitarbeiter verbunden sein kann; Somit hat eine Bank eine Eins-zu-viele-Beziehung mit dem Mitarbeiter, umgekehrt gibt es jedoch keine.
Dies ist eine restriktive Art der Zuordnung, die verwendet wird, wenn eine der beiden Entitäten innerhalb einer anderen Container-Entität zusammengesetzt ist. Die zusammengesetzte Entität kann ohne ein Containerobjekt nicht existieren. Aber man kann eine nullkomponierte Entität haben. Daher wird es verwendet, um eine bidirektionale PART-OF-Beziehung darzustellen; Somit sind beide Entitäten voneinander abhängig.
Da die Zusammensetzung verwendet wird, um die PART-OF-Beziehung zwischen zwei Entitäten zu implementieren, wird eine Entität als Container und die andere als zusammengesetzte Entität bezeichnet. Die zusammengesetzte Entität ist wie ein vollständiges Containerobjekt, das über eigene Eigenschaften und Operationen verfügt und somit eine separate Entität für es darstellt. Dies hilft auch bei der Wiederverwendung von Code, da diese Klasse in anderen Containerklassen als zusammengesetzte Entität verwendet werden kann. Beispielsweise ist Engine eine zusammengesetzte Klasse und Car, TwooWheeler usw. können dafür Containerklassen sein.
Da die zusammengesetzte Klasse Teil einer Container-Entität ist, sind beide voneinander abhängig. Aber dennoch kann eine zusammengesetzte Klasse null sein, sagen wir, dass ein Auto keinen obligatorischen Motor haben muss. Damit ist die Existenz der Composed-Klasse vollständig von der Containerklasse abhängig. Da es sich bei Composition um eine Typassoziation handelt, wird die PART-OF-Beziehung auch als Unterklasse der HAS-A-Beziehung bezeichnet. Auf diese Weise hilft Composition dabei, eine Beziehung zwischen zwei voneinander abhängigen Entitäten zu implementieren, ohne Vererbung zu verwenden.
Stellen Sie sich den Fall von Office vor, das aus verschiedenen Listen wie „Schreibtisch“ und „Besprechungsräume“ besteht. Das Schreibtischobjekt besteht außerdem aus einem Telefonobjekt, da jeder Schreibtisch über ein Tischtelefon verfügt.
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);
}
}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();
}
}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();
}
}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 );
}
}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();
}
}Ausgabe:
Erklärung: Im obigen Programm besteht das Büroobjekt aus einer Liste von Schreibtischen und Besprechungsraum-Entitäten, während weitere Schreibtisch- und Besprechungsräume aus einer Telefon-Entität bestehen. Hier ist das Telefon immer mit dem Objekt „Schreibtisch“ oder „Besprechungsraum“ verknüpft und existiert daher nicht. Außerdem sind Besprechungsräume und Schreibtische von Office-Objekten abhängig. Hier kann eine einzelne Telefonklasse als zusammengesetzte Einheit im Schreibtisch- und Besprechungsraum verwendet werden und trägt so zur Wiederverwendbarkeit des Codes bei.
Es handelt sich um eine restriktive Art der Aggregation, die zur Implementierung der PART-OF-Beziehung zwischen zwei Entitäten mit bidirektionaler Beziehung verwendet wird und über die zusammengesetzte Entität verfügt, die ohne die Container-Entität nicht existiert hätte. Dies ist von Vorteil, da alle in der zusammengesetzten Klasse vorgenommenen Änderungen keine Auswirkungen auf den Rest des Codes und die Wiederverwendung des Codes haben.
Das obige ist der detaillierte Inhalt vonKomposition in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
