Object-oriented programming (OOP) concepts in Java

The two main components of object-oriented programming are classes and objects. If the class is “Color,” the objects are “Red,” “Green,” and “Blue.” If the class is a bike, the objects are RE, Yamaha, Duke, and Jawa. 

A class is a user-defined template or prototype that is used to create objects. It represents the collection of attributes or methods shared by all objects of the same type. Instead of writing their code multiple times, you can use classes to create multiple objects with the same behavior. This includes classes for objects that appear multiple times in your code. The major components of a class include the modifier, class name, superclass, interfaces, and body.

In object-oriented programming, an object is a fundamental building block that represents real-world objects. A typical Java program generates a large number of objects, which interact by invoking methods. The objects are the components of your code that are visible to the viewer or user. An object includes a state, behavior, identity, and method.

Example

public class SLA{

    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[]) {

        SLA.set(“Hariharan”, 200000.0f);

        SLA.get();

    }

}

Output

Employee name is: Hariharan

Employee CTC is: 200000.0

Abstraction

Data abstraction allows the user to only see the most important information. The user doesn’t observe any extraneous or pointless units. For instance, a car is seen as a whole rather than as its distinct parts. Another definition of “data abstraction” is the process of identifying and removing all but the most essential components of an item. An object can be classified or grouped according to its characteristics and behaviors, which also help to distinguish it from other objects of the same sort.

Example

//abstract class

abstract class SLA{

  //abstract methods declaration

  abstract void add();

  abstract void mul();

  abstract void div();

}

Encapsulation

It is described as the collection of data into a single entity. It is the mechanism that connects the code to the data that it works with. Encapsulation can be thought of as a wall that prevents programming from the outside from accessing the data.

• Strictly speaking, encapsulation means that a class’s variables or data are kept secret from other classes and are only accessible through member functions of the class in which they are stated. 
• Encapsulation conceals a class’s data from other classes in a manner akin to data hiding. Encapsulation and data-hiding are interchangeable terms in this context.
• Encapsulation is accomplished by making all of a class’s variables private and by including public methods to set and retrieve the variables’ values.

Example

Encapsulation using private modifier   

class Employee {

    private int empid;

      private String ename;

}

Inheritance

Inheritance is a crucial OOP concept (Object Oriented Programming). A class can adopt the characteristics (fields and methods) of another class using Java’s methodology. By employing the extends keyword, we can achieve inheritance. Another name for inheritance is an “is-a” relationship.

Let’s go over some key terms that are used frequently:

Superclass: A superclass is a class from which features are inherited (also known as base or parent class).

Subclass: Those classes that inherit from other classes are known as subclasses (also known as derived or child class). In addition to the attributes and methods of the superclass, the subclass may also add additional fields and methods.

Reusability: Inheritance supports the concept of “reusability”; for instance, if we want to create a new class but an existing class already has some of the code we require, we can get our new class from the previous class. By doing this, we are making use of the pre-existing class’s fields and methods.

Example

//base class or parent class or superclass

class A{

  //parent class methods

  void method1(){}

  void method2(){}

}

class B extends A{ //Inherits parent class methods

  //child class methods

  void method3(){}

  void method4(){}

}

Polymorphism

It speaks to the effective distinction between entities with the same name that object-oriented programming languages are capable of making. Java accomplishes this with the aid of these entities’ signatures and declarations. Polymorphism is the capacity to manifest in a variety of forms.

Example

// Java program to Demonstrate Polymorphism

// This class will contain

// 3 methods with the same name,

// yet the program will

// compile & run successfully

public class Sum {

    // Overloaded sum().

    public int sum(int x, int y)

    {

        return (x + y);

    }

    public int sum(int x, int y, int z)

    {

        return (x + y + z);

    }

    // Overloaded sum().

    public double sum(double x, double y)

    {

        return (x + y);

    }

    // Driver code

    public static void main(String args[])

    {

        Sum s = new Sum();

        System.out.println(s.sum(10, 20));

        System.out.println(s.sum(10, 20, 30));

        System.out.println(s.sum(10.5, 20.5));

    }

}

Output

30

60

31.0