Java Generic Constructor

A generic constructor is a constructor that declares its own formal type parameters, distinct from any type parameters declared by the enclosing class. This allows the constructor to enforce type constraints and perform type inference specifically for the instantiation process, regardless of whether the enclosing class itself is generic or non-generic.

Syntax

The type parameter section, enclosed in angle brackets (<>), must precede the constructor’s name.

public class ClassName {
    // <T> is the formal type parameter of the constructor
    public <T> ClassName(T parameter) {
        // Constructor implementation
    }
}

Core Mechanics

1. Independence from Class Generics

A generic constructor’s type parameters are scoped strictly to the constructor. If the enclosing class is also generic, the constructor can declare type parameters that are entirely independent of the class-level type parameters.

public class Container<T> {
    private T item;

    // 'T' is the class type parameter.
    // 'E' is the constructor type parameter.
    public <E extends Number> Container(T item, E numericMetadata) {
        this.item = item;
        System.out.println(numericMetadata.doubleValue());
    }
}

2. Type Inference

When a generic constructor is invoked, the Java compiler typically infers the type arguments based on the actual arguments passed to the constructor.

public class Processor {
    public <T> Processor(T input) {
        System.out.println(input.getClass().getName());
    }
}

// The compiler infers T as java.lang.Integer
Processor p1 = new Processor(100); 

// The compiler infers T as java.lang.String
Processor p2 = new Processor("Data"); 

3. Explicit Type Witness

If the compiler cannot infer the type, or if you need to enforce a specific type hierarchy, you can provide an explicit type witness. The type witness is placed in angle brackets immediately before the class name in the new expression.

// Explicitly defining T as Number, rather than letting it default to Integer
Processor p3 = new <Number>Processor(100);

Bounded Type Parameters in Constructors

Generic constructors support bounded type parameters using the extends keyword to restrict the types that can be passed during instantiation. Multiple bounds can be specified using the & operator.

public class Validator {
    // T must be a subclass of Number and implement Comparable
    public <T extends Number & Comparable<T>> Validator(T value) {
        // Implementation
    }
}

Interaction with the Diamond Operator

When instantiating a generic class that also has a generic constructor, the syntax must accommodate both the class type arguments and the constructor type arguments. If you use an explicit type witness for the constructor, you cannot use the diamond operator (<>) for the class type parameters; both must be explicitly declared.

public class Wrapper<C> {
    public <M> Wrapper(C content, M metadata) {
        // Implementation
    }
}

// Standard inference for both class (String) and constructor (Integer)
Wrapper<String> w1 = new Wrapper<>("Text", 42);

// Explicit type witness for constructor requires explicit class type arguments
Wrapper<String> w2 = new <Number>Wrapper<String>("Text", 42); 

// ILLEGAL: Cannot use diamond operator when explicitly passing constructor type arguments
// Wrapper<String> w3 = new <Number>Wrapper<>("Text", 42); // Compilation Error

Tired of Poor Java Skills? Fix That With Deep Grasping!Learn More

Methods

Classes

Constructors

Type Declarations

Lambdas & Method References

Generics

Pattern Matching

Variables

Fields

Parameters

Annotations

Nested Classes

Exception Handling

Control Flow

Loops

Packages & Imports

Primitive Types

Comments

Comparison Operators

Logical & Conditional Operators

Arithmetic Operators

Assignment Operators

Type Operators

Unary Operators

Bitwise Operators

Shift Operators

Java Generic Constructor

Syntax

Core Mechanics

1. Independence from Class Generics

2. Type Inference

3. Explicit Type Witness

Bounded Type Parameters in Constructors

Interaction with the Diamond Operator

​Syntax

​Core Mechanics

​1. Independence from Class Generics

​2. Type Inference

​3. Explicit Type Witness

​Bounded Type Parameters in Constructors

​Interaction with the Diamond Operator

Syntax

Core Mechanics

1. Independence from Class Generics

2. Type Inference

3. Explicit Type Witness

Bounded Type Parameters in Constructors

Interaction with the Diamond Operator