Краткий ответ

Параметр типа, объявленный у конструктора, действует только в объявлении и теле этого конструктора. Он не становится параметром всего класса и недоступен в полях, других конструкторах и методах класса.

Такой конструктор является обобщённым конструктором, даже если сам класс не является обобщённым. При каждом вызове компилятор может вывести отдельное значение его параметра типа.

Исторический контекст

Обобщения появились в Java 5, чтобы проверять совместимость типов на этапе компиляции и уменьшить количество небезопасных приведений. При этом Java сохранила совместимость с байт-кодом и библиотеками, созданными до появления generics, используя стирание типов.

Параметризация отдельных методов и конструкторов позволяет добавить типобезопасность точечно, не превращая весь класс в обобщённый. Это особенно полезно для фабричных методов, утилит и классов, которым нужно принять значение любого типа, но не обязательно хранить этот тип в параметрах самого класса.

Постановка проблемы

Важно различать область действия параметра типа класса, метода и конструктора. Если ошибочно считать параметр конструктора параметром класса, можно ожидать, что он будет доступен в других методах или определит тип состояния объекта.

Это приводит либо к ошибке компиляции, либо к неправильному проектированию API. Кроме того, успешный вывод типа при вызове конструктора не означает, что созданный объект становится параметризованным этим типом.

Подробное решение

Параметр типа конструктора записывается перед именем конструктора. Его область действия начинается в списке параметров конструктора и продолжается в его теле:

class Holder {
    private final Object value;

    <T> Holder(T value) {
        this.value = value;
    }

    static <T> Holder of(T value) {
        return new Holder<>(value);
    }
}

Holder text = new Holder<>("Java");
Holder number = new Holder<>(42);

В обоих вызовах параметр T конструктора выводится независимо: в первом случае это String, во втором — Integer. Однако класс Holder остаётся обычным, а не Holder<String> или Holder<Integer>.

Параметр T конструктора нельзя использовать в объявлении поля или в другом методе класса. Для этого другой метод должен объявить собственный параметр типа, причём совпадение имени не создаёт общей связи между параметрами:

class Holder {
    <T> Holder(T value) {}

    <T> T identity(T value) {
        return value;
    }
}

Здесь T конструктора и T метода — два независимых параметра. Их одинаковое имя является лишь соглашением и может вводить в заблуждение.

При стирании типов параметр конструктора обычно заменяется на свою верхнюю границу: на Object, если граница явно не задана, или на первый тип в списке границ. Поэтому параметризация конструктора не сохраняет тип значения во время выполнения.

Главный компромисс таков: обобщённый конструктор позволяет типобезопасно принимать значение, но не делает тип частью типа объекта. Если объект должен сохранять и возвращать конкретный тип без приведений, параметр типа обычно нужно объявлять у самого класса.

Ситуация из практики

Представим класс конфигурации, который принимает начальное значение любого типа, но позже должен возвращать его как значение исходного типа. Обобщённый конструктор обычного класса принимает значение типобезопасно, однако поле такого класса не может иметь тип конструктора T; после создания объекта связь с конкретным типом не выражена в его типе.

Возможны два варианта:

оставить обычный класс и хранить значение как Object. Это проще, но возвращение значения потребует приведения или дополнительного токена Class<T>;
сделать класс обобщённым, например Holder<T>. Это сохраняет тип в API, но распространяет параметризацию на объявления переменных, методы и места создания объектов.

Если объект должен предоставлять типизированное значение в дальнейшем, выбирают обобщённый класс. Если конструктор лишь нормализует входные данные или передаёт их дальше, а тип не является частью состояния API, достаточно обобщённого конструктора обычного класса. Такое решение сохраняет компактность интерфейса и не создаёт ложного впечатления, что объект параметризован.

Что кандидаты часто упускают

Чем обобщённый конструктор отличается от обобщённого класса?

Обобщённый конструктор имеет собственный параметр типа, который существует только в пределах конструктора. Обобщённый класс задаёт параметр типа для всего экземпляра: его можно использовать в полях, нестатических методах, конструкторах и других членах класса.

Поэтому вызов обобщённого конструктора не меняет тип самого класса. Объект обычного Holder не становится экземпляром отдельного типа Holder<String>.

Можно ли объявить параметр типа конструктора с тем же именем, что и параметр класса?

Да, но это создаёт затенение. Например, у класса может быть T, а у конструктора — другой, независимый T; одинаковые имена не связывают эти параметры.

Такой код допустим, но обычно ухудшает читаемость. Если параметры должны обозначать один и тот же тип, параметр следует оставить у класса и использовать его в конструкторе без повторного объявления.

Почему результат фабричного метода может сохранять тип, если сам конструктор его не сохраняет?

Фабричный метод может объявить собственный параметр типа и вернуть параметризованный класс. Например, метод вида static <T> Holder<T> of(T value) связывает тип аргумента с типом результата.

Для этого сам Holder должен быть объявлен как Holder<T>. Если класс не обобщён, фабричный метод может вывести T, но не сможет выразить его в типе возвращаемого объекта без использования другого механизма, например Class<T> или небезопасного приведения.