将子类的ArrayList传递给一个采用超类ArrayList的构造函数？

Question

Okay so I'm working on this project for the university and I think I'm doing something wrong here, guess I haven't understood java subclassing and class inheritance enough.

I have rewrote my problem in this little form.

    class SuperClass {

        int dunno;

        public SuperClass(int dunno) {
            this.dunno = dunno;
        }
    }

    class SubClass extends SuperClass {

        int duncare;

        public SubClass(int dunno, int duncare) {
            super(dunno);
            this.duncare = duncare;
        }
    }

    class VeryBigClass {

        ArrayList<SuperClass> superList;

        public VeryBigClass(ArrayList<SuperClass> superList) {
            this.superList = superList;
        }
    }

    public void main(String[] args) {

        new VeryBigClass(new ArrayList<SubClass>()); // this is the problematic line

    }

}

In little words I wrote a lot of classes that extend one more general class, and in many places I have made operations with the superclass (the general one), instead of treating each of the subclasses one by one in the same way.

But I can not create the instance of the class I need, since the constructor takes as argument the superclass. I don't even know how to cast it since new VeryBigClass(new (ArrayList<SuperClass>)ArrayList<SubClass>()); is obviously wrong. Plus, the construction of these instances will be handled by a json library at some point so I'd rather not do such fancy stuff...

Answer 1

If you use generics, it should work just fine, is not the same a list of Superclass than a list of Subclass, but the generic solve this:

class VeryBigClass<T extends SuperClass> {

    ArrayList<T> superList;

    public VeryBigClass(ArrayList<T> superList) {
        this.superList = superList;
    }
}

Answer 2

The Java Tutorial explains this in http://docs.oracle.com/javase/tutorial/java/generics/inheritance.html

Bottom line, if you have types with an inheritance relationship, like Sub extends Super as generics, they do not confer an inheritance relationship in the classes that hold them: Foo<Sub> is not a subtype of Foo<Super> .

The reason is that it would violate the promise of what type the generic type contains, breaking the Liskov Substitution principle. If List<Sub> extended List<Super> , it would be legal to do this:

List<Sub> subs = new ArrayList<Sub>();
List<Super> supers = subs;

Super super = new Super();
supers.add(super);

Whoa! Now subs has an element of type Super , completely illegal!

Because ArrayList<Sub> is not a subtype of List<Super> , when you invoked

new VeryBigClass(new ArrayList<SubClass>());

you passed an argument to the constructor that was not legal.

Answer 3

You can also use the wildcard ? extends super ? extends super That is, any class that extends super.

Example :

class VeryBigClass {

    ArrayList<? extends SuperClass> superList;

    public VeryBigClass(ArrayList<? extends SuperClass> superList) {
        this.superList = superList;
    }
}