Object-Oriented Programming (OOP) is a programming paradigm that uses objects and classes to create models based on the real world. Java, being an object-oriented programming language, implements these concepts to provide a clear modular structure for programs. This article delves into the fundamental OOPs concepts in Java: encapsulation, inheritance, polymorphism, and abstraction, accompanied by practical examples for a comprehensive understanding.
Encapsulation: Protecting Data Integrity
What is Encapsulation?
Encapsulation is the mechanism of bundling the data (variables) and the code (methods) that manipulates the data into a single unit, called a class. It also restricts direct access to some of an object’s components, which is a means of preventing accidental interference and misuse of the methods and data.
Java Example of Encapsulation
In Java, encapsulation is implemented using private variables and public methods. Here’s a simple example:
public class Employee {
private String name;
private int age;
public void setName(String newName) {
name = newName;
}
public String getName() {
return name;
}
public void setAge(int newAge) {
age = newAge;
}
public int getAge() {
return age;
}
}
Inheritance: Enhancing Code Reusability
Understanding Inheritance in Java
Inheritance in Java is a mechanism where one class acquires the properties and behaviors (methods) of another class. This helps in code reusability and method overriding. The class that inherits is called a subclass, and the class from which it inherits is called a superclass.
Java Example of Inheritance
Consider the following example:
class Animal {
void eat() {
System.out.println("Eating...");
}
}
class Dog extends Animal {
void bark() {
System.out.println("Barking...");
}
}
public class TestInheritance {
public static void main(String args[]) {
Dog d = new Dog();
d.bark();
d.eat();
}
}
Polymorphism: Flexibility in Using Objects
What is Polymorphism in Java?
Polymorphism in Java allows objects to be treated as instances of their parent class rather than their actual class. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object.
Java Example of Polymorphism
Here’s an example to illustrate polymorphism:
class Bird {
void sing() {
System.out.println("Bird is singing");
}
}
class Sparrow extends Bird {
void sing() {
System.out.println("Sparrow is singing");
}
}
public class TestPolymorphism {
public static void main(String args[]) {
Bird b;
b = new Sparrow(); // Polymorphism
b.sing();
}
}
Abstraction: Simplifying Complexity
The Concept of Abstraction in Java
Abstraction is a process of hiding the implementation details and showing only functionality to the user. In Java, abstraction is achieved using abstract classes and interfaces.
Java Example of Abstraction
An example of abstraction using an abstract class:
abstract class Shape {
abstract void draw();
}
class Rectangle extends Shape {
void draw() {
System.out.println("drawing rectangle");
}
}
class Circle extends Shape {
void draw() {
System.out.println("drawing circle");
}
}
public class TestAbstraction {
public static void main(String args[]) {
Shape s = new Circle(); // In real scenario, object is provided through method, e.g., getShape() method
s.draw();
}
}
Conclusion
The OOPs concepts in Java – encapsulation, inheritance, polymorphism, and abstraction – are fundamental to developing robust and efficient Java applications. Understanding and implementing these concepts correctly will significantly enhance your programming skills and enable you to write better Java code. Remember, practical implementation of these concepts is key to mastering Java OOPs.
by the Bito team. 
