Solution:

Object-Oriented Programming (OOP):

OOP is a programming paradigm that organizes software design around objects and classes rather than functions and logic. It models real-world entities as objects that have attributes (data) and behaviors (methods).

Main Principles of OOP:

1. Encapsulation:

Bundling data and methods that operate on that data within a single unit, while hiding internal implementation details.

public class Student {
    private String name;        // Encapsulated data
    private double grade;       // Hidden from outside access
    
    // Public methods to access private data
    public void setGrade(double grade) {
        if (grade >= 0 && grade <= 100) {  // Validation
            this.grade = grade;
        } else {
            System.out.println("Invalid grade!");
        }
    }
    
    public double getGrade() {
        return grade;
    }
}

2. Inheritance:

Mechanism where a new class (child/subclass) can inherit properties and methods from an existing class (parent/superclass).

// Base class
class Vehicle {
    protected String brand;
    protected int year;
    
    public void start() {
        System.out.println("Vehicle is starting...");
    }
}

// Derived class
class Car extends Vehicle {
    private int doors;
    
    public Car(String brand, int year, int doors) {
        this.brand = brand;  // Inherited from Vehicle
        this.year = year;    // Inherited from Vehicle
        this.doors = doors;
    }
    
    // Override inherited method
    public void start() {
        System.out.println("Car engine is starting...");
    }
}

3. Polymorphism:

Ability of objects of different types to be treated as objects of a common base type, with each type responding differently to the same method call.

// Method Overloading (Compile-time polymorphism)
class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

// Method Overriding (Runtime polymorphism)
class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

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

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

4. Abstraction:

Hiding complex implementation details and showing only essential features of an object.

abstract class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    // Abstract method - must be implemented by subclasses
    public abstract void makeSound();
    
    // Concrete method - can be inherited as-is
    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    public void makeSound() {
        System.out.println(name + " says: Woof!");
    }
}

Solution:

public class Rectangle {
    // Private data members (Encapsulation)
    private double length;
    private double width;
    
    // Default constructor
    public Rectangle() {
        this.length = 1.0;
        this.width = 1.0;
    }
    
    // Parameterized constructor
    public Rectangle(double length, double width) {
        setLength(length);  // Use setter for validation
        setWidth(width);    // Use setter for validation
    }
    
    // Copy constructor
    public Rectangle(Rectangle other) {
        this.length = other.length;
        this.width = other.width;
    }
    
    // Getter methods
    public double getLength() {
        return length;
    }
    
    public double getWidth() {
        return width;
    }
    
    // Setter methods with validation
    public void setLength(double length) {
        if (length > 0) {
            this.length = length;
        } else {
            System.out.println("Length must be positive!");
            this.length = 1.0;  // Set default value
        }
    }
    
    public void setWidth(double width) {
        if (width > 0) {
            this.width = width;
        } else {
            System.out.println("Width must be positive!");
            this.width = 1.0;  // Set default value
        }
    }
    
    // Method to calculate area
    public double calculateArea() {
        return length * width;
    }
    
    // Method to calculate perimeter
    public double calculatePerimeter() {
        return 2 * (length + width);
    }
    
    // Method to check if rectangle is square
    public boolean isSquare() {
        return length == width;
    }
    
    // Method to display rectangle information
    public void displayInfo() {
        System.out.println("Rectangle Information:");
        System.out.println("Length: " + length);
        System.out.println("Width: " + width);
        System.out.println("Area: " + calculateArea());
        System.out.println("Perimeter: " + calculatePerimeter());
        System.out.println("Is Square: " + isSquare());
        System.out.println("------------------------");
    }
    
    // Override toString method for easy printing
    @Override
    public String toString() {
        return String.format("Rectangle[length=%.2f, width=%.2f, area=%.2f]", 
                           length, width, calculateArea());
    }
    
    // Override equals method to compare rectangles
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        
        Rectangle rectangle = (Rectangle) obj;
        return Double.compare(rectangle.length, length) == 0 &&
               Double.compare(rectangle.width, width) == 0;
    }
    
    // Test program
    public static void main(String[] args) {
        System.out.println("=== Rectangle Class Demo ===\n");
        
        // Test default constructor
        Rectangle rect1 = new Rectangle();
        System.out.println("Rectangle 1 (default constructor):");
        rect1.displayInfo();
        
        // Test parameterized constructor
        Rectangle rect2 = new Rectangle(5.0, 3.0);
        System.out.println("Rectangle 2 (5.0 x 3.0):");
        rect2.displayInfo();
        
        // Test copy constructor
        Rectangle rect3 = new Rectangle(rect2);
        System.out.println("Rectangle 3 (copy of Rectangle 2):");
        rect3.displayInfo();
        
        // Test setters with validation
        Rectangle rect4 = new Rectangle();
        System.out.println("Rectangle 4 - Testing setters:");
        rect4.setLength(8.0);
        rect4.setWidth(8.0);  // This will make it a square
        rect4.displayInfo();
        
        // Test invalid values
        System.out.println("Testing invalid values:");
        rect4.setLength(-5.0);  // Should show error message
        rect4.setWidth(0);      // Should show error message
        rect4.displayInfo();
        
        // Test toString method
        System.out.println("Using toString():");
        System.out.println("rect2: " + rect2);
        System.out.println("rect3: " + rect3);
        
        // Test equals method
        System.out.println("\nTesting equality:");
        System.out.println("rect2.equals(rect3): " + rect2.equals(rect3));
        System.out.println("rect1.equals(rect2): " + rect1.equals(rect2));
        
        // Calculate areas for comparison
        System.out.println("\n=== Area Calculations ===");
        Rectangle[] rectangles = {rect1, rect2, rect3, rect4};
        
        double totalArea = 0;
        for (int i = 0; i < rectangles.length; i++) {
            double area = rectangles[i].calculateArea();
            System.out.printf("Rectangle %d area: %.2f\n", i + 1, area);
            totalArea += area;
        }
        System.out.printf("Total area of all rectangles: %.2f\n", totalArea);
    }
}

Solution:

Constructor Overloading:

Constructor overloading is the ability to define multiple constructors in a class with different parameter lists. Java determines which constructor to call based on the number and types of arguments passed.

Benefits:

• Provides multiple ways to initialize objects
• Increases flexibility and usability
• Allows default values for some parameters
• Makes the class more user-friendly

Practical Example - Book Class:

public class Book {
    private String title;
    private String author;
    private String isbn;
    private double price;
    private int pages;
    private String category;
    
    // Constructor 1: Default constructor
    public Book() {
        this.title = "Unknown";
        this.author = "Unknown";
        this.isbn = "000-0000000000";
        this.price = 0.0;
        this.pages = 0;
        this.category = "General";
        System.out.println("Default constructor called");
    }
    
    // Constructor 2: Title and author only
    public Book(String title, String author) {
        this.title = title;
        this.author = author;
        this.isbn = "000-0000000000";  // Default ISBN
        this.price = 19.99;            // Default price
        this.pages = 200;              // Default pages
        this.category = "General";     // Default category
        System.out.println("Constructor with title and author called");
    }
    
    // Constructor 3: Title, author, and price
    public Book(String title, String author, double price) {
        this(title, author);  // Call constructor 2 using 'this'
        this.price = price;   // Override default price
        System.out.println("Constructor with title, author, and price called");
    }
    
    // Constructor 4: Complete information
    public Book(String title, String author, String isbn, 
               double price, int pages, String category) {
        this.title = title;
        this.author = author;
        this.isbn = isbn;
        this.price = price;
        this.pages = pages;
        this.category = category;
        System.out.println("Full constructor called");
    }
    
    // Constructor 5: Copy constructor
    public Book(Book other) {
        this.title = other.title;
        this.author = other.author;
        this.isbn = other.isbn;
        this.price = other.price;
        this.pages = other.pages;
        this.category = other.category;
        System.out.println("Copy constructor called");
    }
    
    // 'this' keyword uses:
    
    // 1. To distinguish between instance variables and parameters
    public void setTitle(String title) {
        this.title = title;  // this.title refers to instance variable
    }
    
    // 2. To call other methods in the same class
    public void displayInfo() {
        this.printHeader();  // 'this' is optional here
        System.out.println("Title: " + this.title);
        System.out.println("Author: " + this.author);
        System.out.println("ISBN: " + this.isbn);
        System.out.println("Price: $" + this.price);
        System.out.println("Pages: " + this.pages);
        System.out.println("Category: " + this.category);
        this.printFooter();
    }
    
    private void printHeader() {
        System.out.println("=== Book Information ===");
    }
    
    private void printFooter() {
        System.out.println("========================");
    }
    
    // 3. To return current object (for method chaining)
    public Book setPrice(double price) {
        this.price = price;
        return this;  // Return current object
    }
    
    public Book setPages(int pages) {
        this.pages = pages;
        return this;  // Return current object
    }
    
    public Book setCategory(String category) {
        this.category = category;
        return this;  // Return current object
    }
    
    // Getters
    public String getTitle() { return title; }
    public String getAuthor() { return author; }
    public double getPrice() { return price; }
    
    // Demo program
    public static void main(String[] args) {
        System.out.println("=== Constructor Overloading Demo ===\n");
        
        // Using different constructors
        Book book1 = new Book();
        System.out.println("Book 1 created\n");
        
        Book book2 = new Book("Java Programming", "John Doe");
        System.out.println("Book 2 created\n");
        
        Book book3 = new Book("Advanced Java", "Jane Smith", 45.99);
        System.out.println("Book 3 created\n");
        
        Book book4 = new Book("Complete Java", "Bob Johnson", 
                             "978-1234567890", 59.99, 800, "Programming");
        System.out.println("Book 4 created\n");
        
        Book book5 = new Book(book4);  // Copy constructor
        System.out.println("Book 5 created (copy of Book 4)\n");
        
        // Display information
        book1.displayInfo();
        book2.displayInfo();
        book3.displayInfo();
        
        // Demonstrate method chaining with 'this'
        System.out.println("=== Method Chaining Demo ===");
        Book book6 = new Book("Learning Java", "Alice Brown")
                        .setPrice(35.99)
                        .setPages(450)
                        .setCategory("Education");
        
        book6.displayInfo();
        
        System.out.println("\n=== 'this' Keyword Summary ===");
        System.out.println("1. this.variableName - refers to instance variable");
        System.out.println("2. this(parameters) - calls another constructor");
        System.out.println("3. this.methodName() - calls instance method");
        System.out.println("4. return this - returns current object for chaining");
    }
}