Before generics, all the collection classes (then just ArrayList, Stack, and Queue) were defined to hold objects of type Object (the root class). Thus, you could add integers and strings to the same collection, and when you took items out of the collection, you had to cast them to their “real” type. This was ugly, and it was error-prone (the compiler could not tell whether you had a collection of integers and added a string).

With generics, the designer of the class (the person who creates the Stack class) can say, “This class will hold only one type, and that type will be defined by the developer who makes an instance of this class.”

The user of the generic Stack class (that’s you) defines an instance of the Stack and the type it will hold. The compiler can now enforce that only objects of the designated type are stored in the collection—that’s type safety. That’s important because, as you’ve seen, you’ll often want to use a collection polymorphically, and if there’s a string lurking in what you think is a collection of ints, you may be surprised when you try to divide each of them by 2.

The designer adds a type placeholder (technically called a type parameter), which is usually represented by the letter T in angle brackets:

class Stack<T>

The user of the Stack class puts in the actual type when instantiating the class, like this:

Stack<Employee> = new Stack<Employee>