The key to the security of Java type conversion is to match the inheritance relationship and the actual object, and the upward transformation is automatic and safe; the downward transformation requires explicit and instanceof inspection; generics are unreliable due to type erasure; and the interface and implementation classes can be converted.

The Java type system is designed relatively strictly, with the purpose of discovering type errors as much as possible during the compilation period. However, in actual development, we still often need to do type conversion. At this time, "safe type conversion" and "type compatibility" have become issues that must be paid attention to.

This article directly talks about the key point: casting is safe only when two classes have an inheritance relationship and the actual object is an instance of the target type . Otherwise, ClassCastException will occur.

What is type compatibility?

Type compatibility in Java is mainly reflected in inheritance relationships. For example, an object of a subclass can be assigned to the reference variable of the parent class. This is called Upcasting , which is automatically completed and does not require casting.

For example:

 Animal a = new Cat(); // Legal, Cat is a subclass of Animal

The other way around is not possible. If you try to assign the object of the parent class to the reference variable of the subclass, you must perform a cast, and the premise is that the object is indeed an instance of the subclass, otherwise an error will be reported at runtime.

Why does cast type conversion go wrong?

There is no problem with casting itself, the problem is that the type mismatch of the actual object . For example, the following code will throw an exception:

 Animal a = new Animal();
Cat c = (Cat) a; // throws ClassCastException when running

Although the syntax here is correct, because a actually points to Animal object, not Cat , it fails to force it to Cat .

To avoid this problem, before making a downward transformation, you should first use instanceof to check the actual type of the object:

 if (a instanceof Cat) {
    Cat c = (Cat) a;
}

This ensures the security of transformation.

Type erasure and generic conversion traps

Java generics are implemented through type erasing, which means that at runtime, the generic information will be "erased". For example, List<String> and List<Integer> are actually both List when running. This brings up a problem: you cannot directly make type judgments or conversions on generics.

For example, the following code will report an error:

 List<String> list = new ArrayList<>();
if (list instanceof List<Integer>) { ... } // Compile error

Because the type information no longer exists at runtime, this judgment cannot be completed. This also reminds us that when using generics, we should be extra careful about type conversion and avoid relying on runtime generic information.

Conversion of polymorphism and interface types

In addition to inheritance between classes, interfaces are also an important scenario for type conversion. If a class implements an interface, its objects can be assigned to the reference variable of the interface:

 Animal a = new Cat(); // Class inheritance Runnable r = new Thread(); // Interface implementation

Similarly, if you want to transition from an interface reference variable to a concrete class, you also need to check if the types match:

 if (r instanceof Thread) {
    Thread t = (Thread) r;
}

Such conversion is safe as long as the actual objects match.

Basically that's it. Type conversion is common in Java, but it is easy to make mistakes without paying attention to type compatibility and the real type of runtime objects. Remember a few key points:

• Upward transformation is automatically completed, safe
• Downward transformation must be explicit and must be coordinated with instanceof
• Generics are not reliable at runtime, don't rely on them to make type judgments
• Interfaces and implementation classes can also be converted, the logic is the same

Once you master these details, you will have a lot of thought when writing code.

The above is the detailed content of Safe Casting and Type Compatibility in Java. For more information, please follow other related articles on the PHP Chinese website!