Learn Java Programming

// Interface defines WHAT, not HOW
interface Payable {
    double calculatePay();       // abstract method
    String getPaymentMethod();   // abstract method
}

interface Taxable {
    double calculateTax();
    default double getNetPay(double gross) {  // default method (Java 8+)
        return gross - calculateTax();
    }
}

// A class can implement MULTIPLE interfaces
class Employee implements Payable, Taxable {
    private String name;
    private double salary;

    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    @Override
    public double calculatePay() { return salary; }

    @Override
    public String getPaymentMethod() { return "Direct Deposit"; }

    @Override
    public double calculateTax() { return salary * 0.30; }
}

// Type against the interface for flexibility
Payable emp = new Employee("Alice", 5000);
System.out.println(emp.calculatePay());  // 5000.0

interface Logger {
    void log(String message);  // abstract — must implement

    // Default method — provides shared implementation
    default void info(String msg) { log("[INFO] " + msg); }
    default void warn(String msg) { log("[WARN] " + msg); }
    default void error(String msg) { log("[ERROR] " + msg); }

    // Static method — called on the interface itself
    static Logger consoleLogger() {
        return msg -> System.out.println(msg);  // lambda!
    }
}

class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // Write to file...
        System.out.println("FILE: " + message);
    }
    // info(), warn(), error() are inherited from default methods
}

Logger logger = Logger.consoleLogger();  // static factory
logger.info("Application started");     // [INFO] Application started

Logger fileLogger = new FileLogger();
fileLogger.error("Disk full");          // FILE: [ERROR] Disk full

import java.util.*;
import java.util.function.*;

// Functional interface = exactly ONE abstract method
@FunctionalInterface
interface Transformer<T> {
    T transform(T input);
}

// Use with lambda expressions
Transformer<String> shout = s -> s.toUpperCase() + "!";
System.out.println(shout.transform("hello"));  // HELLO!

// Built-in functional interfaces
Predicate<Integer> isEven = n -> n % 2 == 0;
Function<String, Integer> toLength = String::length;
Consumer<String> printer = System.out::println;
Supplier<Double> random = Math::random;

// Using with collections
List<String> names = List.of("Alice", "Bob", "Charlie");
names.stream()
    .filter(n -> n.length() > 3)       // Predicate
    .map(String::toUpperCase)            // Function
    .forEach(System.out::println);       // Consumer
// ALICE, CHARLIE

// Sealed interface restricts which classes can implement it
sealed interface Shape permits Circle, Square, Triangle {}

record Circle(double radius) implements Shape {}
record Square(double side) implements Shape {}
record Triangle(double base, double height) implements Shape {}

// Exhaustive pattern matching (Java 21+)
double area(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius() * c.radius();
        case Square s -> s.side() * s.side();
        case Triangle t -> 0.5 * t.base() * t.height();
        // No default needed — compiler verifies all cases!
    };
}