从子类/子类/继承的类中获取基类/父类/父类

Question

I'm trying to send a list of objects over a socket.

The objects in the list contain an unserializable object and so cannot be sent, however it's base class is fully serializable and contains all the fields I need.

So what I'm trying to do is convert the list to a list of the base class. The only way I could think so do this is as follows:

// subClassList is an ArrayList<SubClass>
ArrayList<BaseClass> baseClassList = new ArrayList<BaseClass>();
for(SubClass subClass: subClassList) {
    // cast to the base class
    baseClassList.add((BaseClass)subClass);
}

This however doesn't work as I still get the same NotSerializableException exception. From debugging the code I can see that the new list is still a list of the sub class, even though it has been cast.

Is there a way to achieve what I'm trying to do?

Answer 1

Casting a reference doesn't change the type of the actual object:

String foo = "hello";
Object bar = (Object) foo;
System.out.println(bar); // Hello
System.out.println(bar.getClass()); // java.lang.String

If you want to only have an instance of the base class, you could create a constructor in the base class which simply creates a new instance of the base class given an instance of it, without trying to perform any sort of deep copy:

public BaseClass(BaseClass other) {
    this.x = other.x;
    this.y = other.y;
    this.z = other.z;
    // etc
}

Then in the code you've shown:

baseClass.add(new BaseClass(subClass));

Answer 2

Your approach doesn't work because even though you can use a super class variable to refer to the subclass object, the object itself is of the sub class type.

The best way is to either serialize the subclass, or extract the data from subclass and write them to a newly created super class. Just have a static utility method to do the conversion build into the sub class....

Answer 3

Casting doesn't change the type of an object. It allows getting a reference of another type for the object iff the object has this other type. Upcasting is never necessary. You can use

String s = "hello";
Object o = s; // no cast needed

Downcasting is necessary, and will only work if the object has the type you cast it to:

Object o = "hello";
Object o2 = Integer.valueOf(5);
String s = (String) o; // OK because o is a String
String s2 = (String) o2; // ClassCastException, because o2 is not a String.

So, your code is equivalent to

ArrayList<BaseClass> baseClassList = new ArrayList<BaseClass>();
for(SubClass subClass: subClassList) {
    // cast to the base class
    baseClassList.add(subClass);
}

You must create a new object of the new type, using a copy constructor:

ArrayList<BaseClass> baseClassList = new ArrayList<BaseClass>();
for(SubClass subClass: subClassList) {
    // cast to the base class
    baseClassList.add(new BaseClass(subClass));
}

Answer 4

Your question embodies a contradiction in terms. If the base class is Serializable so are all its derived classes. If your derived class contains references to non-serializable objects, just make them transient.