关于Object转Comparable接口的编译逻辑及方法调用疑问

Great question—let's unpack this clearly, using your merge sort implementation as context. You've hit on two key points about Java's type system and casting behavior, so let's break them down one by one.

1. What happens when the compiler handles an interface type cast? #

When you write ((Comparable) dest[j-1]), the process has two distinct phases: compile-time checking and runtime validation:

• Compile-time: The compiler only verifies if the cast is theoretically valid in Java's type system. Since Object is the parent class of all Java objects, and any class can choose to implement the Comparable interface, this cast is allowed. The compiler doesn't check whether the actual object at dest[j-1] really implements Comparable—it just confirms the cast isn't impossible.
• Runtime: When the code executes, the JVM will inspect the actual type of the object referenced by dest[j-1]. If that object's class implements Comparable, the cast succeeds, and you get a Comparable-typed reference to the object. If not, the JVM throws a ClassCastException right away.

This means your merge sort code has an implicit requirement: all elements in the src and dest arrays must be instances of classes that implement Comparable (like String, Integer, or your own custom classes with a compareTo implementation). Passing an array of non-Comparable objects will crash the code at runtime.

2. Why can we call compareTo on an Object reference after casting? #

You’re correct that Object doesn’t define compareTo, and Comparable only contains an abstract method—here’s the breakdown:

• After casting to Comparable, the compiler treats the reference as a Comparable type, not an Object. So it allows you to call compareTo because that method is part of the Comparable interface’s contract.
• At runtime, the JVM doesn’t call the abstract interface method (which can’t be executed directly). Instead, it calls the concrete compareTo implementation provided by the actual object’s class. Remember: interfaces can’t be instantiated, so any Comparable reference must point to an object of a class that implements Comparable (and thus provides a working compareTo method).

In short, the cast tells the compiler "trust me, this object implements Comparable—let me call its compareTo method", and the JVM validates that trust at runtime. If the object doesn’t implement the interface, you get an exception; if it does, the JVM routes the call to the object’s actual compareTo logic.

A quick side note on modern Java practices #

This casting approach is a bit outdated. Modern Java would use generics to enforce type safety at compile time, like:

private static <T extends Comparable<T>> void mergeSort(T[] src, T[] dest, int low, int high)

This way, you can’t even pass an array of non-Comparable objects without getting a compile error, avoiding runtime surprises entirely.

内容的提问来源于stack exchange，提问作者Gaetano de Gennaro