Assoziation ist in Java eine Beziehung oder Verbindung zwischen zwei Klassen, die durch ihre Objekte hergestellt wird. Die Assoziation stellt dar, dass eine Klasse etwas über eine andere Klasse weiß und einen Verweis auf eine andere Klasse enthält; Sie kann als „hat-a“-Beziehung beschrieben werden, da sie in Java durch die Verwendung eines Instanzfelds implementiert wird. Die Assoziationsbeziehung kann bidirektional sein, da jede Klasse einen Verweis auf die andere hat. Stellt die Assoziationsbeziehung dar, wie Objekte miteinander verbunden sind? Wie kommunizieren sie miteinander? Und wie nutzen sie die Funktionalität des jeweils anderen? Eine Assoziationsbeziehung kann vier Arten haben: Eins-zu-Eins, Viele-zu-Eins, Eins-zu-Viele und Viele-zu-Viele.
Die beiden Assoziationsformen sind Aggregation und Komposition.
Starten Sie Ihren kostenlosen Softwareentwicklungskurs
Webentwicklung, Programmiersprachen, Softwaretests und andere
Aggregation ist eine Beziehung zwischen zwei Klassen, die durch Entitätsreferenz eingerichtet wird; es kann als eine Hat-a-und-Teil-oder-Ganze-Beziehung beschrieben werden. Eine Aggregation ist eine Form der Assoziation, bei der es sich um eine einseitige oder unidirektionale Assoziation handelt. Beispielsweise können Kunden Bestellungen haben, aber das Umgekehrte ist unmöglich, also unidirektional.
class Customer{
int cid;
String cname;
Order ordering;
}Zusammensetzungsbeziehung ist eine eingeschränkte Form der Aggregation, bei der zwei Klassen (oder Entitäten) stark voneinander abhängig sind; Das zusammengesetzte Objekt kann ohne die andere Entität nicht existieren. Die Komposition kann als Teil einer Beziehung beschrieben werden.
Im Folgenden sind die verschiedenen Beispiele für Assoziationen in Java aufgeführt.
Hier schreiben wir den Java-Code, um die Assoziationsbeziehung anhand des folgenden Beispiels besser zu verstehen.
Code:
package demo;
import java.io.*;
class Department
{
private String dname;
public void setDepartmentName(String cname)
{
this.dname = cname;
}
public String getDepartmentName()
{
return this.dname;
}
}
class Emp
{
public String ename;
public void setEmployeeName(String ename)
{
this.ename = ename;
}
public String getEmployeeName()
{
return this.ename;
}
}
class demo
{
public static void main (String[] args)
{
Department d = new Department();
Department d1 = new Department();
Emp e = new Emp();
Emp e1 = new Emp();
d.setDepartmentName("Sales");
d1.setDepartmentName("Accounting");
e.setEmployeeName("John");
e1.setEmployeeName("Joseph");
System.out.println(e.getEmployeeName() + " is working in " + d.getDepartmentName() + ".");
System.out.println(e1.getEmployeeName() + " is working in " + d1.getDepartmentName() + ".");
}
}Ausgabe:
Im obigen Code stellen zwei Klassen, Company und Employee, über ihre Objekte eine Eins-zu-viele-Beziehung dar, da die Klasse Company viele Mitarbeiter haben kann.
Als nächstes schreiben wir den Javacode, um die Aggregationsbeziehung anhand des folgenden Beispiels besser zu verstehen.
Code:
import java.io.*;
import java.util.*;
class Customer
{
String cname;
int cid ;
String type;
public static int cpp=0,ccod=0;
Customer(String cname, int cid, String type)
{
this.cname = cname;
this.cid = cid;
this.type = type;
if(type=="prepaid")
cpp++;
else
ccod++;
}
}
class Order
{
String type;
//list of customer Objects associated with customer class as with its Object(s). */
private List<Customer> customers;
public void setCustomers(String type, List<Customer> customers)
{
this.type = type;
this.customers = customers;
}
public List<Customer> getCustomers()
{
return customers;
}
}
class OnlineStore
{
// list of order Objects which associated with order as with its objects.
private List<Order> orders;
public void setnoCustomer( List<Order> orders)
{
this.orders = orders;
}
// count total customers of all orders in a given purchases
public int getnoCustomer()
{
int noOfOrders = 0;
List<Customer> customers;
for(Order dept : orders)
{
customers = dept.getCustomers();
for(Customer s : customers)
{
noOfOrders++;
}
}
return noOfOrders;
}
}
class demo
{
public static void main (String[] args)
{
Customer c1 = new Customer("Mia", 1, "prepaid");
Customer c2 = new Customer("Priya", 2, "prepaid");
Customer c3 = new Customer("John", 1, "COD");
Customer c4 = new Customer("Rahul", 2, "COD");
List <Customer> cu1 = new ArrayList<Customer>();
cu1.add(c1);
cu1.add(c2);
// making a List of COD Customers
List <Customer> cu2 = new ArrayList<Customer>();
cu2.add(c3);
cu2.add(c4);
Order pp = new Order();
pp.setCustomers("prepaid", cu1);
Order cod = new Order();
cod.setCustomers("COD", cu2);
List <Order> orders = new ArrayList<Order>();
orders.add(pp);
orders.add(cod);
// creating an OnlineStore instance.
OnlineStore purchase = new OnlineStore();
purchase.setnoCustomer(orders);
System.out.print("Number of Customers placed order are : ");
System.out.println(purchase.getnoCustomer());
System.out.print("Number of Customers placed prepaid order are : ");
System.out.println(Customer.cpp);
System.out.print("Number of Customers placed cod order are : ");
System.out.println(Customer.cpp);
}
}Ausgabe:
Wie im obigen Code hat ein Online-Shop keine. von Bestellungen wie Prepaid und Nachnahme. Jede Art von Bestellung hat keine. Anzahl der Kunden, eine OnlineStore-Klasse bezüglich Objekten oder keine. von Objekten der Order-Klasse. Die Klasse „onlineStore“ ist über ihre Objekte und die Klasse „Order“ mit der Klasse „Order“ verknüpft. Es bezieht sich auch auf die Objekte der Customer-Klasse, was bedeutet, dass es über seine Objekte mit der Customer-Klasse in Beziehung steht und eine Has-A-Beziehung darstellt.
Als nächstes schreiben wir den Java-Code, um die Kompositionsbeziehung anhand des folgenden Beispiels besser zu verstehen.
Code:
class Car
{
private String color;
private int wheels;
public void carFeatures()
{
System.out.println("The color of the car is "+color + " and number of wheels are " + wheels);
}
public void setColor(String color)
{
this.color = color;
}
public void setwheels(int wheels)
{
this.wheels = wheels;
}
}
class Maruti extends Car
{
public void setStart()
{
MarutiEngine e = new MarutiEngine();
e.run();
}
}
class MarutiEngine extends Maruti
{
public void run()
{
System.out.println("Engine is running...");
}
public void stop()
{
System.out.println("Engine is not running... ");
}
}
public class demo
{
public static void main(String[] args)
{
Maruti m1 = new Maruti();
m1.setwheels(4);
m1.setColor("White");
m1.carFeatures();
m1.setStart();
}
}Ausgabe:
Wie im obigen Code ist ein Auto die Oberklasse der Maruti-Klasse, was bedeutet, dass das Auto keine haben kann. von Maruti-Autos, und Maruti verwendet MarutiEngine als Teil davon; Wenn Maruti nicht existiert, wird MarutiEngine auch nicht beendet. Somit beschreiben Maruti und die MarutiEngine-Klasse die Kompositionsbeziehung.
Verwendung von Assoziationen in Java:
Wie wir oben gesehen haben, besteht die Notwendigkeit einer Zuordnung für die Wiederverwendbarkeit des Codes. Beispielsweise haben wir die beiden oben genannten Klassen Kundenklasse, Bestellklasse und OnlineStore-Klasse verwendet, um Kundeninformationen zu verwalten, und Programmierer müssen nicht immer wieder denselben Code verwenden.
In Java stellen Sie eine Assoziation her, also eine Beziehung zwischen zwei Klassen, indem Sie deren Objekte einrichten. Die Formen einer Assoziation sind Aggregation und Zusammensetzung. Der Hauptzweck der Assoziation in Java ist die Wiederverwendbarkeit von Code.
Das obige ist der detaillierte Inhalt vonVerein in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
