Why casting a super class reference to subclass reference is potentially dangerous?

Answer 1

It depends on the programming language you are referring to. In the Java Programming Language, Casting a superclass reference to a subclass is dangerous. It is dangerous because the code will compile fine, leading you to believe that the code will always work correctly. However, sometimes when you cast a superclass to a subclass, the program will throw a java.lang.ClassCastException when performing the cast.

Consider an example in Java programming language:

class Person{

String getName(){ return "Fred"; }

}

class Employee extends Person {

double getSalary(){ return 57; }

}

public class X {

public static void main(String args[])

{

Person p = new Person();

Employee e = (Employee) p; //This causes a java.lang.ClassCastException

System.out.println(e.getSalary());

}

}

When this program runs, It crams a Person p object into an Employee e object which causes a "java.lang.ClassCastException: Person cannot be cast to Employee"

Employee e = (Employee) p; //error happens here

Note that an Employee has a method called getSalary, but Person does not. Not all People have Salaries. The Person object is Instantiated and put into 'p'. The problem is that this particular person p is not an employee. If that person p WAS an employee the code would run correctly and print 57.

Casting a superclass reference to a subclass is dangerous because sometimes the cast will work perfectly, and sometimes it will crash the program. The cast itself is the dangerous part. When doing casts of this sort, the programmer needs to make 100% sure that this Person p was instantiated with a new Employee(). Then the Person object will have the method getSalary().

This code is dangerous as well, but it does not throw any exceptions, it makes a Person which is an Employee, and then casts that Person/Employee into an Employee type.

class Person{

String getName(){ return "Fred"; }

}

class Employee extends Person {

double getSalary(){ return 57; }

}

public class X {

public static void main(String args[]){

Employee x = new Employee();

Person w = (Employee) x;

Employee y = (Employee)w;

System.out.println(y.getSalary());

}

}

Here, employee x is created and then cast into a Person object. Person w is an Employee. Now when we cast the Person w into Employee y, everything is fine, and the program prints "57.0". It's dangerous because this person might not have been an Employee.

Answer 2

Casting a superclass reference to a subclass reference can be dangerous because the subclass may have additional methods or attributes that are not present in the superclass. If you then try to access these subclass-specific features using the superclass reference, it can cause runtime errors like ClassCastException or NullPointerException. It's generally safer to use polymorphism and dynamic binding to work with subclass objects using superclass references.