Difference between super T and extends T in Java

Question

What is the difference between List lt   super T gt  and List lt   extends T gt     I used to use List lt   extends T gt   but it does not allow me to add elements to it list add e   whereas the List lt   super T gt  does

User · Answer

Using extends you can only get from the collection  You cannot put into it  Also  though super allows to both get and put  the return type during get is   super T

User · Answer

I love the answer from  Bert F but this is the way my brain sees it   I have an X in my hand   If I want to write my X into a List  that List needs to be either a List of X or a List of things that my X can be upcast to as I write them in i e  any superclass of X     List lt   super   X gt    If I get a List and I want to read an X out of that List  that better be a List of X or a List of things that can be upcast to X as I read them out  i e  anything that extends X  List lt   extends X gt    Hope this helps

User · Answer

The up voted answers covers the details on many aspects  However  I would try to answer this in different way   There are 2 things we need to consider    1  Assignment to the list variable  List lt   extends X gt  listvar   Here  any list of X or list of subclasses of X can be assigned to listvar   List lt   extends Number gt  listvar   listvar   new ArrayList lt Number gt       listvar   new ArrayList lt Integer gt        List lt   super X gt  listvar   Here  any list of X or list of superclasses of X can be assigned to listvar   List lt   super Number gt  listvar   listvar   new ArrayList lt Number gt       listvar   new ArrayList lt Object gt      2  Perform Read or Write operation on the list variable   List lt   extends X gt  listvar     You can use this feature to accept a list in method arguments and perform any operations on type X  Note  You can only read objects of type X from the list     List lt   super Number gt  listvar    You can use this feature to accept a list in method arguments and perform any operations on type Object as You can only read objects of type Object from the list  But yes  additional thing here is   you can add objects of type X into the list

User · Answer

When to use extends and super  Wildcards are most useful in method parameters  They allow for the necessary flexibility in method interfaces   People are often confused when to use extends and when to use super bounds  The rule of thumb is the get-put principle  If you get something from a parametrized container  use extends   int totalFuel List lt   extends Vehicle gt  list    int total   0  for Vehicle v   list        total    v getFuel      return total     The method totalFuel gets Vehicles from the list  asks them about how much fuel they have  and computes the total  If you put objects into a parameterized container  use super   int totalValue Valuer lt   super Vehicle gt  valuer    int total   0  for Vehicle v   vehicles        total    valuer evaluate v     return total     The method totalValue puts Vehicles into the Valuer  It s useful to know that extends bound is much more common than super

User · Answer

I d like to visualize the difference  Suppose we have   class A     class B extends A     class C extends B       List lt   extends T gt  - reading and assigning    ------------------------- ------------------- ---------------------------------            wildcard                 get                       assign                ------------------------- ------------------- ---------------------------------       List lt   extends C gt          A    B    C                            List lt C gt       ------------------------- ------------------- ---------------------------------       List lt   extends B gt          A    B                       List lt B gt    List lt C gt       ------------------------- ------------------- ---------------------------------       List lt   extends A gt          A                  List lt A gt    List lt B gt    List lt C gt       ------------------------- ------------------- ---------------------------------    List lt   super T gt  - writing and assigning    ------------------------- ------------------- -------------------------------------------            wildcard                 add                            assign                     ------------------------- ------------------- -------------------------------------------        List lt   super C gt                     C       List lt Object gt   List lt A gt   List lt B gt   List lt C gt      ------------------------- ------------------- -------------------------------------------        List lt   super B gt                B    C       List lt Object gt   List lt A gt   List lt B gt               ------------------------- ------------------- -------------------------------------------        List lt   super A gt           A    B    C       List lt Object gt   List lt A gt                        ------------------------- ------------------- -------------------------------------------    In all of the cases    you can always get Object from a list regardless of the wildcard  you can always add null to a mutable list regardless of the wildcard

User · Answer

You can go through all the answers above to understand why the  add   is restricted to   lt   gt      lt   extends gt    and partly to   lt   super gt     But here s the conclusion of it all if you want to remember it  and dont want to go exploring the answer every time   List lt   extends A gt  means this will accept any List of A and subclass of A   But you cannot add anything to this list  Not even objects of type A   List lt   super A gt  means this will accept any list of A and superclass of A  You can add objects of type A and its subclasses

User · Answer

Based on Bert F s answer I would like to explain my understanding   Lets say we have 3 classes as  public class Fruit    public class Melon extends Fruit    public class WaterMelon extends Melon     Here We have  List lt   extends Fruit gt  fruitExtendedList          Says that I can be a list of any object as long as this object extends Fruit    Ok now lets try to get some value from fruitExtendedList  Fruit fruit   fruitExtendedList get position     This is valid as it can only return Fruit or its subclass    Again lets try   Melon melon   fruitExtendedList get position     This is not valid because fruitExtendedList can be a list of Fruit only  it may not be    list of Melon or WaterMelon and in java we cannot assign sub class object to    super class object reference without explicitly casting it    Same is the case for   WaterMelon waterMelon   fruitExtendedList get position    Now lets try to set some object in fruitExtendedList  Adding fruit object  fruitExtendedList add new Fruit       This in not valid because as we know fruitExtendedList can be a list of any    object as long as this object extends Fruit  So what if it was the list of     WaterMelon or Melon you cannot add Fruit to the list of WaterMelon or Melon    Adding Melon object  fruitExtendedList add new Melon       This would be valid if fruitExtendedList was the list of Fruit but it may    not be  as it can also be the list of WaterMelon object  So  we see an invalid    condition already    Finally let try to add WaterMelon object   fruitExtendedList add new WaterMelon       Ok  we got it now we can finally write to fruitExtendedList as WaterMelon    can be added to the list of Fruit or Melon as any superclass reference can point    to its subclass object    But wait what if someone decides to make a new type of  Lemon lets say for arguments sake SaltyLemon as  public class SaltyLemon extends Lemon     Now fruitExtendedList can be list of Fruit  Melon  WaterMelon or SaltyLemon   So  our statement   fruitExtendedList add new WaterMelon      is not valid either   Basically we can say that we cannot write anything to a fruitExtendedList   This sums up List lt   extends Fruit gt   Now lets see  List lt   super Melon gt  melonSuperList         Says that I can be a list of anything as long as its object has super class of Melon    Now lets try to get some value from melonSuperList  Fruit fruit   melonSuperList get position     This is not valid as melonSuperList can be a list of Object as in java all    the object extends from Object class  So  Object can be super class of Melon and    melonSuperList can be a list of Object type   Similarly Melon  WaterMelon or any other object cannot be read   But note that we can read Object type instances  Object myObject   melonSuperList get position     This is valid because Object cannot have any super class and above statement    can return only Fruit  Melon  WaterMelon or Object they all can be referenced by   Object type reference    Now  lets try to set some value from melonSuperList   Adding Object type object  melonSuperList add new Object       This is not valid as melonSuperList can be a list of Fruit or Melon    Note that Melon itself can be considered as super class of Melon    Adding Fruit type object  melonSuperList add new Fruit       This is also not valid as melonSuperList can be list of Melon   Adding Melon type object  melonSuperList add new Melon       This is valid because melonSuperList can be list of Object  Fruit or Melon and in    this entire list we can add Melon type object    Adding WaterMelon type object  melonSuperList add new WaterMelon       This is also valid because of same reason as adding Melon   To sum it up we can add Melon or its subclass in melonSuperList and read only Object type object

User · Answer

The generic wildcards target two primary needs   Reading from a generic collection Inserting into a generic collection There are three ways to define a collection  variable  using generic wildcards  These are   List lt   gt            listUknown   new ArrayList lt A gt     List lt   extends A gt  listUknown   new ArrayList lt A gt     List lt   super   A gt  listUknown   new ArrayList lt A gt       List lt   gt  means a list typed to an unknown type  This could be a List lt A gt   a List lt B gt   a List lt String gt  etc   List lt   extends A gt  means a List of objects that are instances of the class A  or subclasses of A  e g  B and C   List lt   super A gt  means that the list is typed to either the A class  or a superclass of A   Read more   http   tutorials jenkov com java-generics wildcards html

User · Answer

The most confusing thing here is that whatever type restrictions we specify  assignment works only one way   baseClassInstance   derivedClassInstance    You may think that Integer extends Number and that an Integer would do as a  lt   extends Number gt   but the compiler will tell you that  lt   extends Number gt  cannot be converted to Integer  that is  in human parlance  it is wrong that anything that extends number can be converted to Integer    class Holder lt T gt        T v      T get     return v        void set T n    v n      class A       public static void main String  args            Holder lt   extends Number gt  he   new Holder            Holder lt   super Number gt  hs   new Holder             Integer i          Number n          Object o              Producer Super  always gives an error except                  when consumer expects just Object         i   hs get        lt   super Number gt  cannot be converted to Integer         n   hs get        lt   super Number gt  cannot be converted to Number                           lt   super Number gt  cannot be converted to      but                                there is no class between Number and Object          o   hs get                Consumer Super         hs set i           hs set n           hs set o      Object cannot be converted to  lt   super Number gt              Producer Extends         i   he get        lt   extends Number gt  cannot be converted to Integer         n   he get            o   he get                Consumer Extends  always gives an error         he set i      Integer cannot be converted to  lt   extends Number gt          he set n      Number cannot be converted to  lt   extends Number gt          he set o      Object cannot be converted to  lt   extends Number gt            hs set i   is ok because Integer can be converted to any superclass of Number  and not because Integer is a superclass of Number  which is not true    EDIT added a comment about Consumer Extends and Producer Super -- they are not meaningful because they specify  correspondingly  nothing and just Object  You are advised to remember PECS because CEPS is never useful

User · Answer

Imagine having this hierarchy    1  Extends  By writing       List lt   extends C2 gt  list    you are saying that list will be able to reference an object of type  for example  ArrayList whose generic type is one of the 7 subtypes of C2  C2 included     C2  new ArrayList lt C2 gt       an object that can store C2 or subtypes  or D1  new ArrayList lt D1 gt       an object that can store D1 or subtypes  or D2  new ArrayList lt D2 gt       an object that can store D2 or subtypes  or      and so on  Seven different cases       1  new ArrayList lt C2 gt     can store C2 D1 D2 E1 E2 E3 E4     2  new ArrayList lt D1 gt     can store    D1    E1 E2       3  new ArrayList lt D2 gt     can store       D2       E3 E4     4  new ArrayList lt E1 gt     can store          E1                  5  new ArrayList lt E2 gt     can store             E2                  6  new ArrayList lt E3 gt     can store                E3                  7  new ArrayList lt E4 gt     can store                   E4                We have a set of  storable  types for each possible case  7  red  sets here graphically represented    As you can see  there is not a safe type that is common to every case    you cannot list add new C2       because it could be list   new ArrayList lt D1 gt     you cannot list add new D1       because it could be list   new ArrayList lt D2 gt       and so on    2  Super  By writing       List lt   super C2 gt  list    you are saying that list will be able to reference an object of type  for example  ArrayList whose generic type is one of the 7 supertypes of C2  C2 included     A1  new ArrayList lt A1 gt       an object that can store A1 or subtypes  or A2  new ArrayList lt A2 gt       an object that can store A2 or subtypes  or A3  new ArrayList lt A3 gt       an object that can store A3 or subtypes  or      and so on  Seven different cases       1  new ArrayList lt A1 gt     can store A1          B1 B2       C1 C2    D1 D2 E1 E2 E3 E4     2  new ArrayList lt A2 gt     can store    A2          B2       C1 C2    D1 D2 E1 E2 E3 E4     3  new ArrayList lt A3 gt     can store       A3          B3       C2 C3 D1 D2 E1 E2 E3 E4     4  new ArrayList lt A4 gt     can store          A4       B3 B4    C2 C3 D1 D2 E1 E2 E3 E4     5  new ArrayList lt B2 gt     can store                B2       C1 C2    D1 D2 E1 E2 E3 E4     6  new ArrayList lt B3 gt     can store                   B3       C2 C3 D1 D2 E1 E2 E3 E4     7  new ArrayList lt C2 gt     can store                            C2    D1 D2 E1 E2 E3 E4   We have a set of  storable  types for each possible case  7  red  sets here graphically represented    As you can see  here we have seven safe types that are common to every case  C2  D1  D2  E1  E2  E3  E4    you can list add new C2       because  regardless of the kind of List we re referencing  C2 is allowed you can list add new D1       because  regardless of the kind of List we re referencing  D1 is allowed   and so on  You probably noticed that these types correspond to the hierarchy starting from type C2   Notes  Here the complete hierarchy if you wish to make some tests  interface A1   interface A2   interface A3   interface A4    interface B1 extends A1   interface B2 extends A1 A2   interface B3 extends A3 A4   interface B4 extends A4    interface C1 extends B2   interface C2 extends B2 B3   interface C3 extends B3    interface D1 extends C1 C2   interface D2 extends C2    interface E1 extends D1   interface E2 extends D1   interface E3 extends D2   interface E4 extends D2

User · Answer

extends  The wildcard declaration of List lt   extends Number gt  foo3 means that any of these are legal assignments   List lt   extends Number gt  foo3   new ArrayList lt Number gt         Number  extends  Number  in this context  List lt   extends Number gt  foo3   new ArrayList lt Integer gt        Integer extends Number List lt   extends Number gt  foo3   new ArrayList lt Double gt         Double extends Number    Reading - Given the above possible assignments  what type of object are you guaranteed to read from List foo3    You can read a Number because any of the lists that could be assigned to foo3 contain a Number or a subclass of Number  You can t read an Integer because foo3 could be pointing at a List lt Double gt   You can t read a Double because foo3 could be pointing at a List lt Integer gt    Writing - Given the above possible assignments  what type of object could you add to List foo3 that would be legal for all the above possible ArrayList assignments    You can t add an Integer because foo3 could be pointing at a List lt Double gt   You can t add a Double because foo3 could be pointing at a List lt Integer gt   You can t add a Number because foo3 could be pointing at a List lt Integer gt      You can t add any object to List lt   extends T gt  because you can t guarantee what kind of List it is really pointing to  so you can t guarantee that the object is allowed in that List  The only  guarantee  is that you can only read from it and you ll get a T or subclass of  T   super  Now consider List  lt   super T gt    The wildcard declaration of List lt   super Integer gt  foo3 means that any of these are legal assignments   List lt   super Integer gt  foo3   new ArrayList lt Integer gt         Integer is a  superclass  of Integer  in this context  List lt   super Integer gt  foo3   new ArrayList lt Number gt          Number is a superclass of Integer List lt   super Integer gt  foo3   new ArrayList lt Object gt          Object is a superclass of Integer    Reading - Given the above possible assignments  what type of object are you guaranteed to receive when you read from List foo3    You aren t guaranteed an Integer because foo3 could be pointing at a List lt Number gt  or List lt Object gt   You aren t guaranteed a Number because foo3 could be pointing at a List lt Object gt   The only guarantee is that you will get an instance of an Object or subclass of Object  but you don t know what subclass    Writing - Given the above possible assignments  what type of object could you add to List foo3 that would be legal for all the above possible ArrayList assignments    You can add an Integer because an Integer is allowed in any of above lists  You can add an instance of a subclass of Integer because an instance of a subclass of Integer is allowed in any of the above lists  You can t add a Double because foo3 could be pointing at an ArrayList lt Integer gt   You can t add a Number because foo3 could be pointing at an ArrayList lt Integer gt   You can t add an Object because foo3 could be pointing at an ArrayList lt Integer gt      PECS  Remember PECS   Producer Extends  Consumer Super      Producer Extends  - If you need a List to produce T values  you want to read Ts from the list   you need to declare it with   extends T  e g  List lt   extends Integer gt   But you cannot add to this list   Consumer Super  - If you need a List to consume T values  you want to write Ts into the list   you need to declare it with   super T  e g  List lt   super Integer gt   But there are no guarantees what type of object you may read from this list  If you need to both read from and write to a list  you need to declare it exactly with no wildcards  e g  List lt Integer gt     Example  Note this example from the Java Generics FAQ  Note how the source list src  the producing list  uses extends  and the destination list dest  the consuming list  uses super   public class Collections      public static  lt T gt  void copy List lt   super T gt  dest  List lt   extends T gt  src          for  int i   0  i  lt  src size    i             dest set i  src get i              Also see  How can I add to List lt   extends Number gt  data structures

User · Answer

Example  Order of inheritance is assumed as O   S   T   U   V  Using extends Keyword    Correct   List lt   extends T gt  Object   new List lt T gt     List lt   extends T gt  Object   new List lt U gt     List lt   extends T gt  Object   new List lt V gt       InCorrect   List lt   extends T gt  Object   new List lt S gt     List lt   extends T gt  Object   new List lt O gt       super Keyword    Correct   List lt   super T gt  Object   new List lt T gt     List lt   super T gt  Object   new List lt S gt     List lt   super T gt  Object   new List lt O gt       InCorrect   List lt   super T gt  Object   new List lt U gt     List lt   super T gt  Object   new List lt V gt       Adding object  List Object   new List     Object add new T       error   But Why error   Let s look at the Possibilities of initializations of List Object  List lt   extends T gt  Object   new List lt T gt     List lt   extends T gt  Object   new List lt U gt     List lt   extends T gt  Object   new List lt V gt       If we use Object add new T     then it will be correct only if   List lt   extends T gt  Object   new List lt T gt        But there are extra two possibilities  List Object   new List    List Object   new List    If we try to add  new T    to the above two possibilities it will give an error because T is the superior class of U and V   we try to add a T object  which is  new T      to List of type U and V   Higher class object Base class  cannot be passed to lower class Object Sub class    Due to the extra two possibilities   Java gives you error even if you use the correct possilibity as Java don t know what Object you are referring to  So you can t add objects to List Object   new List    as there are possibilities that are not valid   Adding object  List Object   new List     Object add new T        compiles fine without error Object add new U        compiles fine without error Object add new V        compiles fine without error  Object add new S         error Object add new O         error   But why error occurs in the above two   we can use Object add new T     only on the below possibilities   List lt   super T gt  Object   new List lt T gt     List lt   super T gt  Object   new List lt S gt     List lt   super T gt  Object   new List lt O gt       If we Tried to use Object add new T    in    List Object   new List                 and   List Object   new List     then it will give error  This is because  We can t add T object which is new T    to the  List Object   new List     because it is an object of type U   We can t add a T object which is new T    to U Object because T is a base class and U is a sub class   We can t add base class to subclass and that s why error occurs   This is same for the another case

User · Answer

Adding an item to the list    List lt    extends X   doesn t allow to add anything  except for null into the list  List lt    super X   allows to add anything that is-a X  X or its subtype   or null    Getting an item from the list    When you get an item from List lt    extends X    you can assign it to a variable of type X or any supertype of X  including Object  When you get an item from List lt    super X    you can only assign it to a variable of type Object    Some examples       List lt   extends Number gt  list1   new ArrayList lt Integer gt         list1 add null      OK     Number n   list1 get 0      OK     Serializable s   list1 get 0      OK     Object o   list1 get 0      OK      list1 add 2 3      ERROR     list1 add 5      ERROR     list1 add new Object        ERROR     Integer i   list1 get 0      ERROR         List lt   super Number gt  list2   new ArrayList lt Number gt         list2 add null      OK     list2 add 2 3      OK     list2 add 5      OK     Object o   list2 get 0      OK      list2 add new Object        ERROR     Number n   list2 get 0      ERROR     Serializable s   list2 get 0      ERROR     Integer i   list2 get 0      ERROR

User · Answer

super is a lower bound  and extends is an upper bound   According to http   download oracle com javase tutorial extra generics morefun html       The solution is to use a form of   bounded wildcard we haven t seen yet    wildcards with a lower bound  The   syntax   super T denotes an unknown   type that is a supertype of T  or T   itself  remember that the supertype   relation is reflexive   It is the dual   of the bounded wildcards we ve been   using  where we use   extends T to   denote an unknown type that is a   subtype of T

[java] Difference between <? super T> and <? extends T> in Java

Examples related to java

Examples related to generics

Examples related to collections