
abstract class Shape {
    abstract double area(); // Abstract method
    public void display() {
        System.out.println("This is a shape.");
    }
}
class Circle extends Shape {
    double radius;
    public Circle(double radius) { this.radius = radius; }
    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

Inheritance: A mechanism where one object acquires all the properties and behaviors of a parent object. It promotes code reusability and establishes an "is-a" relationship.


class Animal { // Parent class
    void eat() { System.out.println("Animal eats"); }
}
class Dog extends Animal { // Child class inherits from Animal
    void bark() { System.out.println("Dog barks"); }
}
// Usage: Dog myDog = new Dog(); myDog.eat(); myDog.bark();

Polymorphism: The ability of an object to take on many forms. It allows objects of different classes to be treated as objects of a common type. Achieved through method overloading (compile-time) and method overriding (runtime).
- Method Overloading (Compile-time / Static Polymorphism): Multiple methods with the same name but different parameters (number, type, or order) within the same class.


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

- Method Overriding (Runtime / Dynamic Polymorphism): A subclass provides a specific implementation for a method that is already defined in its parent class.


class Vehicle {
    void run() { System.out.println("Vehicle is running"); }
}
class Car extends Vehicle {
    @Override
    void run() { System.out.println("Car is running safely"); }
}
// Usage: Vehicle v = new Car(); v.run(); // Calls Car's run() method

6. Difference between Class and Object. Explain with code.

Class: A blueprint or a template for creating objects. It defines the properties (attributes/fields) and behaviors (methods) that objects of that class will have. It doesn't consume memory.
Object: An instance of a class. It's a real-world entity that has state (values of its properties) and behavior. Objects consume memory when created.


// Class definition
class Lamp {
    String type; // property
    boolean isOn; // property

    void turnOn() { // behavior
        isOn = true;
        System.out.println(type + " lamp is ON.");
    }
    void turnOff() { // behavior
        isOn = false;
        System.out.println(type + " lamp is OFF.");
    }
}

// Object creation and usage
public class Main {
    public static void main(String[] args) {
        Lamp ledLamp = new Lamp(); // Object 1
        ledLamp.type = "LED";
        ledLamp.turnOn(); // Calls behavior

        Lamp halogenLamp = new Lamp(); // Object 2
        halogenLamp.type = "Halogen";
        halogenLamp.turnOff(); // Calls behavior
    }
}

7. Why Java is called Object-Oriented Programming?

Java is called an Object-Oriented Programming language because it strictly adheres to the principles of OOP: Encapsulation, Abstraction, Inheritance, and Polymorphism. Everything in Java (except primitive data types) is treated as an object, and programs are designed around objects interacting with each other.

8. Write a Java program to show use of Abstract class and inheritance.


abstract class Employee {
    String name;
    int id;

    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }

    // Abstract method: salary calculation differs for different employee types
    public abstract double calculateSalary();

    // Non-abstract method
    public void displayInfo() {