Cohésion en Java

La cohésion Java est définie comme utilisée pour effectuer des tâches spécialisées (tâche unique) au lieu de plusieurs tâches avec une seule classe Java. Si une classe crée avec une forte cohésion, on dit qu'elle se concentre sur un seul objectif spécifique, plutôt que d'effectuer différentes tâches à la fois.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Commencez votre cours de développement de logiciels libres

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

Exemple en temps réel : supposons que nous devions trouver la factorielle de n nombres et afficher le résultat à l'utilisateur. Si nous prenons une seule classe pour trouver une factorielle et afficher la sortie. Si le client souhaite toujours modifier l'affichage de la sortie dans différents styles, nous devons alors changer la même classe encore et encore sans modifier la logique factorielle. C'est une mauvaise pratique en développement, alors prenez une classe pour la logique factorielle et une autre classe pour la logique de sortie d'affichage, alors maintenant nous ne pouvons toujours changer que la classe de logique d'affichage. On dit qu'il s'agit d'une pratique de haute cohésion.

Types de cohésion

Il existe 2 types de Cohésions

1. Faible cohésion

Lorsque la classe est conçue pour effectuer de nombreuses tâches différentes au lieu de se concentrer sur une tâche spécifique, cette classe est appelée « classe à faible cohésion ». Ce type d'approche est la mauvaise approche de conception de programmation. Cela a nécessité beaucoup de modifications pour de petites monnaies.

Syntaxe :

class Operations
{
//code for multiplication
//code for division
//code for addition
//code for subtraction
.
.
.
}

Explication : Toutes les tâches sont effectuées dans la même classe, de sorte que si une modification se produit, nous devons changer presque tout le code.

2. Haute cohésion

Lorsque la classe est conçue pour effectuer une tâche spécifique, cette classe est appelée « classe à haute cohésion ». Ce type d'approche est une bonne approche de conception de programmation. Il peut être facilement entretenu et moins modifiable

Syntaxe :

class Multiplication
{
//code
}
class Division
{
//code
}
class Addition
{
//code
}
class Multiplication
{
//code
}

Explication : Facile à maintenir et moins modifiable car chaque classe a sa propre tâche spécifique.

Comment fonctionne la cohésion en Java ?

Les travaux de cohésion basés sur la fourniture d'une logique spécifique à chaque classe offrent une meilleure maintenabilité et une meilleure lisibilité.

Syntaxe :

class Task
{
//logic for task
}
class Display
{
//display task here
}

Exemples de cohésion en Java

Voici les exemples mentionnés ci-dessous :

Exemple n°1 – Cohésion de multiplication

Code :

package com.cohesion;
import java.util.Scanner;
//Multiplication logic class
class Multiplication {
// method for providing logic for multiplication of 2 numbers
public static double getMultiplication(double x, double y) {
// return the multiplcation output
return x * y;
}
}
// Output display class
public class MultiplicationCohesion {
public static void main(String args[]) {
// scanner class for ask user input
Scanner scanner = new Scanner(System.in);
System.out.println("Enter any two numbers=>");
// ask the user 2 numbers
double firstNumber = scanner.nextDouble();
double secondNumber = scanner.nextDouble();
// display the multiplication output
System.out.println("Muliplication of " + firstNumber + " and " + secondNumber + " is "
+ Multiplication.getMultiplication(firstNumber, secondNumber));
scanner.close();
}
}

 Sortie :

Exemple n°2 – Cohésion factorielle

Code :

package com.cohesion;
import java.util.Scanner;
//class for factorial
class Factorial {
// method for factorial logic
public static int getFactorial(int inputNumber) {
int factorial = 1;
// calculating the factorial
for (int temp = 1; temp <= inputNumber; temp++) {
factorial = factorial * temp;
}
// returning the factorial
return factorial;
}
}
public class FactorialCohesion {
public static void main(String args[]) {
// scanner class for ask user input
Scanner scanner = new Scanner(System.in);
System.out.println("Enter any number=>");
// ask the user 1 number
int number = scanner.nextInt();
// display the factorial output
System.out.println("Factorial of " + number + " is " + Factorial.getFactorial(number));
scanner.close();
}
}

Sortie :

Exemple n°3 – Cohésion des nombres parfaits

Code :

package com.cohesion;

import java.util.Scanner;
//class for perfect number
class PerfectNumber {
static int sum = 0;
// method for perfect number logic
public static int getPerfectNumber(int inputNumber) {
for (int i = 1; i < inputNumber; i++) {
if (inputNumber % i == 0) {
sum = sum + i;
}
}
return sum;
}
}
public class PerfectNumberCohesion {
public static void main(String args[]) {
// scanner class for ask user input
Scanner scanner = new Scanner(System.in);
System.out.println("Enter any number=>");
// ask the user 1 number
int number = scanner.nextInt();
int output = PerfectNumber.getPerfectNumber(number);
// checking sum and entered number
if (output == number) {
// display the perfect number output
System.out.println(number + " is a Perfect Number");
} else {
// display the perfect number output
System.out.println(number + " is not a Perfect Number");
}
scanner.close();
}
}

Sortie :

Exemple n°4 – Cohésion du nombre palindrome

Code :

package com.cohesion;
import java.util.Scanner;
//class for polindrome number
class Polindrome {
static int sum = 0;
// method for polindrome number logic
public static int getPolindromeNumber(int inputNumber) {
int r, sum = 0, temp;
temp = inputNumber;
while (inputNumber > 0) {
r = inputNumber % 10; // getting remainder
sum = (sum * 10) + r;
inputNumber = inputNumber / 10;
}
return sum;
}
}
public class PolindromeCohesion {
public static void main(String args[]) {
// scanner class for ask user input
Scanner scanner = new Scanner(System.in);
System.out.println("Enter any number=>");
// ask the user 1 number
int number = scanner.nextInt();
int output = Polindrome.getPolindromeNumber(number);
// checking sum and entered number
if (output == number) {
// display the palindrome output
System.out.println(number + " is a Polindrome Number");
} else {
// display the palindrome output
System.out.println(number + " is not a Polindrome Number");
}
scanner.close();
}
}

Sortie :

Conclusion

Java Cohesion est utilisé pour obtenir une meilleure maintenabilité et un code moins modifiable en effectuant n'importe quelle tâche spécifique de chaque classe. On parle alors de programmation de conception à haute cohésion. Des applications temps réel à forte cohésion seront préférables.

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!