🎯 Object-Oriented Programming (OOP) in Java

Quote

“Object-oriented programming is not a technology, it’s a philosophy”

🏗️ What is OOP?

Java is a pure object-oriented language (except for primitive types). Most of the power and flexibility in Java comes from its support for OOP principles. This section is critical for interviews, both for concept-based and coding questions.

🌟 What OOP Brings to the Table

Benefit	Description
Modularity	Separation of concerns - each class has a single responsibility
Reusability	Components can be reused across projects
Extensibility	Easy to extend functionality without modifying existing code
Maintainability	Organized and clean codebase
Lower Cost & Faster Development	Due to reusable code and better organization

Caution

Be aware of these challenges:

• Steep learning curve - OOP concepts can be complex initially
• Larger program size - More code structure and boilerplate
• Performance overhead - Object creation and method calls have costs

🔑 Core OOP Principles

Java follows four main OOP principles:

1. Inheritance - Code reuse through “is-a” relationships
2. Polymorphism - Same interface, different implementations
3. Encapsulation - Data hiding and controlled access
4. Abstraction - Hiding complexity, showing only essentials

---

🧬 Inheritance

Inheritance allows a class (child/subclass) to derive properties and methods from another class (parent/superclass).

🔑 Key Concepts

• Keyword: extends
• Purpose: Promotes code reuse and establishes an “is-a” relationship
• Relationship: Child class is-a type of parent class

class DerivedClass extends BaseClass {
   // methods and fields
}

📌 Benefits of Inheritance

• ✅ Code Reuse - Don’t repeat code across similar classes
• ✅ Establishes “is-a” Relationship - Clear hierarchy and relationships
• ✅ Polymorphism - Can use child objects where parent types are expected

🧠 Types of Inheritance

1. Single Inheritance

class Animal { }
class Dog extends Animal { }  // Dog inherits from Animal

2. Multilevel Inheritance

class Animal { }
class Mammal extends Animal { }
class Dog extends Mammal { }  // Dog inherits from Mammal, which inherits from Animal

3. Hierarchical Inheritance

class Animal { }
class Dog extends Animal { }
class Cat extends Animal { }  // Both Dog and Cat inherit from Animal

4. Multiple Inheritance (via Interfaces Only)

interface Flyable { }
interface Swimmable { }
class Duck implements Flyable, Swimmable { }  // Duck can fly and swim

Note

Multiple Inheritance is achieved ONLY through interfaces in Java, not through classes!

📌 Important Inheritance Rules

What Gets Inherited:

• ✅ Public and protected members (fields and methods)
• ✅ Default (package-private) members within the same package
• ❌ Private members - but can be accessed via getters/setters
• ❌ Constructors - but super() can be used to call parent constructor

What Subclasses Can Do:

• Inherit as-is - Use parent’s implementation
• Override methods - Provide new implementation
• Hide static methods - Define new static method with same signature
• Add new members - Extend functionality

🔁 Constructor Rules in Inheritance

Rule	Explanation
Cannot Override	Constructors are tied to the class, not inherited
Can Overload	Multiple constructors with different parameters
super() and this()	Only one allowed, must be first line
Default Constructor	Injected only if no custom constructors exist

❌ Critical Rule: Never Use super() and this() Together

Danger

Both super() and this() must be the FIRST line in a constructor. You CANNOT use them together!

public class MyClass {
    MyClass() {
        this(5);      // ❌ this() must be first
        super();      // ❌ super() also must be first — this is illegal!
    }

    MyClass(int x) {
        // constructor logic
    }
}

Correct Usage:

public class MyClass {
    MyClass() {
        this(5);      // ✅ this() is first
    }

    MyClass(int x) {
        super();      // ✅ super() is first
        // constructor logic
    }
}

---

🥋 Polymorphism

Polymorphism is the ability of an object to take on many forms. It allows you to perform a single action in different ways, depending on the object that is performing the action.

🧷 Types of Polymorphism

1. Compile-Time Polymorphism (Static)

• Method Overloading - Same method name, different parameters
• Operator Overloading - Limited in Java (mainly + operator)

2. Runtime Polymorphism (Dynamic)

• Method Overriding - Subclass provides specific implementation
• Uses upcasting and dynamic dispatch

🌟 Covariant Return Types

Tip

Covariant return types allow overridden methods to return a more specific type.

class Animal {
    Animal get() { return new Animal(); }
}

class Dog extends Animal {
    Dog get() { return new Dog(); }  // ✅ More specific return type
}

🤯 Common Tricky Questions

Q: Can you have multiple main() methods?

Note

Yes, via overloading! But JVM only looks for public static void main(String[] args).

public class MultipleMain {
    public static void main(String[] args) {
        System.out.println("Main with String[] args");
    }

    public static void main(String arg) {
        System.out.println("Main with String arg");
    }

    public static void main() {
        System.out.println("Main with no args");
    }
}

Q: Can you override only the return type?

Caution

Only if it’s a subtype (covariant return). Otherwise, compile error!

class Parent {
    Number getValue() { return 0; }
}

class Child extends Parent {
    Integer getValue() { return 1; }  // ✅ Integer extends Number
}

📚 Method Overloading

Note

Method overloading occurs when there are multiple methods with the same name but different parameters.

Overloading Rules:

• Change in number of arguments
• Change in type of arguments
• Return type alone is NOT sufficient for overloading

public class Calculator {
    // Overloaded sum with different number of parameters
    public int sum(int x, int y) {
        return (x + y);
    }

    public int sum(int x, int y, int z) {
        return (x + y + z);
    }

    // Overloaded sum with different argument types
    public double sum(double x, double y) {
        return (x + y);
    }

    public static void main(String args[]) {
        Calculator calc = new Calculator();
        System.out.println(calc.sum(10, 20));      // Output: 30
        System.out.println(calc.sum(10, 20, 30)); // Output: 60
        System.out.println(calc.sum(10.5, 20.5)); // Output: 31.0
    }
}

🔧 Operator Overloading

Note

In Java, only the ”+” operator can be overloaded:

• To concatenate strings
• To add integers

class OperatorDemo {
    void operator(String str1, String str2) {
        String s = str1 + str2;
        System.out.println("Concatenated String - " + s);
    }

    void operator(int a, int b) {
        int c = a + b;
        System.out.println("Sum = " + c);
    }
}

class Main {
    public static void main(String[] args) {
        OperatorDemo obj = new OperatorDemo();
        obj.operator(2, 3);           // Output: Sum = 5
        obj.operator("Hello", "World"); // Output: Concatenated String - HelloWorld
    }
}

🔄 Method Overriding

Note

Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass.

Override Rules:

• Same method signature (name, return type, parameters)
• Same or covariant return type
• Same or broader access modifier
• Same or narrower exception specification

class Parent {
    void show() {
        System.out.println("Parent's show()");
    }
}

class Child extends Parent {
    // This method overrides show() of Parent
    @Override
    void show() {
        System.out.println("Child's show()");
    }
}

class Main {
    public static void main(String[] args) {
        Parent obj;

        // Parent reference, Parent object
        obj = new Parent();
        obj.show();  // Output: Parent's show()

        // Parent reference, Child object - RUNTIME POLYMORPHISM!
        obj = new Child();
        obj.show();  // Output: Child's show()
    }
}

Tip

This is RUN TIME POLYMORPHISM, also known as Dynamic Dispatch!

What Cannot Be Overridden:

Caution

These methods CANNOT be overridden:

• Private methods - Not accessible in subclasses
• Final methods - Explicitly marked as non-overridable
• Static methods - Can be hidden, not overridden

Exception Handling in Overriding:

Rule #1: No Exception in Superclass

class Parent {
    void m1() {
        System.out.println("From parent m1()");
    }
}

class Child extends Parent {
    @Override
    // ✅ No issue while throwing unchecked exception
    void m1() throws ArithmeticException {
        System.out.println("From child m1()");
    }

    @Override
    // ❌ Compile-time error while throwing checked exception
    void m2() throws Exception {
        System.out.println("From child m2");
    }
}

Rule #2: Exception in Superclass

class Parent {
    void m1() throws RuntimeException {
        System.out.println("From parent m1()");
    }
}

class Child1 extends Parent {
    @Override
    // ✅ No issue while throwing same exception
    void m1() throws RuntimeException {
        System.out.println("From child1 m1()");
    }
}

class Child2 extends Parent {
    @Override
    // ✅ No issue while throwing subclass exception
    void m1() throws ArithmeticException {
        System.out.println("From child2 m1()");
    }
}

class Child3 extends Parent {
    @Override
    // ✅ No issue while not throwing any exception
    void m1() {
        System.out.println("From child3 m1()");
    }
}

class Child4 extends Parent {
    @Override
    // ❌ Compile-time error while throwing parent exception
    void m1() throws Exception {
        System.out.println("From child4 m1()");
    }
}

Static Methods Cannot Be Overridden

Note

When you define a static method with the same signature as a static method in the base class, it’s called Method Hiding, not overriding.

---

💊 Encapsulation (Data Hiding)

Quote

“Encapsulation is the bundling of data and methods that operate on that data within a single unit or object, keeping it safe from outside interference and misuse.”

Encapsulation = data hiding + controlled access using getters/setters.

🎯 How to Achieve Encapsulation

1. Make variables private - Hide data from outside world
2. Provide public getters and setters - Control access to data

💻 Implementation Example

public class Person {
    // Private fields - data is hidden
    private String name;
    private int age;
    private String email;

    // Constructor
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    // Getter for name
    public String getName() {
        return name;
    }

    // Setter for name with validation
    public void setName(String newName) {
        if (newName != null && !newName.trim().isEmpty()) {
            this.name = newName.trim();
        }
    }

    // Getter for age
    public int getAge() {
        return age;
    }

    // Setter for age with validation
    public void setAge(int newAge) {
        if (newAge >= 0 && newAge <= 150) {
            this.age = newAge;
        }
    }

    // Getter for email
    public String getEmail() {
        return email;
    }

    // Setter for email with validation
    public void setEmail(String newEmail) {
        if (newEmail != null && newEmail.contains("@")) {
            this.email = newEmail;
        }
    }
}

// Using the encapsulated class
class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30, "alice@email.com");

        // Access data through controlled methods
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());

        // Modify data through controlled methods
        person.setAge(31);
        person.setEmail("alice.new@email.com");

        System.out.println("Updated Age: " + person.getAge());
        System.out.println("Updated Email: " + person.getEmail());
    }
}

✅ Benefits of Encapsulation

• Data Protection - External code cannot directly modify private data
• Flexibility & Modularity - Can change internal implementation without affecting external code
• Data Validation - Can add validation logic in setters
• Maintainability - Easier to maintain and modify code

---

🧼 Abstraction (Detail Hiding)

Quote

“Abstraction is the process of hiding the implementation details and showing only the functionality to the user.”

Abstraction = hiding implementation and exposing essential features.

🧠 Simple Analogy

Think of a car: You view it as a car with essential features (start, stop, accelerate, brake) rather than its individual components (engine, transmission, brakes).

🎯 What Abstraction Contains

• Abstract methods - Methods without implementation
• Concrete methods - Methods with implementation
• Cannot be instantiated directly

Note

In Java, abstraction is achieved by:

• Abstract classes - Can have both abstract and concrete methods
• Interfaces - Can achieve 100% abstraction

💻 Abstract Class Example

abstract class Shape {
    protected String color;

    // Constructor
    public Shape(String color) {
        this.color = color;
    }

    // Abstract method - must be implemented by subclasses
    public abstract double calculateArea();

    // Concrete method - has implementation
    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(String color, double length, double width) {
        super(color);
        this.length = length;
        this.width = width;
    }

    @Override
    public double calculateArea() {
        return length * width;
    }
}

---

🔄 Encapsulation vs Abstraction

Feature	Encapsulation	Abstraction
Purpose	Data hiding	Implementation hiding
Access	Via getters/setters	Via abstract classes/interfaces
Focus	How data is accessed	What functionalities are exposed
Level	Low-level (data)	High-level (design)

---

📘 Interfaces

Quote

“An interface is a completely abstract type that defines a contract for classes to implement.”

🔑 Key Characteristics

• All methods are implicitly public and abstract
• All fields are public static final
• Used for multiple inheritance and 100% abstraction
• A class can implement multiple interfaces
• An interface can extend multiple interfaces

🌟 Why Use Interfaces When We Have Abstract Classes?

Tip

Key differences that make interfaces valuable:

Aspect	Abstract Class	Interface
Variables	Can contain non-final variables	Variables are implicitly final, public, and static
Inheritance	A class can extend only one abstract class	A class can implement multiple interfaces
Constructor	Can have constructors	Cannot have constructors
Method Implementation	Can have concrete methods	All methods are abstract (before Java 8)

💻 Interface Example

interface Flyable {
    // public, static and final
    final int MAX_ALTITUDE = 10000;

    // public and abstract
    void fly();
    void land();
}

interface Swimmable {
    void swim();
    void dive();
}

// A class that implements multiple interfaces
class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void land() {
        System.out.println("Duck is landing");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    @Override
    public void dive() {
        System.out.println("Duck is diving");
    }

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
        System.out.println("Max altitude: " + MAX_ALTITUDE);
    }
}

Output:

Duck is flying
Duck is swimming
Max altitude: 10000

---

🧩 Quick Reference Flashcards

Concept	Summary
Inheritance	Code reuse via “is-a” relationship using extends
Overloading	Same method name, different parameters (compile-time)
Overriding	Subclass redefines superclass method (runtime)
Encapsulation	Private data + public accessors for controlled access
Abstraction	Hide implementation, show only functionality
Interface	100% abstraction, enables multiple inheritance

---