Persatuan di Jawa

Persatuan dalam Java ialah hubungan atau sambungan antara dua kelas yang disediakan melalui Objek mereka. Persatuan mewakili bahawa kelas mengetahui tentang kelas lain dan memegang rujukan kepada kelas lain; ia boleh digambarkan sebagai hubungan "mempunyai-a" kerana ia melaksanakan di Jawa melalui penggunaan medan contoh. Hubungan persatuan boleh menjadi dua arah, kerana setiap kelas mempunyai rujukan kepada yang lain. Adakah perhubungan perkaitan mewakili cara objek berhubung antara satu sama lain? Bagaimanakah mereka berkomunikasi antara satu sama lain? Dan bagaimana mereka menggunakan fungsi masing-masing? Perhubungan persatuan boleh terdiri daripada empat jenis: satu-dengan-satu, banyak-dengan-satu, satu-dengan-banyak dan banyak-ke-banyak.

Bentuk Persatuan di Jawa

Dua bentuk persatuan ialah Pengagregatan dan Komposisi.

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

1. Pengagregatan

Pengagregatan ialah hubungan antara dua kelas yang ditetapkan melalui rujukan entiti; ia boleh digambarkan sebagai hubungan has-a dan sebahagian atau keseluruhan. Agregasi ialah satu bentuk persatuan yang merupakan persatuan sehala atau satu arah. Sebagai contoh, pelanggan boleh membuat pesanan, tetapi sebaliknya adalah mustahil, oleh itu satu arah.

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

2. Komposisi

Perhubungan komposisi ialah bentuk Pengagregatan terhad di mana dua kelas (atau entiti) sangat bergantung antara satu sama lain; objek yang digubah tidak boleh wujud tanpa entiti yang lain. Gubahan boleh digambarkan sebagai sebahagian daripada perhubungan.

Contoh Persatuan di Jawa

Berikut ialah contoh perkaitan yang berbeza di Jawa.

Contoh #1 – Hubungan Persatuan

Di sini, kami menulis kod Java untuk memahami hubungan Persatuan dengan lebih jelas dengan contoh berikut.

Kod:

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

Output:

Dalam kod di atas, dua Kelas, Syarikat dan Pekerja, melalui Objek mereka, mewakili hubungan satu-dengan-banyak kerana syarikat kelas boleh mempunyai ramai pekerja.

Contoh #2 – Hubungan Pengagregatan

Seterusnya, kami menulis Javacode untuk memahami hubungan pengagregatan dengan lebih jelas dengan contoh berikut.

Kod:

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

Output:

Seperti dalam kod di atas, kedai dalam talian mempunyai no. tempahan seperti prabayar dan COD. Setiap jenis pesanan mempunyai no. pelanggan, kelas Kedai Dalam Talian mengenai objek, atau tidak. daripada Objek kelas Pesanan. Kelas OnlineStore dikaitkan dengan kelas Pesanan melalui kelas Objek dan Pesanannya. Ia juga merujuk kepada objek (s) kelas Pelanggan, yang bermaksud ia berkaitan dengan kelas Pelanggan melalui Objeknya, mewakili perhubungan Has-A.

Contoh #3 – Hubungan Komposisi

Seterusnya, kami menulis kod Java untuk memahami hubungan Komposisi dengan lebih jelas dengan contoh berikut.

Kod:

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

Output:

Seperti dalam kod di atas, Kereta ialah kelas super bagi kelas Maruti, yang bermaksud Kereta boleh mempunyai no. kereta Maruti, dan Maruti menggunakan MarutiEngine sebagai bahagiannya; jika Maruti tidak wujud, maka MarutiEngine juga tidak akan keluar. Oleh itu kelas Maruti dan MarutiEngine menerangkan hubungan komposisi.

Penggunaan Persatuan dalam Java:

Seperti yang telah kita lihat di atas, keperluan untuk persatuan adalah untuk kebolehgunaan semula kod. Sebagai contoh, kami telah menggunakan dua kelas di atas, kelas Pelanggan, Kelas Pesanan dan kelas Kedai Online mengekalkan maklumat pelanggan dan pengaturcara tidak perlu menggunakan kod yang sama berulang kali.

Kesimpulan

Di Jawa, anda menubuhkan persatuan, yang merupakan hubungan antara dua kelas, dengan menyediakan objeknya. Bentuk persatuan ialah Agregasi dan gubahan. Tujuan utama perkaitan dalam Java adalah untuk kebolehgunaan semula kod.

Atas ialah kandungan terperinci Persatuan di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!