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
