What are Generics in Java?

Question

I don't really understand the point of generics. What do they do, how do you use them?

From what I can tell, all they do is check return types at compile times instead of run times to avoid running the program before an error is thrown. Is this all they do?

for example:

public <Integer> int test() {
    return 'c'; //will throw error at compile instead of runtime
}

I was reading something about how generics are arbitrary, and you should only use capital letters? This is kind of confusing.

Solution 1

Generics allow you to customize a "generic" method or class to whatever type you're working with. For example, suppose you have a method that adds two numbers together. In order to work with the types themselves, you might have to create multiple versions of this method. For instance:

public int Add(int a, int b)

public double Add(double a, double b)

public float Add(float a, float b)

Generics allow you to create a single method that is customized for the type that invokes it.

public <T> T Add(T a, T b)

T is substituted for whatever type you use.

Solution 2

Refer to the Fundamentals in Angelika Langer's FAQ – it's the best explanation of all things related to Java's generics you're likely to find. That said, the original primary goal of generics was to enable "typed" collections.

Solution 3

The simplest way I can think of to explain generics is the good ol' copy-paste metaphore:

public <COPY> PASTE addTwoThings(PASTE a, PASTE b) {
    return a + b;
}

You specify a type (in the <COPY> portion) and java use this type throughout the code block, and it will make sure that the types are compatible. By doing it this way, you avoid having to write:

• addTwoIntegers
• addTwoStrings
• addTwoMyObjects

etc. Don't confuse this for a preprocessor though, Java expects ONLY a type to be given.

Comments

[switz]

So what will be the outcome here?

[switz]

I'm reading this now, thanks.

[Chris Eberle]

The outcome is that if you specify "String" as the type (when you call it), then suddenly you've got a method that knows how to add two strings together. Likewise, if you specify an integer as the type, it will add two integers and return an integer.

[switz]

Okay, that's really clear, thanks! Now if I do something like Stack<Location> = new Stack<Location>; does that mean I have a stack that can only utilize Location objects?

[Erik Funkenbusch]

@Switz - Maybe. You have a stack of Location or Location derived objects. For instance, if you have a class called "MyLocation" derived from Location, you can add it to your stack.

[switz]

Thanks, really cleared it up!

[JAVA]

thanks for the link it was really helpful :)

[Premraj]

Apart from the above answer: we use generics in ADT for type safety

[Novaterata]

Ironically generics are a poor choice for numeric types as mathematical operations are not part of an Interface. So this is kind of a bad example.

[Claude Martin]

Generics are not templates. Primitives do not (yet) have common type in Java. So T could not be anything that then can be used for any of these types. There are wrappers and they all extend Number, but then you'd just be using BigDecimal internally. So this is just the worst example for generics. Maybe in the future Java will have a unified type system, but we are not there yet.

[MC Emperor]

This looks like C# code rather than Java code.