Java instanceof - 5% Transactions Silently Lost

package io.thecodeforge.java.operators;

public class InstanceofBasics {
    public static void main(String[] args) {
        Object text   = "Hello, Forge";
        Object number = 42;
        Object nothing = null;

        System.out.println(text   instanceof String);  // true
        System.out.println(number instanceof String);  // false
        System.out.println(nothing instanceof String); // false — null is never instanceof anything

        // Subtype check
        Number n = 3.14;
        System.out.println(n instanceof Number); // true
        System.out.println(n instanceof Double); // true — Double extends Number
        System.out.println(n instanceof Integer);// false
    }
}

package io.thecodeforge.java.operators;

public class PatternMatching {

    // Old style — before Java 16
    static String describeOld(Object obj) {
        if (obj instanceof String) {
            String s = (String) obj;  // manual cast
            return "String of length " + s.length();
        } else if (obj instanceof Integer) {
            Integer i = (Integer) obj;
            return "Integer: " + (i > 0 ? "positive" : "non-positive");
        }
        return "Unknown: " + obj.getClass().getSimpleName();
    }

    // Pattern matching — Java 16+ (binding variable declared inline)
    static String describe(Object obj) {
        if (obj instanceof String s) {
            return "String of length " + s.length();  // s is in scope here
        } else if (obj instanceof Integer i && i > 0) {
            return "Positive integer: " + i;  // can use binding var in condition
        } else if (obj instanceof Integer i) {
            return "Non-positive integer: " + i;
        }
        return "Unknown: " + obj.getClass().getSimpleName();
    }

    public static void main(String[] args) {
        System.out.println(describe("TheCodeForge"));  // String of length 12
        System.out.println(describe(42));              // Positive integer: 42
        System.out.println(describe(-5));              // Non-positive integer: -5
        System.out.println(describe(3.14));            // Unknown: Double
    }
}

package io.thecodeforge.java.operators;

import java.util.ArrayList;
import java.util.List;

public class InterfaceCheck {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        System.out.println(list instanceof List);       // true
        System.out.println(list instanceof ArrayList);  // true
        System.out.println(list instanceof Iterable);   // true — List extends Iterable

        // Useful pattern: safe processing
        Object[] items = {"hello", 42, null, new ArrayList<>()};
        for (Object item : items) {
            if (item instanceof Iterable<?> it) {
                System.out.println("Iterable found: " + it.getClass().getSimpleName());
            } else if (item instanceof String s) {
                System.out.println("String: " + s.toUpperCase());
            } else {
                System.out.println("Other: " + item);
            }
        }
    }
}

package io.thecodeforge.java.operators;

sealed interface Shape permits Circle, Rectangle {}
final class Circle implements Shape { double radius; Circle(double r) { radius = r; } }
final class Rectangle implements Shape { double w, h; Rectangle(double w, double h) { this.w=w; this.h=h; } }

public class SealedInstanceof {
    static double area(Shape s) {
        if (s instanceof Circle c) {
            return Math.PI * c.radius * c.radius;
        } else if (s instanceof Rectangle r) {
            return r.w * r.h;
        }
        // No else needed — compiler knows all cases covered
        // But it's good practice to keep for future extensibility
        throw new IllegalArgumentException("Unknown shape");
    }

    public static void main(String[] args) {
        System.out.println(area(new Circle(5)));       // 78.53981633974483
        System.out.println(area(new Rectangle(3,4)));  // 12.0
    }
}

package io.thecodeforge.java.operators;

sealed interface Animal permits Dog, Cat, Bird {}
record Dog(String name) implements Animal {}
record Cat(String name) implements Animal {}
record Bird(String name, double wingspan) implements Animal {}

public class SwitchPatternMatching {
    static String describe(Animal a) {
        return switch (a) {
            case Dog(var name) -> "Dog named " + name;
            case Cat(var name) -> "Cat named " + name;
            case Bird(var name, var ws) -> "Bird with wingspan " + ws;
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(new Dog("Rex")));     // Dog named Rex
        System.out.println(describe(new Cat("Luna")));    // Cat named Luna
        System.out.println(describe(new Bird("Tweety", 0.3))); // Bird with wingspan 0.3
    }
}