Kelas Utiliti dan Kaedah Kilang Statik

final class StringUtils {
    // Private constructor prevents instantiation
    private StringUtils() {
        throw new UnsupportedOperationException("Utility class");
    }

    public static boolean isBlank(String s) {
        return s == null || s.strip().isEmpty();
    }

    public static String capitalize(String s) {
        if (isBlank(s)) return s;
        return Character.toUpperCase(s.charAt(0)) + s.substring(1).toLowerCase();
    }
}

System.out.println(StringUtils.isBlank("  ")); // true
System.out.println(StringUtils.capitalize("hELLO")); // Hello

import java.util.*;

List<Integer> nums = new ArrayList<>(Arrays.asList(5, 2, 8, 1, 9, 3));

Collections.sort(nums);
System.out.println(nums); // [1, 2, 3, 5, 8, 9]

System.out.println(Collections.min(nums)); // 1
System.out.println(Collections.max(nums)); // 9

Collections.shuffle(nums); // random order

int[] arr = {3, 1, 4, 1, 5};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr)); // [1, 1, 3, 4, 5]
System.out.println(Arrays.binarySearch(arr, 4)); // 3 (index)

class Connection {
    private final String host;
    private final int port;
    private final boolean ssl;

    private Connection(String host, int port, boolean ssl) {
        this.host = host; this.port = port; this.ssl = ssl;
    }

    // Named factory methods — more expressive than constructors
    public static Connection plain(String host) {
        return new Connection(host, 80, false);
    }
    public static Connection secure(String host) {
        return new Connection(host, 443, true);
    }
}
Connection c = Connection.secure("api.example.com");
// Much clearer than: new Connection("api.example.com", 443, true)

class Color {
    private static final Map<String, Color> CACHE = new HashMap<>();

    public final int r, g, b;

    private Color(int r, int g, int b) {
        this.r = r; this.g = g; this.b = b;
    }

    public static Color of(int r, int g, int b) {
        String key = r + "," + g + "," + b;
        return CACHE.computeIfAbsent(key, k -> new Color(r, g, b));
    }

    public static final Color RED   = of(255, 0, 0);
    public static final Color GREEN = of(0, 255, 0);
    public static final Color BLUE  = of(0, 0, 255);
}
System.out.println(Color.of(255,0,0) == Color.RED); // true (cached)

// Java API examples:
Optional.of(value)               // of
LocalDate.from(temporal)         // from
Integer.valueOf(42)              // valueOf
Calendar.getInstance()           // getInstance
Array.newInstance(type, length)  // newInstance

// Your own:
HttpRequest.post("https://api.example.com/users")
ApiResponse.error(404, "Not found")
Payment.creditCard("4242...", 9999, "USD")

interface Validator<T> {
    boolean validate(T value);
    String errorMessage();
}

class EmailValidator implements Validator<String> {
    public boolean validate(String email) { return email.contains("@"); }
    public String errorMessage() { return "Invalid email address"; }
}

class Validators {
    // Returns interface type — hides implementation
    public static Validator<String> email() { return new EmailValidator(); }
    public static Validator<String> notBlank() {
        return new Validator<>() {
            public boolean validate(String s) { return s != null && !s.isBlank(); }
            public String errorMessage() { return "Value required"; }
        };
    }
}

class EmailMessage {
    private final String to, subject, body;
    private final boolean html;

    private EmailMessage(Builder b) {
        this.to = b.to; this.subject = b.subject;
        this.body = b.body; this.html = b.html;
    }

    public static Builder builder(String to) { return new Builder(to); }

    public static class Builder {
        private final String to;
        private String subject = "", body = "";
        private boolean html = false;

        Builder(String to) { this.to = to; }
        public Builder subject(String s) { this.subject = s; return this; }
        public Builder body(String b) { this.body = b; return this; }
        public Builder html() { this.html = true; return this; }
        public EmailMessage build() { return new EmailMessage(this); }
    }
}
EmailMessage.builder("alice@co.com").subject("Welcome!").html().build();

class PortNumber {
    private final int value;

    private PortNumber(int value) { this.value = value; }

    public static PortNumber of(int port) {
        if (port < 1 || port > 65535)
            throw new IllegalArgumentException(
                "Port must be 1-65535, got: " + port);
        return new PortNumber(port);
    }

    public static PortNumber http()  { return new PortNumber(80); }
    public static PortNumber https() { return new PortNumber(443); }

    public int value() { return value; }
    public boolean isPrivileged() { return value < 1024; }
}
System.out.println(PortNumber.https().isPrivileged()); // true

import java.util.*;

List<String> fruits = List.of("Apple", "Banana", "Cherry");
Set<Integer> ids    = Set.of(1, 2, 3, 4, 5);
Map<String, Integer> ages = Map.of("Alice", 30, "Bob", 25);

// All are unmodifiable:
try {
    fruits.add("Durian"); // UnsupportedOperationException
} catch (UnsupportedOperationException e) {
    System.out.println("Cannot modify!");
}

// Map.entry and Map.ofEntries for > 10 entries
Map<String, String> config = Map.ofEntries(
    Map.entry("host", "localhost"),
    Map.entry("port", "8080")
);

// Constructor: hard to know what this means
new Complex(0.5, -1.2);

// Factory: clear meaning
Complex.fromPolar(1.3, Math.PI / 4); // polar form
Complex.rectangular(0.5, -1.2);      // rectangular form

// Constructor: no caching
new Boolean(true); // deprecated — creates new object!

// Factory: returns cached instance (Boolean.TRUE or FALSE)
Boolean.valueOf(true); // returns Boolean.TRUE singleton