Type Casting — Senior Level¶

// Source
Dog d = (Dog) animal;

// Bytecode
aload_1          // push 'animal' onto stack
checkcast Dog    // verify type, throw ClassCastException if wrong
astore_2         // store as 'Dog d'

if (obj instanceof String) {
    String s = (String) obj; // JIT knows this always succeeds — eliminates checkcast
    s.length();              // JIT devirtualizes — inlines String.length()
}

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 10, time = 1)
public class CastBenchmark {
    private Object obj = "test";

    @Benchmark
    public int instanceofThenCast() {
        if (obj instanceof String s) {
            return s.length();
        }
        return 0;
    }

    @Benchmark
    public int directCast() {
        return ((String) obj).length();
    }

    @Benchmark
    public int classCast() {
        return String.class.cast(obj).length();
    }
}

import java.util.HashMap;
import java.util.Map;

public class Main {
    static class TypeSafeMap {
        private final Map<Class<?>, Object> store = new HashMap<>();

        public <T> void put(Class<T> type, T value) {
            store.put(type, type.cast(value)); // Runtime type check
        }

        public <T> T get(Class<T> type) {
            return type.cast(store.get(type)); // Safe cast via Class token
        }

        // Bounded type token — restrict to Number subtypes
        public <T extends Number> T getNumber(Class<T> type) {
            Object value = store.get(type);
            if (value == null) return null;
            return type.cast(value);
        }
    }

    public static void main(String[] args) {
        TypeSafeMap map = new TypeSafeMap();
        map.put(String.class, "hello");
        map.put(Integer.class, 42);
        map.put(Double.class, 3.14);

        String s = map.get(String.class);     // No explicit cast
        Integer i = map.get(Integer.class);   // Compile-time safe
        Double d = map.getNumber(Double.class);

        System.out.println(s + ", " + i + ", " + d);
    }
}

public class Main {
    sealed interface Expression permits Literal, Add, Multiply, Negate {}
    record Literal(double value) implements Expression {}
    record Add(Expression left, Expression right) implements Expression {}
    record Multiply(Expression left, Expression right) implements Expression {}
    record Negate(Expression operand) implements Expression {}

    static double evaluate(Expression expr) {
        return switch (expr) {
            case Literal l   -> l.value();
            case Add a       -> evaluate(a.left()) + evaluate(a.right());
            case Multiply m  -> evaluate(m.left()) * evaluate(m.right());
            case Negate n    -> -evaluate(n.operand());
            // No default needed — sealed ensures exhaustiveness
        };
    }

    static String prettyPrint(Expression expr) {
        return switch (expr) {
            case Literal l   -> String.valueOf(l.value());
            case Add a       -> "(" + prettyPrint(a.left()) + " + " + prettyPrint(a.right()) + ")";
            case Multiply m  -> "(" + prettyPrint(m.left()) + " * " + prettyPrint(m.right()) + ")";
            case Negate n    -> "(-" + prettyPrint(n.operand()) + ")";
        };
    }

    public static void main(String[] args) {
        // (3 + 4) * (-2)
        Expression expr = new Multiply(
            new Add(new Literal(3), new Literal(4)),
            new Negate(new Literal(2))
        );

        System.out.println(prettyPrint(expr) + " = " + evaluate(expr));
        // Output: ((3.0 + 4.0) * (-2.0)) = -14.0
    }
}

public class Main {
    interface Node { void accept(NodeVisitor v); }
    record TextNode(String text) implements Node {
        public void accept(NodeVisitor v) { v.visit(this); }
    }
    record ImageNode(String url) implements Node {
        public void accept(NodeVisitor v) { v.visit(this); }
    }

    interface NodeVisitor {
        void visit(TextNode node);
        void visit(ImageNode node);
    }

    static class HtmlRenderer implements NodeVisitor {
        public void visit(TextNode node) {
            System.out.println("<p>" + node.text() + "</p>");
        }
        public void visit(ImageNode node) {
            System.out.println("<img src=\"" + node.url() + "\">");
        }
    }

    public static void main(String[] args) {
        Node[] nodes = { new TextNode("Hello"), new ImageNode("photo.jpg") };
        HtmlRenderer renderer = new HtmlRenderer();
        for (Node node : nodes) {
            node.accept(renderer); // No casting needed!
        }
    }
}

import java.util.HashMap;
import java.util.Map;

public class Main {
    interface Event {}
    record OrderEvent(String orderId) implements Event {}
    record PaymentEvent(double amount) implements Event {}

    interface EventHandler<T extends Event> {
        void handle(T event);
    }

    static class EventRegistry {
        private final Map<Class<?>, EventHandler<?>> handlers = new HashMap<>();

        @SuppressWarnings("unchecked")
        public <T extends Event> void register(Class<T> type, EventHandler<T> handler) {
            handlers.put(type, handler);
        }

        @SuppressWarnings("unchecked")
        public <T extends Event> void dispatch(T event) {
            EventHandler<T> handler = (EventHandler<T>) handlers.get(event.getClass());
            if (handler != null) {
                handler.handle(event); // Type-safe despite the unchecked cast
            }
        }
    }

    public static void main(String[] args) {
        EventRegistry registry = new EventRegistry();
        registry.register(OrderEvent.class, e -> System.out.println("Order: " + e.orderId()));
        registry.register(PaymentEvent.class, e -> System.out.printf("Payment: $%.2f%n", e.amount()));

        registry.dispatch(new OrderEvent("ORD-001"));
        registry.dispatch(new PaymentEvent(49.99));
    }
}

public class Main {
    // Pipeline stages use specific types — zero casting needed
    record RawRecord(String line) {}
    record ParsedRecord(String name, int age, double salary) {}
    record EnrichedRecord(String name, int age, double salary, String department) {}

    static ParsedRecord parse(RawRecord raw) {
        String[] parts = raw.line().split(",");
        return new ParsedRecord(parts[0], Integer.parseInt(parts[1]), Double.parseDouble(parts[2]));
    }

    static EnrichedRecord enrich(ParsedRecord parsed) {
        String dept = parsed.salary() > 80000 ? "Senior" : "Junior";
        return new EnrichedRecord(parsed.name(), parsed.age(), parsed.salary(), dept);
    }

    public static void main(String[] args) {
        var records = java.util.List.of(
            new RawRecord("Alice,30,95000"),
            new RawRecord("Bob,25,60000")
        );

        records.stream()
            .map(Main::parse)
            .map(Main::enrich)
            .forEach(r -> System.out.printf("%s (%s): $%.0f%n", r.name(), r.department(), r.salary()));
    }
}

public class Main {
    abstract static class ConversionException extends RuntimeException {
        private final String errorCode;
        ConversionException(String message, String errorCode) {
            super(message);
            this.errorCode = errorCode;
        }
        String getErrorCode() { return errorCode; }
    }

    static class TypeMismatchException extends ConversionException {
        TypeMismatchException(Class<?> expected, Class<?> actual) {
            super("Expected " + expected.getSimpleName() + " but got " + actual.getSimpleName(),
                  "TYPE_MISMATCH");
        }
    }

    static class NumericOverflowException extends ConversionException {
        NumericOverflowException(long value, String targetType) {
            super("Value " + value + " overflows " + targetType, "NUMERIC_OVERFLOW");
        }
    }

    @SuppressWarnings("unchecked")
    static <T> T convert(Object obj, Class<T> targetType) {
        if (obj == null) return null;
        if (targetType.isInstance(obj)) return targetType.cast(obj);

        // Handle numeric conversions
        if (obj instanceof Number num && Number.class.isAssignableFrom(targetType)) {
            if (targetType == Integer.class) {
                long val = num.longValue();
                if (val < Integer.MIN_VALUE || val > Integer.MAX_VALUE) {
                    throw new NumericOverflowException(val, "Integer");
                }
                return (T) Integer.valueOf((int) val);
            }
            if (targetType == Long.class) return (T) Long.valueOf(num.longValue());
            if (targetType == Double.class) return (T) Double.valueOf(num.doubleValue());
        }
        throw new TypeMismatchException(targetType, obj.getClass());
    }

    public static void main(String[] args) {
        System.out.println(convert("hello", String.class));
        System.out.println(convert(42L, Integer.class));
        try {
            convert(Long.MAX_VALUE, Integer.class);
        } catch (NumericOverflowException e) {
            System.out.println("Caught: " + e.getMessage() + " [" + e.getErrorCode() + "]");
        }
    }
}

// ❌ Vulnerable — ObjectInputStream deserializes arbitrary types
ObjectInputStream ois = new ObjectInputStream(untrustedInput);
Object obj = ois.readObject();
Command cmd = (Command) obj; // The cast is not the problem — deserialization already executed gadgets

// ✅ Secure — use JSON deserialization with explicit type binding
ObjectMapper mapper = new ObjectMapper();
mapper.activateDefaultTyping(
    mapper.getPolymorphicTypeValidator(),
    ObjectMapper.DefaultTyping.NON_FINAL
);
// Or better: avoid polymorphic deserialization entirely
Command cmd = mapper.readValue(input, Command.class);

// ❌ Slow — megamorphic: 5+ types through one call site
void processAll(List<Shape> shapes) {
    for (Shape s : shapes) {
        s.area(); // JIT cannot inline — too many types
    }
}

// ✅ Fast — partition by type, creating monomorphic call sites
void processAll(List<Shape> shapes) {
    List<Circle> circles = new ArrayList<>();
    List<Rectangle> rectangles = new ArrayList<>();
    for (Shape s : shapes) {
        if (s instanceof Circle c) circles.add(c);
        else if (s instanceof Rectangle r) rectangles.add(r);
    }
    for (Circle c : circles) c.area();     // Monomorphic — inlined
    for (Rectangle r : rectangles) r.area(); // Monomorphic — inlined
}

// ❌ Slow — autoboxing in stream pipeline
long sum = numbers.stream()
    .map(Number::intValue)      // Returns Integer (boxing)
    .reduce(0, Integer::sum);   // More boxing

// ✅ Fast — use primitive streams
long sum = numbers.stream()
    .mapToInt(Number::intValue)  // IntStream — no boxing
    .sum();

// ❌ Cannot create generic array directly
// String[] arr = new T[10]; // Compilation error

// Workaround with unchecked cast
@SuppressWarnings("unchecked")
public static <T> T[] createArray(Class<T> type, int size) {
    return (T[]) java.lang.reflect.Array.newInstance(type, size);
}

class Holder<T> {
    T value;
    void set(T value) { this.value = value; }
    T get() { return value; }
}

class StringHolder extends Holder<String> {
    // Compiler generates bridge method:
    // Object get() { return get(); } // → checkcast String in caller
    // void set(Object value) { set((String) value); } // → ClassCastException if non-String
}

// ❌ Unsafe — type parameter T is erased
@SuppressWarnings("unchecked")
public <T> T deserialize(byte[] data) {
    return (T) objectMapper.readValue(data, Object.class);
    // Cast always "succeeds" at bytecode level — fails when caller uses result
}

// ✅ Safe — pass Class<T> token for runtime type check
public <T> T deserialize(byte[] data, Class<T> type) {
    return objectMapper.readValue(data, type); // Jackson performs the cast safely
}

public class Main {
    interface Printable { void print(); }
    interface Serializable { }

    static <T extends Printable & java.io.Serializable> void process(T item) {
        item.print();
        // item is both Printable AND Serializable — intersection type
    }

    static class Document implements Printable, java.io.Serializable {
        public void print() { System.out.println("Document printed"); }
    }

    public static void main(String[] args) {
        process(new Document()); // OK — Document satisfies both bounds

        // Lambda with intersection cast
        Runnable r = (Runnable & java.io.Serializable) () -> System.out.println("Serializable lambda");
        System.out.println(r instanceof java.io.Serializable); // true
    }
}

public class Main {
    public static void main(String[] args) {
        Object[] objects = new String[3];
        objects[0] = "hello";
        objects[1] = 42; // What happens here?
    }
}

interface Shape { double area(); }
record Circle(double r) implements Shape { public double area() { return Math.PI*r*r; } }
record Rect(double w, double h) implements Shape { public double area() { return w*h; } }
record Triangle(double b, double h) implements Shape { public double area() { return 0.5*b*h; } }
record Pentagon(double s) implements Shape { public double area() { return 1.72*s*s; } }

// Hot loop with 4 types
for (Shape s : shapes) { total += s.area(); }