Java中的多态性-我可以将对象设置为特定类型吗？

Question

I am a programmer who is getting to grasps with polymorphism after a long break and I was wondering if the following is possible. Say I had a super class in which there were some instance variables A, B and C. In all subclasses A and B are strings and behave as such in all subclasses however in all of the subclasses, the type of C may depend on the state of the subclass. I was wondering if it is possible to set C as type 'Object' in the superclass and then specify its type in each subclass using wrapper classes. eg

public class SuperClass {
    String A;
    String B;
    Object C;

    public SuperClass(){}
    }
}
public class SubClassA extends SuperClass {

    public SubClassA () {
        C = new String(); //notice this type is different from its type in the next class
    }

}

public class SubClassB extends SuperClass {

    public SubClassB () {
        C = new Integer();
    }
}

your thoughts would be appreciated :) Thanks

Answer 1

No. "Set an object to a specific type" does not mean anything. In fact, "Set an object." does not mean anything.

A, B, and C in your example are not objects, they are variables. There are three kinds of variable in Java; primitives (eg, int, boolean, double), array reference variables, and object reference variables. A, B, and C are object reference variables. That means, A, B, and C each hold the identity of some object.

Initially, they all hold null which is a special object reference that means "no object."

Your subclass constructors each create a new object, and store its identity in C.

Objects have types which can be known at run-time, and variables have types which are only known at compile time. The compiler will reject your code if it can prove that you assign the identity of some object to an object reference variable with an incompatible type.

The type of variable C, Object, is compatible with any object. You can assign a String reference to it, or you can assign an Integer reference to it, or you can assign a ForkJoinPool.ForkJoinWorkerThreadFactory reference to it. The downside, is that the compiler will only let you perform operations through C that can be performed on every type of object. The compiler won't allow you to call C.toUpperCase()---not even if it holds a reference to an actual String object.---because you have explicitly declared that C may hold references to things that are not Strings.

---

I would not write the code that you wrote, but it's hard to say what I would write instead, because your example doesn't actually do anything. You'll get better answers in this forum if you ask questions about how to solve actual problems.

Answer 2

Understand, first and foremost, the difference between an object and a reference . An object is something that you create with new and it has a specific type (class) that is fixed from the moment it's created. A reference is a "pointer" to an object.

A single reference can point to different types of objects at different times, so long as the declared type of the reference is the class of the object or its superclass . Object is the superclass of all objects (including arrays, but not "scalars" like int , char , float , etc) and hence a reference declared with type Object can point to any object.

Of course, if you have a reference declared as Object then even if you (supposedly) know what's in it, the compiler and JVM haven't a clue. So you need to "cast" the reference to the appropriate type before you can use it. Eg, knowing that you previously stored a pointer to a String object into C , you might do:

String castFromC = (String)C;
Char charFromC = castFromC.charAt(5);

If it turns out that C is not a String but is instead an Integer, then the (String) "cast" operation will fail at runtime with a ClassCastException.

Answer 3

From my understanding of your concern, your posted code looks OK to me. However, it will force you to cast C to a specific type for it to be "operable" since you just declared the object reference C as just a "reference pointing to an Object type of Java object".

To avoid the ugly typecasting, you can generify your superclass like this

class SuperClass<T> {
    String A;
    String B;
    T C;

    public SuperClass(){}
}

And in your subclasses, you can use it like this

class SubClassA extends SuperClass<String> {

    public SubClassA () {
        C = new String();
    }
}

class SubClassB extends SuperClass<Integer> {

    public SubClassB () {
        C = new Integer(0);
    }
}

Also, it is a convention that your instance variables should have a meaningful name starting with lowercase, declared private, and exposed to other classes with public getters and setters.