爪哇协会

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中文网其他相关文章！