Java Generics - 9. Type Erasure

-
This is part 9 of the 9 part series on Java Generics 


Prev Topic

Topics





Java Generics - Type Erasure


Java Generics were created for tight type checking during compile time. Java complier applies the type erasure to the java code. Actually it replaces generic types by:
  •         Bounds for bounded types and Object for all unbounded types
  •         Inserts casting where necessary
  •         Add bridge methods whenever needed
The Generics also ensures that no new classes are created by the compiler to achieve these goals.
Have a look at the types class called Gen<E> below that is unbounded. It is in fact compiled as the class Gen with the unbounded type E replaced by the class Object.


       // Generic class
       class Gen<E> {
      
              private E val;
      
              public void setVal(E val) {
                     this.val = val;
              }
      
              public E getVal(){
                     return val;
              }     
       }
                    
       // The above clas gets compiles as
       class Gen {
      
              private Object val;
      
              public void setVal(Object val) {
                     this.val = val;
              }
      
              public Object getVal(){
                     return val;
              }     
       }

For a bounded type it actually gets replaced by the bound.


       // Generic class
       class Gen<E extends Number> {
      
              private E val;
      
              public void setVal(E val) {
                     this.val = val;
              }
      
              public E getVal(){
                     return val;
              }     
       }
                    
       // The above clas gets compiles as
       class Gen {
      
              private Number val;
      
              public void setVal(Number val) {
                     this.val = val;
              }
      
              public Number getVal(){
                     return val;
              }     
       }

The Java compiler also erases the type parameters in the method arguments that are generic as in the code below. This is why you will get the exception “Erasure of method foo(Object, Number) is the same as another method in type ErasureMethods” when you use both of the methods below in the same class. You cannot have two methods in a class that have same signature after type erasure.


       // Generic methods
       public <E, N extends Number> void foo(E e, N n) {
              /* */
       }
      
       // resolved as
       public void foo(Object e, Number n) {
              /* */
       }







Prev Topic

Topics




Comments

Post a Comment

Popular posts from this blog

Java Generics - 7. Upper and Lower Bounds

-
Image
This is part 7 of the 9 part series on Java Generics  Prev Topic Typed Classes as method parameters Topics 1. Introduction 2. Bounding 3. Multiple bounding 4. Generic Methods 5. Wildcards 6. Typed Classes as method parameters 7. Upper and Lower Bounds 8. Target Types 9. Type Erasure Next Topic Target Types Java Generics - Upper and Lower Bounds This is going to be a really long blog, so please bear with me. Declaring Generic Variables You can also use generics to declare the variables. In other work you can choose which types can be assigned to a variable. The rules are more or less the same as for methods. You cannot define a type variable, like you could for the methods. Thus the declaration below makes no sense.         // invalid        private <E extends Fruit> E var1 = null ;      ...
Read more

Java Functional Programming : 3. The java.util.function Library

-
Image
This is the multi part series on Java Functional Programming 3. The java.util.function Library In most cases you might not need to declare your own functional interface as Java gives you a standard set of interfaces to save your time. In case you’d like to work with a function of two parameters of the same type, you could probably use the interface java.util.function.BinaryOperator<T> for the same activity. (More on the package java.util.function is to follow). As a shortcut, you’d probably prefer to keep things simple without the need of an extra interface declaration. Lets look at the constructs below:        BinaryOperator<Integer> binAdd = ( a , b ) -> a + b ;        System. out .println( "Bin Add 2, 3 = " + binAdd .apply(2, 3)); The lambda expressions can be passed as a parameter into the methods. Let us define a method which doubles the value given by the lambda ex...
Read more

Java Generics - 3. Multiple bounding

-
Image
This is part 3 of the 9 part series on Java Generics  Prev Topic Bounding Topics 1. Introduction 2. Bounding 3. Multiple bounding 4. Generic Methods 5. Wildcards 6. Typed Classes as method parameters 7. Upper and Lower Bounds 8. Target Types 9. Type Erasure Next Topic Generic Methods Java Generics - Multiple bounding Refer back to out Fruit and Grain hierarchy. Remember few of the Grains and Fruits also implement the interface Exportable . What if you wanted the generic class to be used only with the type Exportable? We already discussed that earlier. The declaration extends makes no distinction whether the F extends a class or an interface. The generics give us even more flexibility. Say you wanted you generic class to be used with a type Fruit which is Exportable ? Here the class to be used with the Generic types should be both – Fruit & Exportable . Is that possible with generics? Yes of cou...
Read more