OOPs Principles

Short Answer:
OOPs (Object-Oriented Programming) principles are the core concepts used to design software using objects. The four main principles are Encapsulation, Abstraction, Inheritance, and Polymorphism.

Detailed Explanation:
OOPs helps in writing modular, reusable, and maintainable code. The four main principles are:

1. Encapsulation

Short: Binding data and methods together and restricting direct access.

Encapsulation is achieved using private variables and public getter/setter methods.

Example:

class Student {
    private int age;

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

    public int getAge() {
        return age;
    }
}

2. Abstraction

Short: Hiding internal implementation and showing only essential details.

Abstraction is achieved using abstract classes and interfaces.

Example:

abstract class Vehicle {
    abstract void start();
}

3. Inheritance

Short: Acquiring properties and behavior from another class.

Inheritance promotes code reuse using the extends keyword.

Example:

class Animal {
    void eat() {
        System.out.println("Eating...");
    }
}

class Dog extends Animal {
}

4. Polymorphism

Short: One method behaving differently in different situations.

Polymorphism can be:

• Compile-time (Method Overloading)
• Runtime (Method Overriding)

Example:

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

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

1. Difference between Abstract Class and Interface

Short Answer:
Abstract class can have both abstract and concrete methods, while interface mainly contains abstract methods (until Java 8).

Detailed Explanation:

Example:

abstract class Vehicle {
    abstract void start();
}

interface Engine {
    void stop();
}

2. Difference between Overloading and Overriding

Short Answer:
Overloading = Same method name, different parameters. Overriding = Same method signature in parent and child class.

Detailed Explanation:

Example:

// Overloading
int add(int a, int b) { return a+b; }
int add(int a, int b, int c) { return a+b+c; }

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

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

3. Explain OOPs Principles with Examples

Short Answer:
OOPs has four principles: Encapsulation, Abstraction, Inheritance, and Polymorphism.

Detailed Explanation:

• Encapsulation: Hiding data using private variables.
• Abstraction: Hiding implementation details.
• Inheritance: Acquiring properties of parent class.
• Polymorphism: One method, multiple behaviors.

Example:

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

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

4. Why do we need Abstraction?

Short Answer:
Abstraction hides internal implementation and shows only necessary functionality.

It improves security, reduces complexity, and increases maintainability. Example: When you drive a car, you use steering and pedals without knowing engine internals.

Example:

interface Payment {
    void pay();
}

5. Can Java support Multiple Inheritance?

Short Answer:
Java does not support multiple inheritance with classes but supports it through interfaces.

Multiple inheritance with classes can cause ambiguity (Diamond Problem). Java avoids this by allowing multiple interfaces instead.

Example:

interface A { void show(); }
interface B { void display(); }

class Test implements A, B {
    public void show() {}
    public void display() {}
}