Generics

Question 1

Why Java Generics?

Answer 1

Bugs that may appear at runtime (due to casts and then accessing illegal methods) can be detected at compile time.
Allows compile time checking of java types, removes requirement to cast objects.

Question 2

What are the 3 types of generics?

Answer 2

Generic types
Generic methods
Generic constructors

Question 3

A generic container is…

Answer 3

using a type variable conventionally a single uppercase letter i.e.
public class Container {
       private T contents;
       public void add(T contents) {
               this.contents = contents;
       }

Container containedDouble;
containedDouble = new Container();

Question 4

Why use generic types?

Answer 4

You can reuse code with different types.

Question 5

Common type parameter names

Answer 5

E - element
K - key
N - number
T - type
V - value
S, U, V, etc - 2nd 3rd 4th types.

Question 6

A generic method is…

Answer 6

A method with a type variable before the return variable i.e.
public static void genericMethod(S var){
}

MyClass object = new MyClass();
String a = object.genericMethod("Hello");

Question 7

A generic constructor is…

Answer 7

public class MyClass{
        MyClass(){
        }
}

Question 8

What is a bounded type?

Answer 8

When you want a class/method to also exhibit certain properties you can make it extend a supertype or implement an interface i.e.
public void genericMethod(S input) means to legally compile the argument must be a number or subtype of it.

Question 9

What is subtyping?

Answer 9

Double and Integer are subtypes of Number
Container and Container are NOT subtypes of Container
Container is a subtype of Container extends Number>
? is a known wildcard.

Question 10

What is type erasure?

Answer 10

As generics were late to java, type erasure allows for backwards compatability. The compiler removes all type information from parameters and arguments within generic classes/methods. i.e. Spoon -> Spoon

Question 11

What is heap pollution?

Answer 11

Heap pollution is the situation when a variable of a declared parameterised type refers to an instance that is not of that parameterised type.

i.e. List l = new ArrayList();
List ls = l;