JAVA中的泛型

一、泛型的概念

泛型是JAVA中的一个重要的概念，它允许你在编译时指定数据类型，从而使得代码更加灵活，更加通用。通过泛型，你可以在通用代码上操作不同数据类型，使得代码更加具有通用性。

二、泛型的使用场景

1、泛型接口：

泛型接口允许你定义一个接口，该接口可以应用于不同的数据类型的对象。例如：List是一个接口，但是List可以应用于List、List等。

2、泛型类：

泛型类允许你定义一个类，该类可以应用于不同的数据类型的对象。例如：ArrayList是一个类，但是ArrayList可以应用于ArrayList、ArrayList等。

3、泛型方法：

泛型方法允许你定义一个方法，并在该方法返回值类型前边使用泛型限制，例如：List中的<T> T[] toArray(T[] var1);方法的定义。

4、泛型参数：

泛型参数用来限制方法参数的数据类型，通过泛型参数，可以灵活的处理不同数据类型的参数。例如：List.add可以接收Integer类型的数据，也可以接收String类型的数据。

三、泛型的应用

假设有一个打印场景，传入的打印内容是不确定的，需要根据实际场景去决定，那么此时就需要使用泛型来解决这个问题， 通过泛型，可以定义一个方法，让方法可以接收不同类型的参数

1.1、JavaGenerics.java

/**  
 * java中的泛型使用：  
 * 假设有一个打印场景，传入的打印内容是不确定的，需要根据实际场景去决定，那么此时就需要使用泛型来解决这个问题，  
 * 通过泛型，可以定义一个方法，让方法可以接收不同类型的参数  
 */  
public class JavaGenerics {  
  
    /**  
     * 测试打印入口：  
     * 如果不使用泛型，那么需要使用两个方法分别打印字符串和数值，如果想要  
     * 打印其他类型的时候，那么就需要再定义一个方法，这样就会造成代码冗余  
     */  
    @Test  
    public void testPrint() {  
       // 单独定义具体的类实现Integer打印  
       IntegerPrinter integerPrinter = new IntegerPrinter(123);  
       integerPrinter.print();  
       // 单独定义具体的类实现String打印  
       StringPrinter stringPrinter = new StringPrinter("Hello");  
       stringPrinter.print();  
  
       // 单独定义方法实现String打印  
       printString("Hello");  
       // 单独定义方法实现Integer打印  
       printInteger(100);  
    }  
  
    /**  
     * 测试打印入口：  
     * 使用了泛型之后，只需要定义一个方法，就可以同时打印字符串和数值，  
     * 这样就可以解决代码冗余的问题，并且，如果需要打印其他类型，只需要定义一个方法即可，不需要再定义其他方法，  
     *  
     */    @Test  
    public void testGenericsPrint() {  
       // 只要定义一个类实现，接受一个泛型T，通过传递的T的类型，就可以实现打印不同类型的数据  
       GenericsPrinter<String> stringGenericsPrinter = new GenericsPrinter<>("Hello");  
       stringGenericsPrinter.print();  
       GenericsPrinter<Integer> integerGenericsPrinter = new GenericsPrinter<>(123);  
       integerGenericsPrinter.print();  
  
        // 只要定义一个方法实现，接受一个泛型T，通过传递的T的类型，就可以实现打印不同类型的数据  
       printGenerics("Hello");  
       printGenerics(123);  
  
       // 使用通配符后，List中的数据类型可以不受限制，可以灵活处理，只要符合通配符的范围即可。  
       List<Integer> integers = new ArrayList<>();  
       integers.add(123);  
       integers.add(456);  
       printGenerics(integers);  
       List<String> string = new ArrayList<>();  
       string.add("123");  
       string.add("456");  
       printGenerics(string);  
  
       // 这里直接会报错，因为已经限制了GenericsPrinter1传入的泛型T为Number的子类或者本身  
       // GenericsPrinter1<String> stringGenericsPrinter1 = new GenericsPrinter1<>();  
  
       // 这里直接会报错，因为已经限制了GenericsPrinter2传入的泛型T为Number的子类或者本身并且必须是实现了Serializable的子类  
       // GenericsPrinter2<String> stringGenericsPrinter2 = new GenericsPrinter2<>();  
  
       // 第一个参数传入的泛型T必须为Number的子类或者本身并且必须是实现了Serializable的子类  
       // 第二个参数传入的泛型K没有限制，可以传递String类型也可以传递Integer  
       GenericsPrinter3<Integer, String> stringGenericsPrinter3 = new GenericsPrinter3<>(123, "hello word");  
       stringGenericsPrinter3.print();  
    }  
  
    /**  
     * 打印数值  
     *  
     * @param integer 打印数值内容  
     */  
    private void printInteger(Integer integer) {  
       System.out.println("Integer: " + integer);  
    }  
  
    /**  
     * 打印字符串  
     *  
     * @param string 打印字符串内容  
     */  
    private void printString(String string) {  
       System.out.println("String: " + string);  
    }  
  
    /**  
     * 打印内容：因为T在JAVA中并不是一个类型，只是一个占位符，  
     * 那么需要明确告诉JAVA这里的T是一个泛型，才能正常编译通过，  
     * 做法是在方法的返回值前边加上<T>。  
     *  
     * @param context 打印内容，这里的T也可以是任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型，  
     *          并且可以使用extend来进行限制类型。参考GenericsPrinter3的使用  
     */  
    private <T> void printGenerics(T context) {  
       System.out.println("context: " + context);  
    }  
  
    /**  
     * 打印内容：如果要打印这种List的情况，但是又不想限制List的类型,那么就使用  
     * 通配符<?>来表示，这样就可以打印List中的任意类型了。  
     *  
     * @param context 打印内容，使用通配符<?>来表示，这样就可以打印List中的任意类型了，  
     *                通配符也可以使用extend和super来表示范围，如：  
     *                <? extends Number>表示泛型为Number或Number子类的类型，  
     *                <? super Number>表示泛型为Number或Number父类的类型  
     */  
    private void printGenerics(List<?> context) {  
       System.out.println("context: " + context);  
    }  
}

1.2、StringPrinter.java

/**  
 * StringPrinter：专门用于打印字符串的类  
 */  
public class StringPrinter {  
  
    String string;  
  
    public StringPrinter(String string) {  
       this.string = string;  
    }  
  
    public void print() {  
       System.out.println(string);  
    }  
}

1.3、IntegerPrinter.java

/**  
 * IntegerPrinter：专门用于打印整数的类  
 */  
public class IntegerPrinter {  
  
    Integer integer;  
  
    public IntegerPrinter(Integer integer) {  
       this.integer = integer;  
    }  
  
    public void print() {  
       System.out.println(integer);  
    }  
}

1.4、GenericsPrinter.java

/**  
 *  泛型类：泛型类就是将泛型定义在类上，泛型类的类型参数只能被使用在类和接口中  
 *  
 * @param <T> 泛型  
 */  
public class GenericsPrinter<T> {  
  
    T context;  
  
    public GenericsPrinter(T context) {  
       this.context = context;  
    }  
  
    public void print() {  
       System.out.println(context);  
    }  
}  
  
/**  
 * 有界限的泛型：限制传入的泛型类型必须继承自Number类  
 *  
 * @param <T> 泛型  
 */  
class GenericsPrinter1<T extends Number> {  
  
    T context;  
  
    public GenericsPrinter1(T context) {  
       this.context = context;  
    }  
  
    public void print() {  
       System.out.println(context);  
    }  
}  
  
/**  
 * 有界限的泛型：限制传入的泛型类型必须继承自Number类和Serializable类  
 * 注意：Number & Serializable顺序不能错，因为不管泛型参数是抽象类还是接口都必须使用extends关键字，  
 * 否则编译器会报错，由于JAVA的单一继承性，抽象类必须在前边且只有一个，使用&连接多个接口。  
 *  
 * @param <T> 泛型  
 */  
class GenericsPrinter2<T extends Number & Serializable> {  
  
    T context;  
  
    public GenericsPrinter2(T context) {  
       this.context = context;  
    }  
  
    public void print() {  
       System.out.println(context);  
    }  
}  
  
/**  
 * 有界限的泛型：可以传递多个泛型参数，  
 * 注意：Number & Serializable顺序不能错，因为不管泛型参数是抽象类还是接口都必须使用extends关键字，  
 * 否则编译器会报错，由于JAVA的单一继承性，抽象类必须在前边且只有一个，使用&连接多个接口。  
 *  
 * @param <T> 泛型，限制传入的泛型类型必须继承自Number类和Serializable类  
 * @param <K> 泛型，无限制  
 */  
class GenericsPrinter3<T extends Number & Serializable, K> {  
  
    T context;  
  
    K context1;  
  
    public GenericsPrinter3(T context, K context1) {  
       this.context = context;  
       this.context1 = context1;  
    }  
  
    public void print() {  
       System.out.println(context.intValue());  
       System.out.println(context);  
       System.out.println(context1);  
    }  
}