Java Generics - 8. Target Types

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


Prev Topic

Topics


Next Topic

Java Generics - Target Types


As per java specification – A target type of an expression is the data type that the compiler expects when it is being used. Consider the method createList in the class TypeInference below, that creates the list of 2 elements which are passed in its parameter.


public class TypeInference {
             
       public static <E> List<E> createList(E e1, E e2){
              List<E> list = new ArrayList<>();
              list.add(e1);
              list.add(e2);
              return list;
       }
             
       public static <E> List<E> newList(){
              return new ArrayList<>();
       }     
}

We can pass any type of parameter here, they could be Integer or maybe String. In this case the compiler understands what we are trying to infer. The compiler understands that you are trying to create the list of String for the first variable, and a list of Integer for the second one.


       List<String> strList1  = TypeInference.createList("Hello", "World");
       List<Integer> intList1 = TypeInference.createList(1, 2); // auto-boxing

This saves you the pain of declaring the type at the right side. Consider the code below. In fact this strange looking code is valid and will compile well. Notice the type declaration within the diamond in the code below.


       List<String> strList2  = TypeInference.<String>createList("Hello", "World");
       List<Integer> intList2 = TypeInference.<Integer>createList(1, 2);


Similarly when using the method newList( ), you needn’t declare the type while using it. The compiler would infer it to the correct type.


       List<String> sList1 = TypeInference.newList();
       List<String> sList2 = TypeInference.<String>newList();


The compiler not only infers the assignment but also the method parameters (from Java 8 onwards). Go ahead and try it yourself. Java has made things simpler for you.



Prev Topic

Topics


Next Topic

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