Object-Oriented Programming (OOP) is the foundation of Java and is essential for writing modular, reusable, and scalable applications. Mastering OOP principles helps Java developers design efficient, maintainable, and high-performance software.
In this article, we’ll cover 12 fundamental OOPS concepts — both basic and advanced — that every Java beginner should understand.
As a Java beginner, you may already know the below basic OOPS concepts:
Apart from the above basic OOPS concepts, you should also check out the below advanced OOPS concepts:
1️⃣ Object
The object is a real-time entity that has some state and behavior. In Java, an object is an instance of the class that has the instance variables as the state of the object and the methods as the behavior of the object.
The object of a class can be created by using a new keyword in Java programming.
Example: Defining an Object in Java
class Car {
String brand = "Tesla";
void displayBrand() {
System.out.println("Brand: " + brand);
}
}
public class Main {
public static void main(String[] args) {
Car myCar = new Car(); // Object creation
myCar.displayBrand(); // Method call
}
}✔️ Objects store data and perform operations through methods.
2️⃣ Class
A class is a blueprint for creating objects. It defines the structure (fields) and behavior (methods) of objects.
Example: Defining a Class
class Student {
String name;
int age;
void displayInfo() {
System.out.println(name + " is " + age + " years old.");
}
}✔️ A class does not occupy memory until an object is created.
3️⃣ Abstraction
Abstraction hides unnecessary implementation details and only exposes essential functionalities. It reduces complexity and improves security.
In Java, abstraction is achieved by Interfaces and Abstract classes. We can achieve 100% abstraction using Interfaces.
Example: Using Abstract Class
abstract class Animal {
abstract void makeSound(); // Abstract method (no implementation)
}
class Dog extends Animal {
void makeSound() {
System.out.println("Barks");
}
}
public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
dog.makeSound();
}
}✔️ Abstract classes and interfaces achieve abstraction.
4️⃣ Encapsulation
Encapsulation restricts direct access to an object’s data and ensures controlled modification using getter and setter methods.
Example: Implementing Encapsulation
class Employee {
private String name; // Private variable
// Setter
public void setName(String name) {
this.name = name;
}
// Getter
public String getName() {
return name;
}
}✔️ Encapsulation ensures data protection and maintainability.
5️⃣ Inheritance
Inheritance allows a child class to inherit properties and behaviors from a parent class, promoting code reuse.
Example: Implementing Inheritance
class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}
class Dog extends Animal {
void bark() {
System.out.println("Dog barks.");
}
}
public class Main {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.eat(); // Inherited method
myDog.bark(); // Child class method
}
}✔️ Types of Inheritance in Java:
🔹 Single Inheritance (One class inherits another)
🔹 Multilevel Inheritance (A -> B -> C)
🔹 Hierarchical Inheritance (One parent, multiple children)
6️⃣ Polymorphism
Polymorphism allows objects to be treated as instances of their parent class, enabling method overriding and method overloading.
Example 1: Method Overloading (Compile-time Polymorphism)
class MathOperations {
int add(int a, int b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }
}Example 2: Method Overriding (Runtime Polymorphism)
class Animal {
void makeSound() {
System.out.println("Animal makes a sound.");
}
}
class Cat extends Animal {
void makeSound() {
System.out.println("Cat meows.");
}
}✔️ Polymorphism increases flexibility and scalability.
7️⃣ Composition
Composition is a design principle where one class contains an instance of another class, forming a HAS-A relationship.
Example: Implementing Composition
class Engine {
void start() {
System.out.println("Engine is starting...");
}
}
class Car {
Engine engine = new Engine(); // Car HAS-A Engine
void startCar() {
engine.start();
System.out.println("Car is moving...");
}
}✔️ Composition promotes modularity and better code maintainability.
8️⃣ Aggregation
Aggregation represents a weak association between two objects, meaning one object can exist without the other.
Example: Implementing Aggregation
class Department {
String deptName;
Department(String deptName) {
this.deptName = deptName;
}
}
class Employee {
String name;
Department department;
Employee(String name, Department department) {
this.name = name;
this.department = department;
}
}✔️ Objects are loosely coupled in Aggregation.
9️⃣ Association
Association defines a relationship between two independent objects, allowing them to interact.
Example: Implementing Association
class Bank {
String name;
Bank(String name) {
this.name = name;
}
}
class Account {
String accountHolder;
Account(String accountHolder) {
this.accountHolder = accountHolder;
}
}✔️ Association can be one-to-one, one-to-many, or many-to-many.
🔟 Cohesion
Cohesion refers to how closely related a class’s methods and fields are. High cohesion means a class has one specific responsibility.
Good Example (High Cohesion)
class FileReader {
void readFile(String fileName) {
// Code to read file
}
}Bad Example (Low Cohesion)
class FileManager {
void readFile() {}
void writeFile() {}
void printFile() {}
void connectToDatabase() {} // Unrelated responsibility
}✔️ High cohesion improves maintainability and readability.
1️⃣1️⃣ Coupling
Coupling measures how dependent classes are on each other. Loose coupling is preferred over tight coupling.
Example: Loose Coupling (Preferred)
class EmailService {
void sendEmail() {
System.out.println("Email sent!");
}
}
class Notification {
private EmailService emailService = new EmailService();
void sendNotification() {
emailService.sendEmail();
}
}✔️ Loose coupling improves flexibility and reusability.
1️⃣2️⃣ Delegation
Delegation allows one class to delegate responsibilities to another, promoting code reuse and flexibility.
Example: Implementing Delegation
class Printer {
void print(String message) {
System.out.println(message);
}
}
class Manager {
Printer printer = new Printer();
void delegatePrinting() {
printer.print("Printing from Manager");
}
}✔️ Delegation improves modularity and reduces redundancy.
🎯 Conclusion: Master OOPS for Better Java Development
Mastering OOPS concepts in Java is crucial for writing scalable, maintainable, and efficient code. These principles help developers design robust applications while following best coding practices.
✅ Focus on Object, Class, Encapsulation, Abstraction, Inheritance, and Polymorphism.
✅ Understand advanced concepts like Composition, Aggregation, and Association.
✅ Follow High Cohesion, Loose Coupling, and Delegation principles.
🚀 Start applying these concepts today to enhance your Java programming skills! 🚀
Comments
Post a Comment
Leave Comment