What is OOP?

OOP stands for Object-Oriented Programming.
Procedural programming is about writing procedures or methods that perform operations on the data, while object-oriented programming is about creating objects that contain both data and methods.

OOP provides several concepts:

Object
Class
Inheritance
Polymorphism
Abstraction
Encapsulation

Apart from these concepts, there are some other terms which are used in Object-Oriented design:

Coupling
Cohesion
Association
Aggregation
Composition

Object

An object is a basic unit of Object-Oriented Programming that represents real-life entities. A typical Java program creates many objects, which as you know, interact by invoking methods. The objects are what perform your code, they are the part of your code visible to the viewer/user. An object mainly consists of:

State: It is represented by the attributes of an object. It also reflects the properties of an object.
Behavior: It is represented by the methods of an object. It also reflects the response of an object to other objects.
Identity: It is a unique name given to an object that enables it to interact with other objects.
Method: A method is a collection of statements that perform some specific task and return the result to the caller. A method can perform some specific task without returning anything. Methods allow us to reuse the code without retyping it, which is why they are considered time savers.

Class

A class is a user-defined blueprint or prototype from which objects are created. It represents the set of properties or methods that are common to all objects of one type. Using classes, you can create multiple objects with the same behavior instead of writing their code multiple times. This includes classes for objects occurring more than once in your code. In general, class declarations can include these components in order:

Modifiers: A class can be public or have default access.
Class name: The class name should begin with the initial letter capitalized by convention.
Superclass (if any): The name of the class’s parent (superclass), if any, preceded by the keyword extends. A class can only extend (subclass) one parent.
Interfaces (if any): A comma-separated list of interfaces implemented by the class, if any, preceded by the keyword implements. A class can implement more than one interface.
Body: The class body is surrounded by braces, { }.

Ex:

public class Wrap {
    
   static String Employee_name;
   static float Employee_salary;

   static void set(String n, float p) {
       Employee_name  = n;
       Employee_salary  = p;
   }

   static void get() {
       System.out.println("Employee name is: " +Employee_name );
       System.out.println("Employee CTC is: " + Employee_salary);
   }

   public static void main(String args[]) {
       Wrap.set("Rathod Avinash", 10000.0f);
       Wrap.get();
   }
}

public class Wrap {

static String Employee_name;

static float Employee_salary;

static void set(String n, float p) {

Employee_name = n;

Employee_salary = p;

}

static void get() {

System.out.println("Employee name is: " +Employee_name );

System.out.println("Employee CTC is: " + Employee_salary);

}

public static void main(String args[]) {

Wrap.set("Rathod Avinash", 10000.0f);

Wrap.get();

}

Output:

Employee name is: Rathod Avinash
Employee CTC is: 10000.0

1 2	Employee name is: Rathod Avinash Employee CTC is: 10000.0

Inheritance

Inheritance is an important pillar of OOP (Object Oriented Programming). It is the mechanism in Java by which one class is allowed to inherit the features (fields and methods) of another class. We are achieving inheritance by using extends keyword. Inheritance is also known as “is-a” relationship.

Let us discuss some frequently used important terminologies:

Superclass: The class whose features are inherited is known as superclass (also known as base or parent class).
Subclass: The class that inherits the other class is known as subclass (also known as derived or extended or child class). The subclass can add its own fields and methods in addition to the superclass fields and methods.
Reusability: Inheritance supports the concept of “reusability”, i.e. when we want to create a new class and there is already a class that includes some of the code that we want, we can derive our new class from the existing class. By doing this, we are reusing the fields and methods of the existing class.

Ex:

//base class or parent class or super class
class A{
  //parent class methods
  void method1(){}
  void method2(){}
}

//derived class or child class or base class
class B extends A{  //Inherits parent class methods
  //child class methods
  void method3(){}
  void method4(){}
}

//base class or parent class or super class

class A{

//parent class methods

void method1(){}

void method2(){}

}

//derived class or child class or base class

class B extends A{ //Inherits parent class methods

//child class methods

void method3(){}

void method4(){}

}

Polymorphism

If one task is performed in different ways, it is known as polymorphism. For example: to convince the customer differently, to draw something, for example, shape, triangle, rectangle, etc.
In Java, we use method overloading and method overriding to achieve polymorphism.
Another example can be to speak something; for example, a cat speaks meow, dog barks woof, etc.
Ex:

sleep(1000) //millis

sleep(1000,2000) //millis,nanos

sleep(1000) //millis

sleep(1000,2000) //millis,nanos

Abstraction

Hiding internal details and showing functionality is known as abstraction. For example phone call, we don’t know the internal processing.
In Java, we use abstract class and interface to achieve abstraction.
Ex:

//abstract class
abstract class Wrap{
   //abstract methods declaration
   abstract void add();
   abstract void mul();
   abstract void div();
 }

//abstract class

abstract class Wrap{

//abstract methods declaration

abstract void add();

abstract void mul();

abstract void div();

}

Encapsulation

Binding (or wrapping) code and data together into a single unit are known as encapsulation. For example, a capsule, it is wrapped with different medicines.
A java class is the example of encapsulation. Java bean is the fully encapsulated class because all the data members are private here.
Ex:

//Encapsulation using private modifier 

//Employee class contains private data called employee id and employee name
class Employee {
    private int empid;
      private String ename;
}

//Encapsulation using private modifier

//Employee class contains private data called employee id and employee name

class Employee {

private int empid;

private String ename;

}

Coupling

Coupling refers to the knowledge or information or dependency of another class. It arises when classes are aware of each other. If a class has the details information of another class, there is strong coupling. In Java, we use private, protected, and public modifiers to display the visibility level of a class, method, and field. You can use interfaces for the weaker coupling because there is no concrete implementation.

Cohesion

Cohesion refers to the level of a component which performs a single well-defined task. A single well-defined task is done by a highly cohesive method. The weakly cohesive method will split the task into separate parts. The java.io package is a highly cohesive package because it has I/O related classes and interface. However, the java.util package is a weakly cohesive package because it has unrelated classes and interfaces.

Association

Association represents the relationship between the objects. Here, one object can be associated with one object or many objects. There can be four types of association between the objects:

One to One
One to Many
Many to One, and
Many to Many

Let’s understand the relationship with real-time examples. For example, One country can have one prime minister (one to one), and a prime minister can have many ministers (one to many). Also, many MP’s can have one prime minister (many to one), and many ministers can have many departments (many to many).
Association can be undirectional or bidirectional.

Aggregation

Aggregation is a way to achieve Association. Aggregation represents the relationship where one object contains other objects as a part of its state. It represents the weak relationship between objects. It is also termed as a has-a relationship in Java. Like, inheritance represents the is-a relationship. It is another way to reuse objects.

Composition

The composition is also a way to achieve Association. The composition represents the relationship where one object contains other objects as a part of its state. There is a strong relationship between the containing object and the dependent object. It is the state where containing objects do not have an independent existence. If you delete the parent object, all the child objects will be deleted automatically.

Advantage of OOPs over Procedure-oriented programming language

OOPs makes development and maintenance easier, whereas, in a procedure-oriented programming language, it is not easy to manage if code grows as project size increases.
OOPs provides data hiding, whereas, in a procedure-oriented programming language, global data can be accessed from anywhere.
OOPs provides the ability to simulate real-world event much more effectively. We can provide the solution of real word problem if we are using the Object-Oriented Programming language.