View RSS Feed

Generics

Java Generics

  1. Java Generic's Wildcards

    by , 02-18-2012 at 04:57 PM
    Consider a situation where you desire all List elements to be printed. This could be explained by the given code:
    Java Code: This is the code to explain printing of all elements
    public void processElements(List<Object> elements){
       for(Object o : elements){
          System.out.println(o);
       }
    }
    This method couldn’t be used along with List<String> instance. To sort out this problem, wildcard operator is used. For writing generic List by the help of wildcard operator, use this code.
    ...
    Categories
    Generics
  2. Java Generic Methods

    by , 02-18-2012 at 04:55 PM
    It is also possible and supported to generify methods in Java.

    Java Code: This is the code to expalin generic methods
    public static <T> T add(T element, Collection<T> collection){
        collection.add(element);
        return element;
    }
    A type T is being specified by this method. It is used as generic type of collection as well as for element parameter type.

    Java Code:
    String stringElement = "stringElement";
    List<String> stringList = new ArrayList<String>();
    ...
    Categories
    Generics
  3. Generic Classes in Java

    by , 02-18-2012 at 04:52 PM
    Your Java classes could also be generified. Generics are not restricted or bound to any pre-defined classes of Java. This is also applicable to customized written classes of Java.

    Simple generic class is explained here by this code.
    Java Code: This is the code to explain generic class
    public class GenericTestFactory<E> {
        Class myClass = null;
        public GenericTestFactory(Class myClass) {
            this.myClass = myClass;
        }
        public E createInstance()
        throws
    ...
    Categories
    Generics
  4. Generic Map in Java

    by , 02-18-2012 at 04:49 PM
    It is possible to generify java.util.Map. Instances of Map in such cases could be of a specific type. Instances of that type in that case could be only inserted as well read, from that Map.
    Java Code: This is the code to explain Generic Map
    Map<Integer, String> set = new HashMap<Integer, String>;
    This Map just can now accept string instances to be as values and Integer instances to be as Keys.

    Accessing a Generic Map

    Following code could be used for addition of String to generic ...
    Tags: generic map Add / Edit Tags
    Categories
    Generics
  5. Generic Set in Java

    by , 02-18-2012 at 04:45 PM
    It is also possible to generify the java.util.Set. Set instances in these cases might of a specific type.

    Instances of that type in such cases could be inserted or read, from that set.

    Usage of generic Set is explained here.
    Java Code: This is the code to explain usage of generic Set
    Set<String> set = new HashSet<String>;
    Adding Elements to a Generic Set

    To a set, specific String type is added by using this code.
    Java Code: This is the code to add specific String type in a Set
    Set<String> set = new HashSet<String>;
    ...
    Tags: generic set Add / Edit Tags
    Categories
    Generics
  6. Generic List in Java

    by , 02-18-2012 at 04:43 PM
    It is possible to do the generification of java.util.List. This shows that List instances might be of a specific type. That type of instances in such cases could only be read from List.

    Generic List is explained by this code.
    Java Code: This is the code to expalin Generic List declaration
    List<String> list = new ArrayList<String>;
    String instances can be stored by this list.

    Exists are being checked just at the compilation time by this generic type.

    Accessing a Generic ...
    Tags: generic list Add / Edit Tags
    Categories
    Generics
  7. Java's Generic For Loop

    by , 02-18-2012 at 04:40 PM
    Generic consists of “new for loop”, that is known as “for each loop”. New for loop iterates the generic collections and also supports to integrate. Iteration over a List or Generic set is explained by this code:
    Generic List gets iterated by this code:

    Java Code: This is the code to explain the Generic For Loop
    List<String> list = new ArrayList<String>;
    for(String aString : list) {
        System.out.println(aString);
    }
    For loop parenthesis, declaration of a String variable is done. ...
    Categories
    Generics
  8. Generic Methods and Constructors

    by , 02-18-2012 at 04:37 PM
    Within methods declaration of the type parameters could be done and constructor signatures for creation of the generic constructors or generic methods.
    Java Code: This is the code to explain Generic Methods
    public class Box<T> {
    
        private T t;          
    
        public void add(T t) {
            this.t = t;
        }
    
        public T get() {
            return t;
        }
    
        public <U> void inspect(U u){
            System.out.println("T: " +
    ...
  9. Different Java Generic Types

    by , 02-18-2012 at 04:35 PM
    By using Generics, implementation of Box class is done. It is shown in the given code

    Java Code:
    public class Box<T> {
    
        // T stands for "Type"
        private T t;
    
        public void add(T t) {
            this.t = t;
        }
    
        public T get() {
            return t;
        }
    }
    In given Box class replacement takes place with T, of all occurrences objects.

    For referencing ...
    Categories
    Generics
  10. What is Java Generics?

    by , 02-18-2012 at 04:32 PM
    Java provides support to the Generic features of JV. For specification of the concrete types to certain general methods or classes, Generics is used.

    Above given definition is an abstract definition. For better understanding, consider few examples.
    Object instances are stored by the help of List interface. Therefore one can do storage and also place objects in a List. E.g.

    Java Code:
    List list = new ArrayList();
    list.add(new Integer(2));
    list.add("String");
    ...
    Categories
    Generics
  11. Use an Interface to Compare Objects in Generics

    by , 11-30-2011 at 12:25 AM
    A key aspect of using generics is being able to compare different objects. Consider an example where you are comparing different species of felines.
    Java Code:
    public class ComparableFeline implements Comparable<ComparableFeline> {
    
    	@Override
    	public int compareTo(ComparableFeline arg0) {
    		return 0;
    	}
    }
    So if you wanted to narrow ComparableFeline for use only among different types of domesticated cats instead of other felines such as ...

    Updated 11-30-2011 at 09:37 AM by Advanced Java

    Categories
    Generics
  12. Use Lists instead Arrays in Generics

    by , 11-30-2011 at 12:20 AM
    Generics were added to java in release 1.5. It allows you to avoid needing to cast objects as they are read from a collection. Instead you tell the compiler what types of objects that you want to hold in the collection. Often it is difficult to know which generic to use when you have two or more who seem to be able to complete the same function. Consider the choice between whether to use a list or an array. Now a key thing to remember is that arrays are covariant and know and enforce their element ...
  13. Wildcards with Generics

    by , 11-30-2011 at 12:16 AM
    Unlike with arrays, it is important to remember with generics that is not possible to upcast an object from its superclass to its subclass. So for example, this will create a compile time error.

    Java Code:
    import java.util.*;
    
    public class NonCovariantGenerics { 
    // Compile Error: incompatible types: 
    List<Shape> slist = new ArrayList<Rectangle>();
    In this listing List of Rectangle is not type-equivalent to a List of Shape, even if an Rectangle ...
  14. Supertype Wildcards with Generics

    by , 11-30-2011 at 12:12 AM
    In my last tip, I showed how you can use a wildcard with generics. It is also possible to use a supertype wildcards. In this case the wildcard is bounded by any base class of a particular class, by specifying <? super MyClass> or even using a type parameter: <? super T> (although you cannot give a generic parameter a supertype bound; that is, you cannot say <T super MyClass>). This allows you to safely pass a typed object into a generic type. Thus, with supertype wildcards you ...
  15. Unbounded Wildcards with Generics

    by , 11-30-2011 at 12:09 AM
    When you as a programmer decide to use an unbounded wildcard <?>, it appears to mean anything. and so using an unbounded wildcard seems equivalent to using a raw type. There are time that the compiler is indifferent as to using raw type or <?>. If you use <?> it can be considered as a decoration. When you are using the raw type, the generic parameter can hold any type. In this example I show an important use of unbounded wildcards. If you are dealing with multiple generic parameters, ...
  16. Dynamic Type Safety in Pre Java 5 Code Collections

    by , 11-29-2011 at 11:40 PM
    Sometimes is might be necessary to pass generic containers to pre-Java5 code. In those cases, it is possible that the old-style code can corrupt your containers. In order to address this issue, there are a set of utilities in the java.util.Collections package to address the issues around type-checking. There are a number of static methods designed for this. They all take the container that you are checking as the first argument and the type you want to enforce as the second argument. They are shown ...
  17. Comparing Objects and HashCode

    by , 11-29-2011 at 11:30 PM
    Another thing that many programmers forget when they make objects that they need to compare in their applications is that it is not enough to assume that if your object is a subclass of Object, that the hashCode method that you can use it in a HashMap, Hashtable or HashSet. In fact, the Java specification states that you must always override the hashCode when ever you override the equals method. Otherwise, you have violated one of the key tenants of Java in not ensuring that equal objects have equal ...
  18. Generics - Exceptions

    by , 11-29-2011 at 04:35 AM
    Due to erasure, exception use is limited with generics. As exceptions are know at both compile and at run time, it renders redundant the use of catch clauses. This also means that a generic class cannot inherit directly or indirectly from Throwable.

    One can though use type parameters in the throws clause of a method declaration. This will allow you to write generic code that varies with the type of a checked exception:

    Java Code:
    import java.util.List;
    
    public interface
    ...