爪哇協會

Java 中的關聯是兩個類別之間透過其物件建立的關係或連結。關聯表示一個類別了解另一個類別並持有對另一個類別的引用；它可以被描述為「has-a」關係，因為它在 Java 中透過使用實例欄位來實現。關聯關係可以是雙向的，因為每個類別都互相引用。關聯關係是否代表物件之間如何連結？他們如何互相溝通？他們如何使用彼此的功能？關聯關係可以有四種：一對一、多對一、一對多、多對多。

Java 中的關聯形式

關聯的兩種形式是聚合和組合。

開始您的免費軟體開發課程

網頁開發、程式語言、軟體測試及其他

1。聚合

聚合是透過實體引用建立的兩個類別之間的關係；它可以被描述為「有一個」和「部分」或「整體」關係。聚合是一種單向或單向關聯的關聯形式。例如，客戶可以有訂單，但相反的訂單是不可能的，因此是單向的。

class Customer{
int cid;
String cname;
Order ordering;
}

2。成分

組合關係是聚合的一種受限形式，其中兩個類別（或實體）彼此高度依賴；沒有其他實體，組合物件就無法存在。組合可以描述為部分關係。

Java 中關聯的範例

以下是 Java 中關聯的不同範例。

範例 #1 – 關聯關係

這裡，我們透過下面的範例編寫Java程式碼來更清楚地理解關聯關係。

代碼：

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

輸出：

在上面的程式碼中，Company 和 Employee 兩個類別透過它們的物件表示一對多的關係，因為 Company 類別可以有多個員工。

範例 #2 – 聚合關係

接下來，我們透過以下範例編寫Java程式碼，以便更清楚地理解聚合關係。

代碼：

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

輸出：

如上面的程式碼所示，線上商店沒有。預付和貨到付款等訂單。每種類型的訂單都沒有。客戶數量、有關物件的 OnlineStore 類，或沒有。 Order 類別的物件的數量。 onlineStore 類別透過其 Objects 和 Order 類別與 Order 類別關聯。它還引用 Customer 類別的對象，這意味著它透過其物件與 Customer 類別相關，表示 Has-A 關係。

範例 #3 – 組合關係

接下來，我們透過以下範例編寫Java程式碼，以便更清楚地理解組合關係。

代碼：

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

輸出：

如上面的程式碼所示，Car是Maruti類別的超類，這意味著Car可以沒有。 Maruti 汽車，Maruti 使用 MarutiEngine 作為其零件；如果Maruti不存在，那麼MarutiEngine也不會退出。因此 Maruti 和 MarutiEngine 類別描述了組合關係。

Java 中關聯的使用：

正如我們在上面所看到的，關聯的需要是為了程式碼的可重複使用性。例如，我們已經使用了上面的兩個類，Customer類、Order類、OnlineStore類來維護客戶訊息，程式設計師不需要一次又一次使用相同的程式碼。

結論

在 Java 中，您可以透過設定物件來建立關聯，也就是兩個類別之間的關係。關聯的形式有聚合和組合。 Java 中關聯的主要目的是為了程式碼的可重複使用性。

以上是爪哇協會的詳細內容。更多資訊請關注PHP中文網其他相關文章！