In Java and object-oriented programming (OOP) generally, the core concepts aim to improve code modularity, readability, and reusability. Here’s a breakdown of all the essential OOP concepts:

1. Class and Object

  • Class: A blueprint or template from which objects are created. It defines a type by bundling data (fields) and methods to work on that data.
  • Object: An instance of a class. It is a concrete entity based on a class and represents a real-world entity with state and behavior.
  • Example:
    class Car { // Car is a class
    String color;
    void drive() {
        System.out.println("Car is driving.");
    }
}

Car myCar = new Car(); // myCar is an object of Car

2. Encapsulation

  • Concept: Bundles data and methods within a single class and restricts direct access to some components.
  • Purpose: Ensures that data is only modified through specified methods, promoting data integrity.
  • Example:
    public class Account {
    private double balance;

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

3. Abstraction

  • Concept: Focuses on essential qualities of an object rather than specific details, allowing you to manage complexity by hiding unnecessary details.
  • Purpose: Simplifies interactions with objects, presenting only the relevant features.
  • Example:
    abstract class Animal {
    abstract void sound(); // only essential feature
}

class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
}

4. Inheritance

  • Concept: Allows a new class (subclass) to acquire properties and behaviors from an existing class (superclass).
  • Purpose: Promotes code reuse and establishes a relationship between classes.
  • Example:
    class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Barking...");
    }
}

5. Polymorphism

  • Concept: Enables entities to take on multiple forms. In Java, this is primarily achieved through method overloading and method overriding.
  • Purpose: Allows flexibility in code by letting you use the same operation with different types.
  • Example:
    class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Bark");
    }
}

Animal myAnimal = new Dog(); // Polymorphism in action
myAnimal.sound(); // Outputs: Bark

6. Association

  • Concept: Defines a relationship between classes where each has its independent lifecycle but can work together.
  • Types: Association can be one-to-one, one-to-many, many-to-one, or many-to-many.
  • Example:
    class Teacher {
    String name;
}

class Student {
    String name;
}

// A teacher teaches multiple students (One-to-Many)

7. Aggregation

  • Concept: A specialized form of Association where a class is a part of another class but can exist independently.
  • Purpose: Represents a "has-a" relationship between objects.
  • Example:
    class Library {
    List books; // Library has-a collection of Books
}

class Book {
    String title;
}

8. Composition

  • Concept: A stronger form of Aggregation where the containing object cannot exist without the contained object.
  • Purpose: Represents a "part-of" relationship with stricter lifecycle dependency.
  • Example:
    class House {
    private Room room; // Room cannot exist without House
    
    House() {
        room = new Room(); // When House is created, Room is also created
    }
}

class Room {
    // Room details
}

9. Method Overloading and Method Overriding

  • Method Overloading: Having multiple methods in the same class with the same name but different parameters.
  • Method Overriding: Allowing a subclass to provide a specific implementation of a method that is already defined in its superclass.
  • Example:
    // Method Overloading
class Print {
    void display(String text) {
        System.out.println(text);
    }

    void display(int number) {
        System.out.println(number);
    }
}

// Method Overriding
class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Bark");
    }
}

Each of these concepts plays a vital role in structuring code that is modular, efficient, and easier to maintain. Together, they make Java's object-oriented approach a powerful tool for building applications.