1. Class:
   • A class in Java serves as a blueprint or template for creating objects. It encapsulates data (attributes) and behaviors (methods) that define the characteristics and actions of objects.
   • Classes promote code organization, modularity, and reusability by bundling related functionality into a single unit.

   Example:

   public class Car {    String color;
       int speed;
       void accelerate() {
           // Method to increase the speed
       }
   }     

   
   
2. Object:
   • An object is an instance of a class. It represents a specific entity in the real world and encapsulates both state (attributes) and behavior (methods).
   • Objects enable interaction and manipulation of data within the program, providing a way to model and simulate real-world scenarios.

   Example:

   Car myCar = new Car(); // Creating an object of the Car class
   myCar.color = "Red";
   myCar.speed = 100;
   myCar.accelerate();

   
   
3. Encapsulation:
   • Encapsulation is a fundamental OOP principle that involves bundling data (attributes) and methods (behaviors) within a class, and restricting access to the internal state of objects.
   • It promotes data integrity and abstraction by hiding implementation details and providing controlled access through public methods (getters and setters).Example:

   public class Car {
       private String color; // Encapsulated attribute
       public void setColor(String color) { // Setter method
           this.color = color;
       }
       public String getColor() { // Getter method
           return color;
       }
   }    

   
   
4. Inheritance:
   • Interfaces define a contract for classes to implement, specifying method signatures without implementations.
   • They facilitate loose coupling, multiple inheritance, and polymorphism by enabling unrelated classes to communicate through a common interface.

   Example:

   public interface Drawable {
       void draw(); // Method signature
   }
   

   
   
   • Multiple inheritance refers to the ability of a class to inherit attributes and behaviors from more than one superclass.
   • Java does not support multiple inheritance of classes to avoid the diamond problem, where ambiguity arises when a class inherits from two classes that have a common ancestor.
   • However, Java supports multiple inheritance through interfaces, allowing a class to implement multiple interfaces and inherit their method signatures.

   Example:

   
   interface Engine {
       void start();
       void stop();
   }
   
   interface GPS {
       void navigate();
   }
   
   public class SmartCar implements Engine, GPS {
       // Implementations of methods from Engine and GPS interfaces
   }

   
   
5. Polymorphism:
   • Polymorphism allows objects of different types to be treated as instances of a common superclass, fostering flexibility and extensibility in Java programs.
   • It is achieved through method overriding (runtime polymorphism) and method overloading (compile-time polymorphism).
   Method Overriding:
   
   • Method overriding occurs when a subclass provides a specific implementation of a method defined in its superclass.
   • It allows a subclass to customize or extend the behavior of inherited methods to suit its own requirements.
   • The overridden method in the subclass must have the same signature (name, parameters, and return type) as the method in the superclass.

   Example:

   class Animal {
       void makeSound() {
           System.out.println("Animal makes a sound");
       }
   }
   
   class Dog extends Animal {
       @Override
       void makeSound() {
           System.out.println("Dog barks");
       }
   }                 

   
   
   Method Overloading:
   • Method overloading involves defining multiple methods in the same class with the same name but different parameter lists.
   • It enables a class to provide different implementations of a method for different types or numbers of parameters.
   • The compiler determines which overloaded method to invoke based on the number and types of arguments passed.

   Example:

   
   class MathUtils {
       int add(int a, int b) {
           return a + b;
       }
   
       double add(double a, double b) {
           return a + b;
       }
   } 

6. Abstraction:
   • Abstraction involves hiding the complex implementation details of an object and exposing only the essential features through abstract classes and interfaces.
   • It facilitates code reuse, simplifies system design, and enhances maintainability by focusing on what an object does rather than how it does it.

   Example:

   
   public abstract class Shape {
       abstract double area(); // Abstract method
   } 

   
   
7. Association, Aggregation, and Composition:
   These relationships describe how classes are connected or associated with each other in Java:
   
   

   • Association:

     Represents a relationship between independent classes where each class can exist without the other.

   • Aggregation:

     Denotes a “has-a” relationship where one class contains another class as a part, implying a weaker connection than composition.

   • Composition:

     Signifies a stronger form of aggregation where the containing object owns the contained object and manages its lifecycle.
   
   
8. Interfaces:
   • Interfaces define a contract for classes to implement, specifying method signatures without implementations.
   • They facilitate loose coupling, multiple inheritance, and polymorphism by enabling unrelated classes to communicate through a common interface.

   Example:

   
   public interface Drawable {
       void draw(); // Method signature
   } 

These OOP concepts are fundamental pillars of Java programming, empowering developers to build modular, maintainable, and scalable software systems.