Generics In Java

1.      Generics

a)  Generics in Java is one of important feature added in Java 5 along with Enum, autoboxing and varargs , to provide compile time type-safety.

b)     Generic in Java is added to provide compile time type-safety of code and removing risk of ClassCastException at runtime which was quite frequent error in Java code,

c)      Generics allows Java programmer to write more robust and type-safe code.

d)     generics expand your ability to reuse code and let you do so safely and easily.

2.      Non Generics Class using Object

a)      This makes NonGen able to store any type of object, as can the generic version

b)     Its not good because following  two reason .

               i.     explicit casts must be employed to retrieve the stored data

        ii.   many kinds of type mismatch errors cannot be found until run time.

3.      The General Form of a Generic Class

a)      syntax for declaring a generic class:

i.  class class-name<type-param-list> { // ...

b)     syntax for declaring a reference to a generic class

i.                    class-name<type-arg-list> var-name =new class-name<type-arg-list>(cons-arg-list);

4.      bounded types

a)      When specifying a type parameter, you can create an upper bound that declares the

       superclass from which all type arguments must be derived.

b)     This is accomplished through the use of an extends clause

c)      In addition to using a class type as a bound, you can also use an interface type.

 In fact,

d)     you can specify multiple interfaces as bounds.

e)      bound can include both a class type and one or more interfaces. In this case, the class type must be specified first.

f)       class Gen<T extends MyClass & MyInterface> { // ...

g)     Here, T is bounded by a class called MyClass and an interface called MyInterface. Thus,any type argument passed to T must be a subclass of MyClass and implement MyInterface.

h)     Syntax

i.  I <T extends superclass>

ii.  This specifies that T can only be replaced by superclass, or subclasses of superclass.

5.      Using Wildcard Arguments

a)      The wildcard argument is specified by the ?, and it represents an unknown type.

b)     One last point: It is important to understand that the wildcard does not affect what type of Stats objects can be created. This is governed by the extends clause in the Stats declaration. The wildcard simply matches any valid Stats object.

6.      Bounded Wildcards (Ex. Generic7)

a)      In general, to establish an upper bound for a wildcard, use the following type of wildcard

b)     expression:<? extends superclass>

c)      where superclass is the name of the class that serves as the upper bound

d)     You can also specify a lower bound for a wildcard by adding a super clause to a wildcard

e)      declaration. Here is its general form:<? super subclass>

f)       In this case, only classes that are superclasses of subclass are acceptable arguments. This is an exclusive clause, because it will not match the class specified by subclass.

7.      Creating a Generic Method(Ex Generic8)

a)       it is possible to create a generic method that is enclosed within a non-generic class.

b)     generic methods can be either static or non-static. There is no restriction in this regard.

c)      Generalized syntax

<type-param-list> ret-type meth-name(param-list) { // ...

8.      Generic Constructors (Ex Generic9)

a)      It is also possible for constructors to be generic, even if their class is not.

9.      Generic Interfaces

a)      you can also have generic interfaces

b)     In general, a generic interface is declared in the same way as is a generic class.

c)      In general, if a class implements a generic interface, then that class must also be generic, at least to the extent that it takes a type parameter that is passed to the interface. For example,the following attempt to declare MyClass is in error:

d)     class MyClass implements MinMax<T> { // Wrong!{ // OK

e)      Because MyClass does not declare a type parameter, there is no way to pass one to MinMax.

f)       In this case, the identifier T is simply unknown, and the compiler reports an error. Of course,if a class implements a specific type of generic interface, such as shown here:

g)     class MyClass implements MinMax<Integer> { // OKthen the implementing class does not need to be generic.

h)     Benefit of Generic Interface

i.  it allows you to put constraints (that is, bounds) on the types of data for which the interface can be implemented.

ii.     It can be implemented for different types of data.

i)       Syntax:

i.     interface interface-name<type-param-list> { //

ii.  Here, type-param-list is a comma-separated list of type parameters. When a generic interface is implemented, you must specify the type arguments, as shown here:

iii.                     class class-name<type-param-list> implements interface-name<type-arg-list> {

10.  Raw Types and Legacy Codes

a)      Because support for generics is a recent addition to Java, it was necessary to provide some transition path from old, pre-generics code. At the time of this writing, there are still millionsand millions of lines of pre-generics legacy code that must remain both functional and compatible with generics. Pre-generics code must be able to work with generics, and generic code must be able to work with pre-generic code.

b)     To handle the transition to generics, Java allows a generic class to be used without any type arguments. This creates a raw type for the class. This raw type is compatible with legacy code, which has no knowledge of generics. The main drawback to using the raw type is that the type safety of generics is lost.

c)      A raw type is not type safe. Thus, a variable of a raw type can be assigned a reference to any type of Gen object. The reverse is also allowed;

d)     Generic Class Hierarchies

11.  Rules of Genrics

a)      Parametrized type like Set<T> is subtype of raw type Set and you can assign Set<T> to Set, following code is legal in Java:

Set setOfRawType = new HashSet<String>();

setOfRawType = new HashSet<Integer>();

b)     Gen<int> strOb = new Gen<int>(53); // Error, can't use primitive type