Couplage en Java

Le couplage en JAVA est un indicateur de a. dépendance d'une classe avec l'autre classe dans un environnement orienté objet, b. niveau de flexibilité dont dispose le développeur pour modifier le code dans différentes classes pour répondre aux exigences de l'utilisateur final, c. la manière dont la fonctionnalité d'une classe est utilisée par l'autre classe : directement ou à l'aide d'interfaces externes, d. les efforts requis pour maintenir le code après la mise en ligne, e. la manière dont des techniques logicielles innovantes telles que l'inversion de contrôle et l'injection de dépendances sont utilisées pour injecter plus de flexibilité dans le codage et les tests de codes.

Commencez votre cours de développement de logiciels libres

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

Types de couplage en Java

Il existe deux couplages majeurs en Java, et analysons-les en détail.

1. Couplage serré

Dans la conception d'applications orientées objet, il est toujours nécessaire d'utiliser la logique développée dans une classe dans une autre classe pour réutiliser les efforts déjà investis et éviter de réinventer la roue.

La collaboration directe entre les classes conduit à un couplage étroit, et ses fonctionnalités sont

• La logique métier disponible dans la classe appelée est créée en tant qu'objet à l'intérieur de la classe appelante.
• L'objet ainsi créé est exécuté au sein de la classe appelante pour obtenir la fonctionnalité requise. Par conséquent, le programme appelant connaît toutes les fonctionnalités de la logique métier disponible dans la classe appelée.
• Tout changement dans la logique métier codée dans la classe appelée impacte les résultats de la classe appelée
• Si les changements sont inévitables dans la classe appelée, des changements adaptés devront également être effectués dans la classe appelante.
• Par conséquent, les classes sont fortement interdépendantes les unes des autres

Exemple de couplage serré

Deux classes collaboratrices dans cet exemple, « Ordervalue » et « order », sont interdépendantes. La classe appelante « Ordervalue » connaît la logique métier codée dans « l'ordre » de la classe appelée en conséquence, le code de la classe appelante est structuré et tout changement dans la classe appelée perturbera les résultats du programme.

On peut donc conclure que les classes « Valeur de commande » et « Ordre » sont étroitement couplées.

Code :

// Tight Coupling - Sample program
public class ordervalue // Calling class
{
public static void main(String args[]) // method in the class
{
order b = new order(600,5); // creating object for the called class
System.out.println("value of the order is");
// order and execute it
System.out.println(b.value); // Prints the order value computed by
} // the called class
}
class order // Called class
{
public int value; // method in the class
order(int orderquantity, int rate) // business logic
{
this.value = orderquantity * rate; // computing the value
}
}

Sortie :

2. Couplage lâche

Dans ce concept, les classes qui doivent collaborer pour partager la logique métier et les fonctionnalités communes dans OOPS sont couplées via des sources externes. Ainsi, ils sont vaguement ou indirectement connectés entre eux.

Les principaux attributs du couplage lâche sont

• Les dépendances entre les classes, les composants de code et les modules sont faibles.
• Si la dépendance est inévitable, alors ils sont connectés via des composants externes comme des interfaces.
• La connectivité utilisant les interfaces reste minimale pour profiter des avantages du couplage lâche.
• Il ne sera pas nécessaire de définir des objets autour des autres classes au sein d'une classe, et les objets seront indépendants.
• Chaque classe connaîtra peu d'informations sur les autres classes de ce couplage. Au mieux, chaque classe sera consciente des interfaces auxquelles les autres modules sont exposés.
• Toute modification du code dans une classe n'impactera pas les autres classes, et celles-ci n'ont pas besoin d'être mises à jour.
• Il offre une flexibilité parfaite au développeur pour modifier facilement le code et s'adapter aux nouveaux changements commerciaux.
• Le temps et les efforts nécessaires à la maintenance des programmes sont considérablement réduits
• Les concepts du framework Spring tels que l'inversion de contrôle et l'injection de dépendances sont utilisés pour surmonter le couplage étroit.

Inversion de contrôle (IOC)

C'est un concept par lequel le contrôle des modules ou des objets du programme est transféré au framework conteneur. Ce concept est utilisé assez régulièrement en OOPS. Au lieu que les codes de programme appellent une bibliothèque, le framework de conteneurs prend en charge les codes de contrôle et d'appel. La dépendance est injectée dans les objets par opposition aux objets créant des dépendances.

Ce concept facilite le couplage lâche et la modularité dans la programmation.

Injection de dépendance (DI)

DI est le véhicule par lequel les concepts IOC sont mis en œuvre et le transfert de contrôle a lieu lors de la configuration des dépendances d'objet.

Exemples de couplage lâche

In the example, three Classes, “month1”, “month2”, “month3” are independent modules, and they collaborate little with each other through an interface “iface”. As a result, these classes have very little knowledge of the other classes on what they are doing. They only know that all the classes are interacting with an interface.

There is no object created using the other classes in any of these classes, and they are the typical examples of loose coupling.

Code:

// Loose Coupling in JAVA - Sample Program
interface Iface //Interface is defined
{
public void monthname(); //module within the interface
}
class month1 implements Iface { // Class interacts through
public void monthname() // interface
{
System.out.println("January");
}
}
class month2 implements Iface { // Class interacts through
public void monthname() // interface
{
System.out.println("Feburary");
}
}
class month3 implements Iface { // Class interacts through
public void monthname() // interface
{
System.out.println("March");
}
}
public class Subject { // Execution starts here
public static void main(String[] args)
{
Iface t = new month1(); // First class called thru
t.monthname(); // interface
Iface tx = new month2(); // Second class called thru
tx.monthname(); // interface
Iface tx2 = new month3(); // Third class called thru
tx2.monthname(); } // interface
}

Output:

Conclusion

As far as possible, applications will have to be designed to hold only loose couplings for better maintainability and serviceability and keep interdependence between program components very minimal. However, if interdependence is a must, the components will have to be connected only through the interface.

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!