Type Casting, instanceof & Type Checking in Java

Dog dog = new Dog("Rex");
Animal animal = dog;          // implicit upcast — always safe
Object obj = animal;          // another implicit upcast

// The reference type changes, but the actual object is still a Dog
System.out.println(animal.getClass());  // class Dog

// 1. Method parameters
void feed(Animal a) { ... }
feed(new Dog("Rex"));  // Dog → Animal (implicit)

// 2. Collections
List<Animal> animals = new ArrayList<>();
animals.add(new Dog("Rex"));  // Dog → Animal (implicit)
animals.add(new Cat("Whiskers"));

// 3. Return types
Animal adopt() {
    return new Dog("Buddy");  // Dog → Animal (implicit)
}

Animal animal = new Dog("Rex");

// ✅ Works — the actual object IS a Dog
Dog dog = (Dog) animal;
dog.fetch();

// ❌ ClassCastException at runtime!
Animal animal2 = new Cat("Whiskers");
Dog dog2 = (Dog) animal2;  // compiles fine, EXPLODES at runtime

// ✅ Safe pattern — check before cast
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.fetch();
}

// ✅ Even better — Java 16+ pattern matching
if (animal instanceof Dog dog) {
    dog.fetch();  // already cast and scoped
}

byte → short → int → long → float → double
char → int → long → float → double

int x = 42;
long y = x;      // implicit widening — no data loss
double z = x;    // implicit widening — int to double

double pi = 3.14159;
int truncated = (int) pi;       // 3 — fractional part lost!

long big = 130L;
byte small = (byte) big;        // -126 — overflow wraps around!

int millions = 16_777_217;
float approx = millions;        // 16777216.0 — precision loss (implicit but lossy!)

Animal animal = getAnimal();

animal instanceof Dog      // true if animal IS a Dog (or subclass of Dog)
animal instanceof Animal   // always true (Dog IS-A Animal)
animal instanceof Object   // always true (everything IS-A Object)
null instanceof Dog        // always false — null is never an instance of anything

// ❌ Old way — check then cast (redundant)
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// ✅ New way — pattern variable (check + cast + scope in one)
if (obj instanceof String s) {
    System.out.println(s.length());  // s is already cast
}

// Works with && (short-circuit guarantees safety)
if (obj instanceof String s && s.length() > 5) {
    process(s);
}

// ❌ Does NOT work with || (s might not be assigned)
// if (obj instanceof String s || s.isEmpty()) { }  // COMPILE ERROR

static String describe(Object obj) {
    return switch (obj) {
        case Integer i when i > 0  -> "Positive int: " + i;
        case Integer i             -> "Non-positive int: " + i;
        case String s when s.isBlank() -> "Blank string";
        case String s              -> "String: " + s;
        case null                  -> "null";
        default                    -> "Unknown: " + obj.getClass();
    };
}

// The JVM checks: "Is the actual object assignable to the target type?"
Object obj = "hello";
Integer num = (Integer) obj;  // ClassCastException: String cannot be cast to Integer

// 1. Always check first
if (event instanceof PaymentEvent pe) {
    processPayment(pe);
} else if (event instanceof PromoEvent promo) {
    processPromo(promo);
}

// 2. Use polymorphism instead of casting
event.process();  // let the subclass decide behavior

// 3. Use generics to catch at compile time
Queue<PaymentEvent> paymentQueue = new LinkedList<>();  // type-safe

class Dog extends Animal { }
interface Flyable { void fly(); }

Dog dog = new Dog();
Flyable f = (Flyable) dog;  // Compiles! (Dog could have a subclass that implements Flyable)
                             // But throws ClassCastException at runtime

// With final class — compiler CAN reject:
final class Rock { }
Rock rock = new Rock();
// Flyable f2 = (Flyable) rock;  // COMPILE ERROR — Rock is final, can never implement Flyable

// At runtime, List<String> and List<Integer> are both just "List"
List<String> strings = new ArrayList<>();
List rawList = strings;               // warning: raw type
List<Integer> integers = rawList;     // warning: unchecked cast — compiles!
integers.add(42);                     // works at runtime (erasure removes checks)

String s = strings.get(0);           // ClassCastException! (it's actually an Integer)

// ❌ Compiler warns: "unchecked cast"
Object obj = getFromCache();

@SuppressWarnings("unchecked")           // Only suppress if you're SURE
Map<String, List<Integer>> map = (Map<String, List<Integer>>) obj;

// ✅ Better: use Class token for type-safe casting
public <T> T getFromCache(String key, Class<T> type) {
    Object value = cache.get(key);
    return type.cast(value);  // ClassCastException with clear message if wrong type
}

// ❌ Cannot check generic type at runtime (erasure)
if (list instanceof List<String>) { }  // COMPILE ERROR

// ✅ Can check raw type only
if (list instanceof List<?>) { }       // OK but tells you nothing about element type

// ✅ Check elements individually
if (list.stream().allMatch(e -> e instanceof String)) {
    @SuppressWarnings("unchecked")
    List<String> strings = (List<String>) list;
}

// When (Type) cast shines — everyday code
Dog dog = (Dog) animal;

// When Class.cast() shines — generic/reflective code
public <T> T deserialize(byte[] data, Class<T> type) {
    Object obj = objectMapper.readValue(data, type);
    return type.cast(obj);  // type-safe, no unchecked warning
}

// instanceof — inheritance-aware
Dog rex = new GoldenRetriever();
rex instanceof Dog;              // true
rex instanceof Animal;           // true
rex instanceof GoldenRetriever;  // true

// getClass() — exact match only
rex.getClass() == Dog.class;              // false! it's a GoldenRetriever
rex.getClass() == GoldenRetriever.class;  // true

// Option A: instanceof (Liskov-friendly, allows subclass equality)
@Override
public boolean equals(Object o) {
    if (!(o instanceof Point p)) return false;
    return x == p.x && y == p.y;
}

// Option B: getClass() (strict, subclasses are never equal to parent)
@Override
public boolean equals(Object o) {
    if (o == null || getClass() != o.getClass()) return false;
    Point p = (Point) o;
    return x == p.x && y == p.y;
}

// ❌ Before Java 8 — compiler couldn't always infer
List<String> list = Collections.emptyList();           // works
void process(List<String> items) { }
process(Collections.emptyList());                      // ❌ might not compile in Java 7

// ✅ Type witness to the rescue
process(Collections.<String>emptyList());              // explicit type witness

// Modern Java (8+) — inference is smarter, rarely needed
process(Collections.emptyList());                      // ✅ works now (target type inference)

// Chained method calls where inference breaks
Optional.<List<String>>empty().orElse(new ArrayList<>());

// When the compiler can't infer from context
var map = Collections.<String, List<Integer>>emptyMap();  // var needs help

// ❌ BAD — "type switch" smell (violates Open/Closed Principle)
void processShape(Shape shape) {
    if (shape instanceof Circle c) {
        drawCircle(c);
    } else if (shape instanceof Rectangle r) {
        drawRectangle(r);
    } else if (shape instanceof Triangle t) {
        drawTriangle(t);
    }
    // Adding a new shape requires modifying THIS code
}

// ✅ GOOD — each shape knows how to draw itself
interface Shape {
    void draw();
}

class Circle implements Shape {
    @Override public void draw() { /* circle logic */ }
}

// Now: shape.draw() — no instanceof needed, and new shapes don't break existing code

// ✅ Sealed classes + pattern matching — the modern approach
sealed interface Shape permits Circle, Rectangle, Triangle {}

String describe(Shape shape) {
    return switch (shape) {  // compiler verifies exhaustiveness!
        case Circle c    -> "Circle(r=" + c.radius() + ")";
        case Rectangle r -> "Rect(" + r.w() + "x" + r.h() + ")";
        case Triangle t  -> "Triangle(base=" + t.base() + ")";
    };
}

// Kafka consumer receiving mixed event types
void onMessage(ConsumerRecord<String, Event> record) {
    Event event = record.value();
    switch (event) {
        case OrderCreated e   -> orderService.handle(e);
        case PaymentReceived e -> paymentService.handle(e);
        case ShipmentSent e   -> shippingService.handle(e);
        default -> log.warn("Unknown event type: {}", event.getClass());
    }
}

// Spring wraps beans in proxies (AOP, @Transactional)
// Direct cast to implementation class will FAIL

// ❌ Fails — proxy is not the actual class
MyServiceImpl impl = (MyServiceImpl) applicationContext.getBean("myService");

// ✅ Use interface reference
MyService service = applicationContext.getBean(MyService.class);

// ✅ Or unwrap the proxy
if (AopUtils.isAopProxy(bean)) {
    Object target = ((Advised) bean).getTargetSource().getTarget();
    MyServiceImpl impl = (MyServiceImpl) target;
}

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes({
    @JsonSubTypes.Type(value = CircleDTO.class, name = "circle"),
    @JsonSubTypes.Type(value = RectDTO.class, name = "rectangle")
})
public abstract class ShapeDTO { }

// Jackson handles casting internally — you get the correct subtype
ShapeDTO shape = objectMapper.readValue(json, ShapeDTO.class);
if (shape instanceof CircleDTO circle) {
    System.out.println("Radius: " + circle.getRadius());
}