Someone could tell me about difference?

Question about the task

Wildcards

Java Collections, Level 5, Lesson 8

Under discussion

I added wildcards:

Previously code looks:

I understand that here occur relationship producer-consumer or something similar. Wildcard ? with super give me sureness that this List have ancestors and I can safely adding to it. Wildcard ? with extends give me reliability that this list is descendant from S, this mean that from D too (because S extends H, H extends D) But I don't understand difference between before code and after. I see that this give me more possibilities because before I could use only S and D class, now I have whole more spectrum of class to work. Maybe someone give me some hints about this code because this Generics Day give me headache :) (I added screens because I had problem with adding proper code)

Comments (4)

Popular
New
Old

You must be signed in to leave a comment

Thomas

Level 41 , Bayreuth, Germany

12 October, 09:33

useful

public static void main(String[] args) {
    // to mimik some kind of generic inheritance you use upper and lower bounds because there is no type inheritance
    // List<Car> has nothing to do with List<Cabriolet> (on the other hand Collection<Car> is a parent of List<Car>)

    // With writing lower bounds, the <? super Type>, you want to make sure that your
    // Type can be written to all sorts of Containers of that Type and its parents. E.g. you want to make
    // sure your Cabriolet can be added to Car lists or even Object lists
    write(new ArrayList<Object>(), new Cabriolet());
    write(new ArrayList<Car>(), new Cabriolet());

    // compare for methods that don't use bounds. Then there is inheritance for the item but not for the generic type
    writeExact(new ArrayList<>(), new Cabriolet()); // works
    writeExact(new ArrayList<>(), new Car()); // OK
    // writeExact(new ArrayList<Cabriolet>(), new Cabriolet()); // no, no generic type inheritance
    // !!!! that's the reason for upper and lower bounds, that there is no generic inheritance

    // when you write a method for reading from a Container and you want to be more flexible and pass in
    // all sorts of containers with types 'inheriting' from Car, then you use upper bounds
    // ? extends Type
    // that way you make sure that the type is at least of type Type

    // lists and objects to use to test
    List<Car> cars = new ArrayList<>();
    List<Cabriolet> cabriolets = new ArrayList<>();
    cars.add(new Car());
    cabriolets.add(new Cabriolet());

    // now you just need one method to be able to read from all sorts of lists with a type of car or its descendants
    System.out.println(read(cars));
    System.out.println(read(cabriolets));
}

Thomas

Level 41 , Bayreuth, Germany

12 October, 09:34

useful

That was just the main method... here is the class, just past main into it. The 1000 char limit wasn't enough ;)

public class Main {

    private static void writeExact(List<Car> list, Car item) {
        list.add(item);
    }

    public static void write(List<? super Cabriolet> list, Cabriolet item) {
        list.add(item);
        System.out.println(list);
    }

    public static Car read(List<? extends Car> list) {
        return list.get(0);
    }
}

then you just need a Car class and a Cabriolet extends Car class.

matemate123

Level 50 , Kraków, Poland

12 October, 12:46

Nice example, Generics scares me a little less now. Thanks!

Thomas

Level 41 , Bayreuth, Germany

12 October, 13:34

ups, the code was messed up... fixed that