Java创建一个通用类

示例

泛型使类，接口和方法能够将其他类和接口用作类型参数。

本示例使用通用类Param获取单个类型参数 T，并用尖括号（<>）分隔：

public class Param<T> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
       this.value= value;
    }
}

要实例化此类，请提供类型参数代替T。例如Integer：

Param<Integer> integerParam = new Param<Integer>();

type参数可以是任何引用类型，包括数组和其他泛型类型：

Param<String[]> stringArrayParam;
Param<int[][]> int2dArrayParam;
Param<Param<Object>> objectNestedParam;

在Java SE 7和更高版本中，可以将一个空的一组类型参数（<>）称为菱形替换类型参数：

Param<Integer> integerParam = new Param<>();

与其他标识符不同，类型参数没有命名约束。但是，它们的名称通常是大写目的的首字母。（甚至在整个JavaDocs中都是这样。）
示例包括T“ type”，E“ element”和K/ V“ key” /“ value”。

扩展泛型类

public abstract class AbstractParam<T> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
       this.value= value;
    }
}

AbstractParam是使用类型参数声明的抽象类T。扩展此类时，可以用编写在里面的类型参数替换该类型参数<>，或者可以保持不变。在下面的第一个和第二个示例中，String并Integer替换type参数。在第三个示例中，type参数保持不变。第四个示例根本不使用泛型，因此类似于类具有Object参数的情况。编译器会警告您AbstractParam是原始类型，但会编译ObjectParam该类。第五个示例具有2个类型参数（请参见下面的“多个类型参数”），选择第二个参数作为传递给超类的类型参数。

public class Email extends AbstractParam<String> {
    // ...
}

public class Age extends AbstractParam<Integer> {
    // ...
}

public class Height<T> extends AbstractParam<T> {
    // ...
}

public class ObjectParam extends AbstractParam {
    // ...
}

public class MultiParam<T, E> extends AbstractParam<E> {
    // ...
}

用法如下：

Email email = new Email();
email.setValue("test@example.com");
String retrievedEmail = email.getValue();

Age age = new Age();
age.setValue(25);
Integer retrievedAge = age.getValue();
int autounboxedAge = age.getValue();

Height<Integer> heightInInt = new Height<>();
heightInInt.setValue(125);

Height<Float> heightInFloat = new Height<>();
heightInFloat.setValue(120.3f);

MultiParam<String, Double> multiParam = new MultiParam<>();
multiParam.setValue(3.3);

请注意，在Email类中，该方法的行为就像它具有的签名一样，而该方法的行为就像在声明时一样。T getValue()String getValue()void setValue(T)void setValue(String)

也可以使用带有空花括号（{}）的匿名内部类实例化：

AbstractParam<Double> height = new AbstractParam<Double>(){};
height.setValue(198.6);

请注意，不允许将Diamond与匿名内部类一起使用。

多种类型的参数

Java提供了在通用类或接口中使用多个类型参数的能力。通过在尖括号之间放置逗号分隔的类型列表，可以在类或接口中使用多个类型参数。例：

public class MultiGenericParam<T, S> {
    private T firstParam;
    private S secondParam;
   
    public MultiGenericParam(T firstParam, S secondParam) {
       this.firstParam= firstParam;
       this.secondParam= secondParam;
    }
    
    public T getFirstParam() {
        return firstParam;
    }
    
    public void setFirstParam(T firstParam) {
       this.firstParam= firstParam;
    }
    
    public S getSecondParam() {
        return secondParam;
    }
    
    public void setSecondParam(S secondParam) {
       this.secondParam= secondParam;
    }
}

使用方法如下：

MultiGenericParam<String, String> aParam = new MultiGenericParam<String, String>("value1", "value2");
MultiGenericParam<Integer, Double> dayOfWeekDegrees = new MultiGenericParam<Integer, Double>(1, 2.6);