Association en Java

L'association en Java est une relation ou une connexion entre deux classes établies via leurs objets. L'association représente qu'une classe connaît une autre classe et détient une référence à une autre classe ; elle peut être décrite comme une relation « possède un » car elle est implémentée en Java via l'utilisation d'un champ d'instance. La relation d'association peut être bidirectionnelle, chaque classe faisant référence à l'autre. La relation d'association représente-t-elle la façon dont les objets se connectent les uns aux autres ? Comment communiquent-ils entre eux ? Et comment utilisent-ils les fonctionnalités de chacun ? Une relation d'association peut être de quatre types : un-à-un, plusieurs-à-un, un-à-plusieurs et plusieurs-à-plusieurs.

Formes d'association en Java

Les deux formes d'association sont l'Agrégation et la Composition.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

1. Agrégation

L'agrégation est une relation entre deux classes établie via une référence d'entité ; elle peut être décrite comme une relation « has-a » et partielle ou totale. Une agrégation est une forme d'association à sens unique ou unidirectionnelle. Par exemple, les clients peuvent avoir des commandes, mais l'inverse est impossible, donc unidirectionnel.

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

2. Composition

La relation de composition est une forme restreinte d'agrégation dans laquelle deux classes (ou entités) sont fortement dépendantes l'une de l'autre ; l'objet composé ne peut exister sans l'autre entité. La composition peut être décrite comme une partie de la relation.

Exemples d'association en Java

Voici les différents exemples d'association en Java.

Exemple n°1 – Relation d'association

Ici, nous écrivons le code Java pour comprendre plus clairement la relation d'association avec l'exemple suivant.

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

Sortie :

Dans le code ci-dessus, deux classes, Entreprise et Employé, à travers leurs objets, représentent une relation un-à-plusieurs car la classe Entreprise peut avoir de nombreux employés.

Exemple n°2 – Relation d'agrégation

Ensuite, nous écrivons le Javacode pour comprendre plus clairement la relation d'agrégation avec l'exemple suivant.

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

Sortie :

Comme dans le code ci-dessus, une boutique en ligne n'en a pas. de commandes comme prépayées et COD. Chaque type de commande n'a pas. de clients, une classe OnlineStore concernant les objets, ou non. d'objets de la classe Order. La classe onlineStore est associée à la classe Order via ses classes Objects et Order. Il fait également référence au(x) objet(s) de la classe Customer, ce qui signifie qu'il est lié à la classe Customer via ses Objects, représentant une relation Has-A.

Exemple n°3 – Relation de composition

Ensuite, nous écrivons le code Java pour comprendre plus clairement la relation Composition avec l'exemple suivant.

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

Sortie :

Comme dans le code ci-dessus, une voiture est la superclasse de la classe Maruti, ce qui signifie que la voiture ne peut en avoir aucune. des voitures Maruti, et Maruti utilise MarutiEngine dans le cadre ; si Maruti n'existe pas, alors MarutiEngine ne se fermera pas non plus. Ainsi, les classes Maruti et MarutiEngine décrivent la relation de composition.

Utilisation de l'association en Java :

Comme nous l'avons vu ci-dessus, la nécessité d'une association est liée à la réutilisabilité du code. Par exemple, nous avons utilisé les deux classes ci-dessus, la classe Customer, la classe Order et la classe OnlineStore pour conserver les informations client, et les programmeurs n'ont pas besoin d'utiliser le même code encore et encore.

Conclusion

En Java, vous établissez une association, qui est une relation entre deux classes, en configurant leurs objets. Les formes d'une association sont l'agrégation et la composition. L'objectif principal de l'association en Java est la réutilisabilité du code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!