Object-Oriented Programming (OOP) in Java

Object-Oriented Programming (OOP) is a paradigm that emphasizes the organization of code into reusable, self-contained objects. It revolves around four core principles: encapsulation, inheritance, polymorphism, and abstraction. OOP promotes code flexibility, reusability, and maintainability.

Classes, Objects, and Inheritance:
In OOP, a class is a blueprint that defines the structure and behavior of objects. Objects are instances of classes that represent real-world entities. Inheritance allows one class (subclass) to inherit properties and methods from another class (superclass), fostering code reuse and creating hierarchical relationships.

Example of Classes and Inheritance:

class Animal {
void sound() {
System.out.println(“Animal makes a sound”);
}
}

class Dog extends Animal {
void sound() {
System.out.println(“Dog barks”);
}
}

Polymorphism enables a single method to have multiple implementations. Method overriding, a form of polymorphism, allows a subclass to provide its implementation of a method defined in its superclass.

Example of Polymorphism and Method Overriding:

class Shape {
void draw() {
System.out.println(“Drawing a shape”);
}
}

class Circle extends Shape {
void draw() {
System.out.println(“Drawing a circle”);
}
}

class Rectangle extends Shape {
void draw() {
System.out.println(“Drawing a rectangle”);
}
}

Encapsulation refers to the bundling of data and methods within a class, hiding the internal details from outside access. It promotes data security and reduces the impact of changes in one part of the code on other parts.

Example of Encapsulation and Data Hiding:

class Person {
private String name;
private int age;

public void setName(String name) {
this.name = name;
}

public void setAge(int age) {
this.age = age;
}

public String getName() {
return name;
}

public int getAge() {
return age;
}

}

Abstract classes are classes that cannot be instantiated and may contain abstract methods, which have no implementation in the abstract class. Interfaces define a contract for classes, specifying the methods they must implement.

Example of Abstract Classes and Interfaces:

abstract class Shape {
abstract void draw();
}

interface Drawable {
void draw();
}