Generics

First, the two kinds of cast

String s = "hello";
Object obj = s;              // upcast. Always safe. No cast written.

Object o = 10;
String bad = (String) o;     // downcast. Compiles. Throws at run time.

The error message is worth reading once:

class java.lang.Integer cannot be cast to class java.lang.String

The JVM found out at the moment it tried. Not before.

Generics: tell the compiler once

class Box<T> {
    private T value;
    Box(T value) { this.value = value; }
    T get() { return value; }
}

T is a type parameter. It is a placeholder. You fill it in when you create the box:

Box<Integer> b = new Box<>(10);
int n = b.get();                    // no cast. The compiler knows it is an Integer.
System.out.println(b.get() + 5);    // 15. Works.

Box<String> s = new Box<>("hello");
s.get().toUpperCase();              // String methods available, no cast

And the mistake from before will not compile at all:

Box<Integer> b = new Box<>(10);
String bad = b.get();     // ERROR at COMPILE time, not run time

That move, from a run time crash to a compile error, is the entire point of generics.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. Upcasting needs no cast. Downcasting does. Why is one safe and the other not?

   Show the answer

   Upcasting goes from a specific type to a general one. A Dog is always an Animal, so the compiler knows it can never fail. No cast needed.

   Downcasting goes the other way, from general to specific. An Animal might be a Dog, or it might be a Cat. The compiler cannot tell, because the object could have come from a file, a user, or an API call.

   So you write the cast to say "I know what this is". If you are wrong, the JVM finds out while the program is running and throws a ClassCastException.

   That is the whole problem generics were invented to remove. A cast is you promising the compiler something it cannot check.

2. `List<String>` and `List<Integer>` have the same class at run time. What does that tell you?

   Show the answer

   That generics exist only for the compiler. The type is checked, then thrown away. This is called type erasure.

   After compiling, Box<String> and Box<Integer> are both just Box, holding Object. The compiler inserted the casts for you, and checked them all before it did.

   It was done this way for compatibility. Generics arrived in Java 5, and code written before that had to keep working, so the bytecode could not change shape.

   The cost shows up in odd rules: you cannot write new T(), you cannot make a T[], and you cannot ask if (x instanceof List<String>). At run time none of that information exists.

3. Why does `<T extends Number>` let you call `doubleValue()` when plain `<T>` does not?

   Show the answer

   Because plain T could be anything. The compiler has to assume the worst, which is Object, and Object has no doubleValue().

   <T extends Number> narrows the promise. Whatever T turns out to be, it is at least a Number. So every method on Number is available inside your class.

   You are trading flexibility for capability. Fewer types are allowed in, and you can do more with the ones that get in.

   Note the keyword: extends, even when the bound is an interface. <T extends Comparable<T>> is normal Java. Generics reuse extends for both, and there is no implements here.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

4 exercises95 pointsabout 100 minutes

class OldBox {
    private Object value;
    OldBox(Object value) { this.value = value; }
    Object get() { return value; }
}

class NewBox<T> {
    private T value;
    NewBox(T value) { this.value = value; }
    T get() { return value; }
}

public class BoxOfAnything {
    public static void main(String[] args) {
        OldBox old = new OldBox(10);
        // System.out.println(old.get() + 5);      // uncomment: what error?
        String wrong = (String) old.get();          // compiles. Then what?

        // TODO: do the same two things with NewBox<Integer> and compare
    }
}

public class Pair<K, V> {
    // TODO: two fields, a constructor, and getters

    // TODO: swap() -> returns a Pair<V, K> with the halves exchanged

    // TODO: a STATIC generic method that builds a Pair without repeating the types:
    //       Pair<String,Integer> p = Pair.of("Atlas", 101);

    // TODO: toString

    public static void main(String[] args) {
        // build a Pair<String,Integer>, print it, swap it, print that
        // build a Pair<Integer,Boolean> and show the same code works
    }
}

import java.util.*;

class Stats<T> {
    private final List<T> values = new ArrayList<>();
    void add(T v) { values.add(v); }

    // TODO: this will not compile. Work out why, then fix the class header.
    // double sum() {
    //     double total = 0;
    //     for (T v : values) total += v.doubleValue();
    //     return total;
    // }
}

public class Bounds {
    // TODO: static <T extends Comparable<T>> T largest(List<T> items)

    public static void main(String[] args) {
        // TODO: use Stats with Integer and with Double
        // TODO: show new Stats<String>() is now a compile error, and read the message
        // TODO: use largest() on a List<String> and a List<Integer>
    }
}

import java.util.*;

public class Erasure {
    // TODO: uncomment one at a time. Each fails. Predict the reason first.
    // static <T> T makeOne() { return new T(); }
    // static <T> T[] makeArray() { return new T[10]; }
    // static void f(List<String> a) { }
    // static void f(List<Integer> a) { }

    public static void main(String[] args) {
        List<String>  ls = new ArrayList<>();
        List<Integer> li = new ArrayList<>();

        System.out.println("same class at run time? " + (ls.getClass() == li.getClass()));
        System.out.println("class name: " + ls.getClass().getName());

        // TODO: use a raw type to put an Integer into a List<String>. It compiles.
        // TODO: then read it back as a String and watch what happens.
    }
}