Learn Java Programming

class Shape {
    protected String color;

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

    public double area() {
        return 0;  // base implementation
    }

    public String describe() {
        return color + " shape with area " + String.format("%.2f", area());
    }
}

class Circle extends Shape {
    private double radius;

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

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

class Rectangle extends Shape {
    private double width, height;

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

    @Override
    public double area() {
        return width * height;
    }
}

// Polymorphism: treat all shapes uniformly
public class Main {
    public static void main(String[] args) {
        Shape[] shapes = {
            new Circle("Red", 5),
            new Rectangle("Blue", 4, 6)
        };

        for (Shape s : shapes) {
            System.out.println(s.describe());
        }
        // Red shape with area 78.54
        // Blue shape with area 24.00
    }
}

// Cannot be instantiated — serves as a template
abstract class Animal {
    protected String name;

    public Animal(String name) { this.name = name; }

    // Abstract method — subclasses MUST implement
    public abstract String sound();

    // Concrete method — shared by all subclasses
    public void introduce() {
        System.out.println(name + " says " + sound());
    }
}

class Dog extends Animal {
    public Dog(String name) { super(name); }

    @Override
    public String sound() { return "Woof!"; }
}

class Cat extends Animal {
    public Cat(String name) { super(name); }

    @Override
    public String sound() { return "Meow!"; }
}

// Animal a = new Animal("?"); // ERROR: cannot instantiate abstract class
Animal dog = new Dog("Rex");
dog.introduce();  // Rex says Woof!

class Vehicle {
    protected String brand;
    protected int year;

    public Vehicle(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    public String info() {
        return brand + " (" + year + ")";
    }
}

class Car extends Vehicle {
    private int doors;

    public Car(String brand, int year, int doors) {
        super(brand, year);  // MUST be first statement in constructor
        this.doors = doors;
    }

    @Override
    public String info() {
        return super.info() + " - " + doors + " doors";  // call parent version
    }
}

Car car = new Car("Toyota", 2024, 4);
System.out.println(car.info());  // Toyota (2024) - 4 doors

// final class — cannot be extended
final class Constants {
    public static final double PI = 3.14159;
}
// class ExtConstants extends Constants {}  // ERROR!

// final method — cannot be overridden
class Base {
    public final void critical() { /* locked logic */ }
}

// instanceof — check type at runtime
Object obj = "Hello";
if (obj instanceof String s) {  // pattern matching (Java 16+)
    System.out.println(s.length());  // 5, already cast!
}