What is meant by parameterized type?

Question

This link states the following:

The instantiation of a generic type with actual type arguments is called a parameterized type . Example (of a parameterized type):

Collection<String> coll = new LinkedList<String>();

So what is the parameterized type?

• Collection<String> or
• LinkedList<String>

Answer 1

They are both parameterized types: types that take other types as parameters.

The fact that you have different types on the two sides of the expression is irrelevant, and has to do with polymorphic behavior i.e. because LinkedList is a subtype of Collection.

Answer 2

Parameterized type generally is a class that deals with other object without interesting what type is it. The type may be defined using symbolic "name" and then passed when instance of class is created.

For example:

class MyClass<T> {
    private T obj;
    public MyClass<T>(T obj) {
        this.obj = obj;
    }
    public int getId() {
        return obj.hashCode();
    }
}

In example above MyClass wraps object of any type and executes its method hashCode() using the fact that this method always exists.

Here is how this class is used:

int sid = new MyClass<String>("aaaa").hashCode();

Please pay attention that you cannot say new MyClass<String>(123): the fact that object is created with parameter String dictates the type of constructor argument.

Coming back to your example Collection<String> means "collection of strings". This means that you cannot add object of other type to this collection.

Answer 3

It seems generic type and parameterized type are synonymous. But it seems not right to call for example Box<Integer> a generic type since in the sense of the word not generic anymore. So probably:

A generic type is the declaration with formal type parameter/s

class Box<T> { .. }

Box<T> is a generic type

A parameterized type is the declaration with actual type argument/s

Box<Integer> b;        

Box<Integer> is a parameterized type

A raw type is the declaration of a generic type with no actual type argument/s.

class Box<T> { .. }
Box b;

Box is a raw type

Answer 4

Here's a quick breakdown of the nomenclature...

• Type parameter: Simply the placeholder, i.e., "<T>"
• Type argument: Is passed to the type parameter when declaring, i.e., "<String>"
• Parameterized type (generic): Type with formal type parameter(s), i.e., "List<T>"
• Parameterized type (concrete): Type with declared type arguments(s) as parameters, i.e., "List<String>"

Answer 5

Both uses of collection

Collection<String> 
LinkedList<String>

are parameterized types here with String being the type used.

Answer 6

Even if this is a fairly old question, I still think I can add something - especially clarification to the difference between terms "generic type" and "parameterized type", which, in the beginning, confused me to some extent.

From the Java Docs Tutorial:

We call generic type to type definition, e.g.: SomeType<T>, and we call parameterized type to type invocation, e.g.: SomeType<SpecificType> (when we provide specific class as an argument to the type parameter).

E.g. List<T> is a generic type and List<String> is a parameterized type.

Answer 7

ParameterizedType represents a parameterized type such as Collection.

A parameterized type is created the first time it is needed by a reflective method, as specified in this package. When a parameterized type p is created, the generic type declaration that p instantiates is resolved, and all type arguments of p are created recursively. See TypeVariable for details on the creation process for type variables. Repeated creation of a parameterized type has no effect.

Instances of classes that implement this interface must implement an equals() method that equates any two instances that share the same generic type declaration and have equal type parameters.