Java: Generics Interview Questions

public static <T> T returnLast(T[] array) {
    T lastItemFound = null;
    for (int i = 0; i < array.length; i++) { 
        if (array[i] != null) {
            lastItemFound = array[i];
        } 
     } 
    return lastItemFound;
}

• Replace generic types with bounds or Object.
• Bytecode only contains regular classes and methods.
• Concept of bridge method generation. This is a more advanced answer.

List<String> aList = new ArrayList<>();
aList.add("string1");

Generics allows for types to be bounded by multiple types.

public class Box<T extends ClassA & ClassB> {

This restricts the types provided by the user to be a subclass of ClassA and ClassB. Remember, taken straight from the official documentation: If one of the bounds is a class, it must be specified first.

A raw type is the name of a generic class or interface without any type arguments were a non-generic type is a regular class. More specifically, generics add compile time type safety with the use of type parameter provided by the user. If these are omitted, you loose the intended type safety. Non-generic classes do make this contract.

The unbounded wildcard <?> represents any Object. <Object> represents specifically the Object type.

Though this may seem ok at face value, lets consider what happens after type erasure. At runtime, the createArray() is return Object[]. So while this code may look valid at compile time:

Integer[] array = createArray(10);
}

At runtime, we’ve are assigning an Object[] to a variable declared to be a Integer[] which violates type safety.

Used in Java generics, a type parameter is used when a type can be used as a parameter in a class, method, or interface.

1. Provides better type safety, especially when working with Lists (or Collections). We can declare a List to contain objects of just one type.
2. Avoiding unnecessary casts that clutter up code.
3. Allows for the creation of methods and classes that can be used on with different types. No need to sublcass or create duplicates.

1. With respect to method invocations, type inference allows you to invoke generic methods as you would a ordinary method (omitting the type arguments)
2. With class instantiation, you can invoke the constructor of a generic class using an empty set of type parameters ().

public class ClassA {}
public interface ClassB {}
public class ClassC extends B implements Comparable{}

List<? extends A> – Defines a wildcard bounded by the class A. Type arguments provide can include any class that extends or implements (if A is a interface) A. This syntax is typically used for example, in a method parameter definition.

List<T extends A> – This definition also accepts type arguments that are extends/implements A. However, this syntax is applicable for generic class, interface or method definitions.

Both are an example of bounded wildcards. List<? extends A> will accept any parameterized typed List with a type argument that is a subclass of A or if A is an interface, implements A. This is an example of a upper bounded wildcard. List <? super A>? accepts any List whos type that is a super class of A. This is an example of a lower bounded wildcard.

No you cannot. Even though String is a subclass of Object, this relationship does not exist between List<String> and List<Object>?

1. Valid. b (ClassB) is a subclass of ClassA, thus the b can be assigned to to “a” since A is of type Class A.
2. Invalid. “a” and “a2” are of different types. “a” is a ClassA<String> and a2 is a ClassA<Integer>
3. Invalid. Because “b” is actually a subclass of ClassA<String>.
4. Valid. “a” is a super class of “c1”, thus “a” can be assigned c1.
5. Invalid. Since “a” is a super class of “c1” so while “c1” is a ClassA, the opposite is not true.
6. Invalid. “c1” is the parameterized type ClassC<String> and “c2” is the parametrized type ClassC<Integer>. There is no relationship between these two parametrized types even if the generic class is the same.
7. Valid. “a2” is actually super class (ClassA) of a ClassC. When “c2” is created, it is of a parameter type ClassC<Integer> which extends ClassA<Integer>. ClassA<Integer> is the type of “a2”.

It’s important to know that the wildcard character (?) represent unknown types and Object represents specifically the object type.

• A variable declared as List can be assigned List,List or even List
• List can only be assigned List
• It cannot be assigned List<String> even though Strings are a subclass of Object and a String can be added to a List declared as List<Object>.

We don’t want to duplicate the Box class for every single type of object we want to store. Instead, we’ll convert Box into a generic class using a type parameter T.

public class Box<T> {
    private T object;

    public void set(T object) { this.object = object; }
    public T get() { return object; }
}

No. Think of how we pass type arguments during the generic type invocation process. Since static fields are shared by all classes of an instance, it does not make sense to have static fields who are type parameters since different instances of the Class can be parameterized by different types.

No, it will not compile. The type parameter T is non-static but is referenced in a static context. More generally, you cannot use type parameters in statically defined fields.

No, this is not a valid assignment. Node<Shape> is not a super class of Node<Circle> even if Shape is a super class of Circle.

No Java generics cannot be applied to primitive types.

No, you cannot create an instance like the following:

public class Test <T> {	
    public T getSomething() {
        T t = new T(); // error, will not compile
        return t;
    }
}

However, there are workarounds to use parameterized factory types to create instances:

public class Test<T> {
    private Supplier<T> supplier;
    
    Test(Supplier<T> supplier) {
        this.supplier = supplier;
    }

    public T getSomething() {
        return supplier.get();
    }
}
/ ** **/
Supplier<String> stringSupplier = () -> "abc";
Supplier<Integer> integerSupplier = () -> Integer.valueOf(1);

Test<String> s = new Test<>(stringSupplier);
String str = s.getSomething();
	
Test<Integer> n = new Test<>(integerSupplier);
Integer num = n.getSomething();

Unbounded wildcards can be useful when are writing a method that does not need to know (or deal with) actual type. A simplistic example is a method to return the first non-null value of a List. We don't care about actual type of the contents of the List.

• <? extends T>
• <? super T>

• Stronger compile time type checking./li>
• Remove unnecessary type casting.
• Enabling programmers to implement generic algorithms.