java泛型编程初识

1.泛型解决的是什么问题

很多类、接口、方法中逻辑相同，只是操作的对象类型不同，这个时候就可以使用泛型。泛型可以定义一个模板，这个模板中实现了相对应的逻辑，但是实际操作的对象类型需要指定。泛型字面意思就是将类型泛化，各种类型都可以。

2.泛型实例化语句

List、Set、map等接口及其子类就使用到了泛型,可以在<>内指定实际存储数据类型，这个类型必须是引用类型，int、double这些基本类型不能用来实例化泛型。
实际存储对象的类型可以在实例化时指定,如果实例化时不指定实际类型，那么存储对象的类型就是Object
示例:

// 指定实际存储数据类型
List<String> list = new ArrayList<>();
// 不指定实际存储数据类型,默认存储Object类型
List list2 = new ArrayList<>();

3.自定义泛型

泛型类成员对象或方法都不能是静态的，因为类在加载时不知道实际的数据类型，不能为其分配空间

1)自定义泛型类或接口

语法:
class<T1, T2, T3…>{}
interface<T1, T2, T3…>{}
T1,T2,T3是类型占位符，根据实际指定的类型进行替换,如果实际传入String,Double,Integer，那么T1就被替换为String,T2就被替换为Double,T3就被替换为Integer。当然也可以定义更多的类型
泛型类示例:

public class Test6 {
    public static void main(String[] args) {
    	// 指定实际类型
        CuteCat<String, Integer> cuteCat = new CuteCat<>("天天", 3);
        cuteCat.show();
		
		// 不指定类型，根据传入数据推导
        CuteCat cuteCat1 = new CuteCat("疯疯", 4);
        cuteCat1.show();
    }
}

class CuteCat<T1, T2> {
    private T1 value1;
    private T2 value2;

    public CuteCat(T1 value1, T2 value2) {
        this.value1 = value1;
        this.value2 = value2;
    }

    public void show() {
        System.out.println("value1:" + value1);
        System.out.println("value2:" + value2);
    }
}

泛型接口示例:

public class Test7 {
    public static void main(String[] args) {
        Dragon<ArrayList, Hashtable> dragon = new Dragon<ArrayList, Hashtable>() {
            @Override
            public void func1(ArrayList arrayList) {
                System.out.println(arrayList.getClass());
            }

            @Override
            public Hashtable transfer(ArrayList arrayList) {
                System.out.println("transfer");
                return null;
            }
        };
        dragon.func1(new ArrayList());
        dragon.transfer(new ArrayList());
    }
}

interface Dragon<T1, T2> {
    void func1(T1 t1);
    T2 transfer(T1 t1);
}

2)自定义泛型方法

方法中需要使用指定的泛型类对象，这样的方法是泛型方法
语法:
权限修饰符<T1，T2…> 返回值类型 方法名(参数列表){}
示例:

public class Test5 {
    public<K, V> void func1(K key, V value) {
        System.out.println(key + ":" + value);
    }
    public static void main(String[] args) {
        Test5 test5 = new Test5();
        test5.func1("age", 15);
    }
}

３)类型边界

当泛型类需要对实际数据类型进行限制时，可以在类型参数后面使用extends Parent进行限制，指定实际类型必须是类Parent的子类
示例:

class Parent{
}

class Son<T extends Parent>{
}

4.泛型使用中的继承和通配

1)通配

<>使用?表示可以使用任意引用类型
示例:

List<?> list = new ArrayList<String>();
List<?> list2 = new ArrayList<Double>();
List<?> list3 = new ArrayList<Date>();

2)继承使用限制

在泛型中指定类型为父类后不能直接使用子类来实例化，必须使用extends关键字;
另外泛型中指定类型为子类后如果想用父类实例化必须使用super关键字;
示例:

public class Test5 {
    // 规定泛型必须是GrandFather及其子类,不仅仅是直接子类
    List<? extends GrandFather> list = new ArrayList<Baby>();

    // 规定泛型必须是Son类及其父类,不仅仅是直接父类
    List<? super Son> list2 = new ArrayList<Father>();
}

class GrandFather{}

class Father extends GrandFather{}

class Son extends Father{}

class Baby extends Son{}