Generics Module 2Generics Module Generics Module 2.pptx

Generics Module 2.pptx

1. Generics

2. Contents Introduction Benefits of Generics Generic Classes and Interfaces Generic Methods Wildcard Generic Types Restrictions on Generics

3. Introduction Enables to create classes, interfaces, and methods in which the type of data upon which they operate is specified as a parameter. Introduced in Java by jdk 1.5. Generics means parameterized types. Generics add the type-safety. Generics add stability to your code by making more of your bugs detectable at compile time.

4. Why Generics? The functionality of Gen class can be achieved without generics by specifying Object type and using proper casting whenever required. Then why we use Generics? Java compiler does not have knowledge about the type of data actually stored in NonGen . So: Explicit casts must be employed to retrieve the stored data. Several type mismatch errors cannot be found until run time.

5. Why Generics? Stronger type checks at compile time Elimination of casts ArrayList list = new ArrayList (); list.add ("hello"); String s = (String) list.get (0); Using generics: List<String> list = new ArrayList <String>(); list.add ("hello"); String s = list.get (0); // no cast Enabling programmers to implement generic algorithms. We can implement generic algorithms that work on collections of different types, can be customized, and are type safe and easier to read.

6. Example

7. Generics Work Only with Objects When declaring an instance of a generic type, the type argument passed to the type parameter must be a class type. Gen<int> strOb = new Gen<int>(53); The above declaration is an error. A reference of one specific version of a generic type is not type compatible with another version of the same generic type. iOb = strOb ; // Wrong!

8. Generic Class

9. General Form of Generic Class The generics syntax for declaring a generic class: class class-name<type-param-list> { // ... } The syntax for declaring a reference to a generic class: class-name<type- arg -list> var-name = new class-name<type- arg -list>(cons- arg -list);

10. Generic Class with Multiple Type Parameters

11. Generic Class with Multiple Type Parameters

12. Problem Create a generic class that contains a method that returns the average of an array of numbers of any type, including integers, floats, and doubles.

13. Possible Solution

14. Why Error? The compiler has no way to know that you are intending to create Gen class objects using only numeric types. When we try to compile Gen class, an error is reported that indicates that the doubleValue ( ) method is unknown. We need some way to tell the compiler that we intend to pass only numeric types to T.

15. Bounded Types Used to limit the types that can be passed to a type parameter. When specifying a type parameter, we can create an upper bound that declares the super-class from which all type arguments must be derived. <T extends superclass> A bound can include both a class type and one or more interfaces. class Gen<T extends MyClass & MyInterface > Any type argument passed to T must be a subclass of MyClass and implement MyInterface .

16. Solution

17. WILD CARD Generics

18. Example (comparing object values) method compare(Stats<Integer>) in the type Gen<Integer> is not applicable for the arguments (Gen<Double>)

19. Gen<Integer> obj1 Memory representation of objects Gen<Double> obj2 Object of Gen<Integer> required

20. wildcard generic (i.e. it accepts any type) Solution

21. Problem Create a generic class Stats that contains a method sameAvg ( ) that determines whether two different Stats class objects contain arrays that yield the same average or not; no matter what type of numeric data each object holds. For example , if one object contains the double values 1.0, 2.0, and 3.0, and the other object contains the integer values 2, 1, and 3, then the averages will be the same.

22. Possible Solution method same_Avg (Stats<Integer>) in the type Stats<Integer> is not applicable for the arguments (Stats<Double>)

23. Why Error? It will work only with the objects of same type. if the invoking object is of type Stats<Integer>, then the parameter ob must also be of type Stats<Integer>.

24. Wildcard Argument The wildcard simply matches the validity of object. The wildcard argument is specified by the ?, and it represents an unknown type. boolean same_Avg (Stats<?> ob ) { if(average() == ob.average ()) return true; return false; } Important: It is important to understand that the wildcard does not affect what type of Stats class objects can be created. This is governed by the extends clause in the Stats class declaration. The wildcard simply matches any valid Stats class object.

25. Bounded Wildcards A bounded wildcard is especially important when you are creating a generic type that will operate on a class hierarchy.

26. Bounded Wildcards Notice that Coords specifies a type parameter bounded by TwoD .

27. Bounded Wildcards Problem Starts if I want to create a methods showXYZ () for ThreeD and FourD Object.

28. Bounded Wildcards

29. Generic Method

30. Generic Method It is possible to declare a generic method that uses one or more type parameters. Methods inside a generic class are automatically generic relative to the type parameters. It is possible to create a generic method that is enclosed within a non-generic class.

31. Generic Method The type parameters are declared before the return type of the method. Generic methods can be either static or non-static. <type-param-list> ret-type method-name(param-list) {…} Example: static <T, V extends T> boolean isIn (T x, V[] y) This ability to enforce type safety is one of the most important advantages of generic methods.

32. Example

33. Example

34. Example

35. Generic Constructors

36. Generic Constructors

37. Generic Interfaces

38. Generic Interfaces Generic interfaces are specified just like generic classes.

39. Generic Interfaces Generic interfaces are specified just like generic classes. Example: interface MinMax <T extends Comparable<T>> { T min(); T max(); } The implementing class must specify the same bound. Once the bound has been established, it need not to be specified again in the implements clause.

40. Generic Interfaces class MyClass <T extends Comparable<T>> implements MinMax <T extends Comparable<T>> { //Wrong 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: class MyClass implements MinMax <T> { // Wrong! Because MyClass does not declare a type parameter, there is no way to pass one to MinMax . 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: class MyClass implements MinMax <Integer> { // OK

41. Generic Interfaces interface MinMax <T extends Comparable<T>> { T min(); T max(); } class Myclass <T extends Comparable<T>> implements MinMax <T> { … }

42. Example

43. Raw Types and Legacy Code

44. Raw Types and Legacy Code 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.

45. Raw Types

46. Generic Class Hierarchies

47. Generic Class Hierarchies Generic classes can be part of a class hierarchy in just the same way as a non-generic class. Thus, a generic class can act as a superclass or be a subclass. The key difference between generic and non-generic hierarchies is that in a generic hierarchy, any type arguments needed by a generic superclass must be passed up the hierarchy by all subclasses. This is similar to the way that constructor arguments must be passed up a hierarchy.

48. Using a Generic Superclass

49. Using a Generic Superclass

50. A Generic Subclass

51. A Generic Subclass

52. A Generic Casting You can cast one instance of a generic class into another only if the two are otherwise compatible and their type arguments are the same. For example, assuming the foregoing program, this cast is legal: (Gen<Integer>) iOb2 // legal because iOb2 includes an instance of Gen<Integer>. But, this cast: (Gen<Long>) iOb2 // illegal is not legal because iOb2 is not an instance of Gen<Long>.

53. Overriding Methods in a Generic Class

54. Overriding Methods in a Generic Class

55. Erasure Usually, it is not necessary to know the details about how the Java compiler transforms your source code into object code. However, in the case of generics, some general understanding of the process is important because it explains why the generic features work as they do—and why their behavior is sometimes a bit surprising.

56. Erasure In general, here is how erasure works. When your Java code is compiled, all generic type information is removed (erased). This means replacing type parameters with their bound type, which is Object if no explicit bound is specified, and then applying the appropriate casts (as determined by the type arguments) to maintain type compatibility with the types specified by the type arguments. The compiler also enforces this type compatibility. This approach to generics means that no type parameters exist at run time. They are simply a source-code mechanism.

57. Erasure // Here, T is bound by Object by default. class Gen<T> { T ob ; // here, T will be replaced by Object Gen(T o) { ob = o; } // Return ob. T getob () { return ob ; } } // Here, T is bound by String. class GenStr <T extends String> { T str; // here, T will be replaced by String GenStr (T o) { str = o; } T getstr () { return str; } }

58. Ambiguity Errors The inclusion of generics gives rise to another type of error that you must guard against: ambiguity. Ambiguity errors occur when erasure causes two seemingly distinct generic declarations to resolve to the same erased type, causing a conflict.

59. Erasure class Gen extends java.lang.Object { java.lang.Object ob ; Gen( java.lang.Object ); java.lang.Object getob (); } class GenStr extends java.lang.Object { java.lang.String str; GenStr ( java.lang.String ); java.lang.String getstr (); }

60. Some Generic Restrictions Type Parameters Can’t Be Instantiated // Can't create an instance of T. class Gen<T> { T ob ; Gen() { ob = new T(); // Illegal!!! } }

61. Some Generic Restrictions Restrictions on Static Members class Wrong<T> { // Wrong, no static variables of type T. static T ob ; // Wrong, no static method can use T. static T getob () { return ob ; }

62. Some Generic Restrictions Generic Array Restrictions // vals = new T[10]; // can't create an array of T // Gen<Integer> gens[] = new Gen<Integer>[10]; // Wrong! it’s valid to declare a reference to an array of type. cannot create generic exception classes. Cannot Instantiate Generic Types with Primitive Types Pair<int, char> p = new Pair<>(8, 'a'); Cannot Create, Catch, or Throw Objects of Parameterized Types

63. Exercise Write a Java program to create a generic method that takes a list of any type and a target element. It returns the index of the first occurrence of the target element in the list. Return -1 if the target element cannot be found.