Updated April 11, 2023

## Introduction to Cohesion in Java

The Java Cohesion is defined as used to perform the specialized tasks (single task) instead of multiple tasks with a single java class. If a class is creating with high cohesion then it is said to targeted towards a single specific purpose, rather than performing different tasks at a time.

Real-Time Example: Letβs assume we have to find out factorial of n numbers and display the output to the user. If we take a single class for finding factorial and displaying output. If the client always wants to change displaying output in different styles then we have to change the same class again and again without modifying factorial logic. This is bad practice in development, so take a class for factorial logic and another class for display output logic then now we can only change the display logic class always. It is said to high cohesion practice.

### Types of Cohesion

There are 2 types of Cohesions

#### 1. Low Cohesion

When class is designed to perform many different tasks instead of focusing on any specific task then that class is called “Low Cohesive class”. This kind of approach is the bad programming design approach. It required a lot of modifications for small change.

**Syntax:**

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

**Explanation: **All the task are performed within the same class so that if any modification occurs we have change almost entire code.

#### 2. High Cohesion

When class is designed to perform any specific task then that class is called as “High Cohesive class”. This kind of approach is good programming design approach. It can easily maintain and less modifiable

**Syntax:**

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

**Explanation: **Easy to maintain and less modifiable as each class has their own specific task.

### How Does Cohesion Work in Java?

Cohesion works based on providing specific logic for each class provide better maintainability and better readability.

**Syntax:**

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

### Examples of Cohesion in Java

Here are the examples mention below:

#### Example #1 – Multiplication Cohesion

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

**Β ****Output:**

#### Example #2 – Factorial Cohesion

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

**Output:**

#### Example #3 – Perfect number Cohesion

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

**Output:**

#### Example #4 – Palindrome number Cohesion

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

**Output:**

### Conclusion

Java Cohesion is used to achieve better maintainability and less modifiable code by perform any specific task from each class. This is said to be High cohesion design programming. Real time applications high cohesion will be preferable.

### Recommended Articles

This is a guide to Cohesion in Java. Here we discuss the introduction to Cohesion in Java along with the 2 types of cohesion and respective examples. You may also have a look at the following articles to learn more –