Abstract Class Example:

abstract class Animal {
    // Concrete field
    protected String name;
    protected int age;
    
    // Constructor
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Concrete method
    public void sleep() {
        System.out.println(name + " is sleeping");
    }
    
    // Abstract method (must be implemented)
    public abstract void makeSound();
    public abstract void move();
}
                            

Concrete Implementation:

class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " barks: Woof!");
    }
    
    @Override
    public void move() {
        System.out.println(name + " runs on four legs");
    }
}

public class TestAbstract {
    public static void main(String[] args) {
        // Animal animal = new Animal(); // Error!
        
        Dog dog = new Dog("Buddy", 3);
        dog.makeSound(); // Buddy barks: Woof!
        dog.move();      // Buddy runs on four legs
        dog.sleep();     // Buddy is sleeping
    }
}
                            

Interface Definition:

interface Drawable {
    // Constant (public static final)
    String TYPE = "DRAWABLE";
    
    // Abstract methods (public abstract)
    void draw();
    void resize(double factor);
}

interface Movable {
    void move(int x, int y);
    void rotate(double angle);
}

interface Printable {
    void print();
    boolean canPrint();
}
                            

Interface Implementation:

class Rectangle implements Drawable, Movable {
    private int x, y, width, height;
    
    public Rectangle(int x, int y, int w, int h) {
        this.x = x; this.y = y;
        this.width = w; this.height = h;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing rectangle at (" 
            + x + "," + y + ")");
    }
    
    @Override
    public void resize(double factor) {
        width *= factor;
        height *= factor;
    }
    
    @Override
    public void move(int newX, int newY) {
        this.x = newX;
        this.y = newY;
    }
    
    @Override
    public void rotate(double angle) {
        System.out.println("Rotating by " + angle);
    }
}
                            

Multiple Interfaces:

interface Flyable {
    void fly();
    double getAltitude();
}

interface Swimmable {
    void swim();
    double getDepth();
}

class Duck implements Flyable, Swimmable {
    private double altitude = 0;
    private double depth = 0;
    
    @Override
    public void fly() {
        altitude = 100;
        System.out.println("Duck is flying");
    }
    
    @Override
    public double getAltitude() {
        return altitude;
    }
    
    @Override
    public void swim() {
        depth = 5;
        System.out.println("Duck is swimming");
    }
    
    @Override
    public double getDepth() {
        return depth;
    }
    
    public void walk() {
        System.out.println("Duck is walking");
    }
}
                            

Interface Inheritance:

interface Vehicle {
    void start();
    void stop();
}

interface LandVehicle extends Vehicle {
    void accelerate();
    void brake();
}

interface WaterVehicle extends Vehicle {
    void sail();
    void anchor();
}

// Multiple interface inheritance
interface AmphibiousVehicle 
    extends LandVehicle, WaterVehicle {
    void switchToLandMode();
    void switchToWaterMode();
}

class AmphibiousCar 
    implements AmphibiousVehicle {
    
    @Override
    public void start() {
        System.out.println("Engine started");
    }
    
    @Override
    public void stop() {
        System.out.println("Engine stopped");
    }
    
    // Implement all other methods...
}
                            

Interface with Default Methods:

interface Calculator {
    // Abstract methods
    double add(double a, double b);
    double subtract(double a, double b);
    
    // Default methods
    default double multiply(double a, double b) {
        return a * b;
    }
    
    default double divide(double a, double b) {
        if (b == 0) {
            throw new ArithmeticException("Division by zero");
        }
        return a / b;
    }
    
    default void printResult(double result) {
        System.out.println("Result: " + result);
    }
}
                            

Implementation:

class BasicCalculator implements Calculator {
    @Override
    public double add(double a, double b) {
        return a + b;
    }
    
    @Override
    public double subtract(double a, double b) {
        return a - b;
    }
    
    // Can override default methods if needed
    @Override
    public void printResult(double result) {
        System.out.println("Calculation result: " + result);
    }
    
    // multiply() and divide() are inherited
}

public class TestDefault {
    public static void main(String[] args) {
        Calculator calc = new BasicCalculator();
        
        double sum = calc.add(10, 5);
        calc.printResult(sum); // Uses overridden method
        
        double product = calc.multiply(4, 3);
        calc.printResult(product); // Uses default method
    }
}
                            

Interface with Static Methods:

interface MathUtils {
    // Static constants
    double PI = 3.14159;
    double E = 2.71828;
    
    // Abstract method
    double calculate();
    
    // Static methods
    static double square(double x) {
        return x * x;
    }
    
    static double cube(double x) {
        return x * x * x;
    }
    
    static double power(double base, double exp) {
        return Math.pow(base, exp);
    }
    
    static boolean isEven(int num) {
        return num % 2 == 0;
    }
    
    static boolean isPrime(int num) {
        if (num < 2) return false;
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) return false;
        }
        return true;
    }
}
                            

Using Static Methods:

class NumberProcessor implements MathUtils {
    private double value;
    
    public NumberProcessor(double value) {
        this.value = value;
    }
    
    @Override
    public double calculate() {
        return MathUtils.square(value);
    }
}

public class TestStatic {
    public static void main(String[] args) {
        // Call static methods directly
        double result1 = MathUtils.square(5);
        double result2 = MathUtils.cube(3);
        
        System.out.println("5² = " + result1);
        System.out.println("3³ = " + result2);
        
        // Check if numbers are prime
        System.out.println("Is 17 prime? " + 
            MathUtils.isPrime(17));
        System.out.println("Is 20 even? " + 
            MathUtils.isEven(20));
        
        // Use with implementing class
        NumberProcessor processor = 
            new NumberProcessor(4);
        System.out.println("Calculated: " + 
            processor.calculate());
    }
}
                            

Abstract Classes:

• Partial implementation with abstract methods
• Cannot be instantiated
• Support constructors and instance variables
• Single inheritance only
• Mix of abstract and concrete methods

Interfaces:

• Pure contracts with method signatures
• Support multiple inheritance
• Default and static methods (Java 8+)
• All fields are constants
• Achieve loose coupling