java-泛型学习笔记

一、什么是泛型

核心为：类型参数化

1-背景

• JAVA推出泛型以前，程序员可以构建一个元素类型为Object的集合，该集合能够存储任意的数据类型对象，而在使用该集合的过程中，需要程序员明确知道存储每个元素的数据类型，否则很容易引发ClassCastException异常。

2-概念

• Java泛型（generics）是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。
• 泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数。

3-好处

• 类型安全

• 消除了强制类型的转换

4-类型

• E - Element (在集合中使用，因为集合中存放的是元素)
• T - Type（表示Java 类，包括基本的类和我们自定义的类）
• K - Key（表示键，比如Map中的key）
• V - Value（表示值）
• N - Number（表示数值类型）
• ？ - （表示不确定的java类型）
  S、U、V - 2nd、3rd、4th types

5-思考

• ArrayList集合中的泛型

• ArrayList集合中的add()方法

• 可以看出当我们在

• ArrayList的E变为了String，类似于参数一般传进去

二、泛型类

1-泛型类

1-1.定义语法

• 泛型类的定义语法

class 类名称 <泛型标识,泛型标识,>{
    private 泛型标识 变量名
        ....
}

• 例如：

/**
 * 泛型类的定义
 * @param <T> 泛型标识，类比形参 (创建对象的时候指定具体的数据类型)，由外部指定
 */
public class TestDemo<T> {
    //变量
    private T Data;
    //有参构造
    public TestDemo(T data) {
        Data = data;
    }
    //get方法
    public T getData() {
        return Data;
    }
    //set方法
    public void setData(T data) {
        Data = data;
    }
}

1-2.具体使用

• 使用的语法：

类名<具体的数据类型> 对象名=new 类名<具体的数据类型>();

• Java1.7后，后面的<>中可以不写具体类型

类名<具体的数据类型> 对象名=new 类名<>();

• 例如：

public class demo001 {
    public static void main(String[] args) {
        TestDemo<String> stringTestDemo = new TestDemo<>();
        stringTestDemo.setData("haha");
        String data = stringTestDemo.getData();
        System.out.println(data);
    }
}

2-泛型类注意事项

• 泛型类，如果没有指定具体的数据类型，此时，操作类型是Object
• 泛型的类型参数只能是类类型，不能是基本数据类型
• 泛型类型在逻辑上可以看成是多个不同的类型，但实际上都是相同类型

public class demo002 {
    public static void main(String[] args) {
        TestDemo<String> stringTestDemo = new TestDemo<>();
        TestDemo<Integer> integerTestDemo = new TestDemo<>();
        //结果为true
        System.out.println(stringTestDemo.getClass()==integerTestDemo.getClass());
    }
}

• 可以结合后面的泛型擦除理解，泛型擦除之后 TestDemo<String> 和TestDemo<Integer>都是TestDemo类。

3-从泛型类派生子类

• 子类也是泛型类，子类和父类的泛型类型要一致

class ChildGeneric<T> extends Generic<T>

• 子类不是泛型类，父类要明确泛型的数据类型

class ChildGeneric extends Generic<String>

三、泛型接口

1-定义接口

interface 接口名称<泛型标识,泛型标识,...>{
	泛型标识 方法名();
    ...
}

2-泛型接口的使用

• 实现类也是泛型类，实现类和接口的泛型类型要一致

/**
 * 泛型接口
 * @param <T>
 */
public interface Generator<T> {
    T getKey();
}
/**
 * 泛型接口的实现类，是一个泛型类，
 * 那么要保证实现接口的泛型类泛型标识包含泛型接口的泛型标识，类似于传参
 * @param <T>
 * @param <E>
 */
public class Pair<T,E> implements Generator<T> {

    private T key;
    private E value;

    public Pair(T key, E value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public T getKey() {
        return key;
    }

    public E getValue() {
        return value;
    }
}

• 实现类不是泛型类，接口要明确数据类型

/**
 * 实现泛型接口的类，不是泛型类，需要明确实现泛型接口的数据类型。
 */
public class Apple implements Generator<String> {
    @Override
    public String getKey() {
        return "hello generic";
    }
}

四、泛型方法

1-语法

修饰符<T,E,...> 返回值类型 方法名(形参列表){
	方法体
}

• public与返回值中间非常重要，可以理解为声明此方法为泛型方法。
• 只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
• < T >表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
• 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

2-使用

• 泛型方法：

public class TestDemoMethod {
    public<E> E getValue(ArrayList<E> list) {
        return list.get(0);
    }
}

• 使用，类型参数化：

public class demo003 {
    public static void main(String[] args) {
        //创建String的list
        ArrayList<String> list = new ArrayList<String>();
        list.add("haha");
        //调用泛型方法
        TestDemoMethod testDemoMethod = new TestDemoMethod();
        String value = testDemoMethod.getValue(list);
        //输出为"haha"
        System.out.println(value);
    }
}

3-泛型方法与可变参数

public <E> void print(E... e){
	for (E e1 : e) {
		System.out.println(e);
	}
}

4-泛型方法总结

• 泛型方法能使方法独立于类而产生变化
• 如果static方法要使用泛型能力，就必须使其成为泛型方法

五、类型通配符-?

• 类型通配符一般是使用?代替具体的类型实参。
• 所以，类型通配符是类型实参，而不是类型形参。

2-类型通配符的上限

• 语法：类/接口<? extends 实参类型>，要求该泛型的类型，只能是实参类型，或实参类型的子类类型
• 如：有MiniCat、Cat、Animal。List<? extends Cat>只能传入Cat和MiniCat。因为不确定传入的是Cat还是Cat的子类，所以list

public class demo003 {
    public static void main(String[] args) {
        ArrayList<MiniCat> miniCats = new ArrayList<>();
        ArrayList<Cat> cats = new ArrayList<>();
        ArrayList<Animal> animals = new ArrayList<>();
        //满足:List<? extends Cat> list
        test(miniCats);
        //满足:List<? extends Cat> list
        test(cats);
        //不满足:List<? extends Cat> list
        //test(animals);


    }

    public static void test(List<? extends Cat> list){
        //根据List<? extends Cat> list，可知传入进来的list内部都是Cat集其子类
        //因为不知道继承层级，万一传入的list甚至继承自miniCat,所以list不能存入MiniCat、Cat、Animal
        //以下均编译出错
//        list.add(new Cat());
//        list.add(new MiniCat());
//        list.add(new Animal());
    }
}

• 只能读，不能写
• 很多时候会遇到<? extends E>，这个E是我们传进来的

3-类型通配符的下限

• 语法：类/接口<? super 实参类型>，要求该泛型的类型，只能是实参类型，或实参类型的父类类型。
• 如：有MiniCat、Cat、Animal。List<? super Cat>只能传入Cat和Animal。因为传入的是Cat及其父类，所以List是可以存入MiniCat（即Cat的子类）

public class demo003 {
    public static void main(String[] args) {
        ArrayList<MiniCat> miniCats = new ArrayList<>();
        ArrayList<Cat> cats = new ArrayList<>();
        ArrayList<Animal> animals = new ArrayList<>();
        //满足:List<? super Cat> list
        test(cats);
        //满足:List<? super Cat> list
        test(animals);
        //不满足:List<? super Cat> list，编译报错
//        test(miniCats);

    }

    public static void test(List<? super Cat> list){
        //根据List<? super Cat> list，可知传入进来的list内部都是Cat集其父类
        //所以可以add，Cat集其子类的类型，而不会报错
        list.add(new Cat());
        list.add(new MiniCat());
        //因为List<? super Cat> list，不知道传入的是Cat还是Animal类型的list，所以我们直接放入Animal会编译报错
        //list.add(new Animal());
    }
}

• 可以写子类类型

import java.util.Comparator;
import java.util.TreeSet;

public class demo002 {
    public static void main(String[] args) {
        TreeSet<Cat> treeSet = new TreeSet<>(new myAnimalComparator());
        treeSet.add(new Cat("A",25));
        treeSet.add(new Cat("C",28));
        treeSet.add(new Cat("D",30));
        treeSet.add(new Cat("B",24));
        System.out.println(treeSet);
    }

}
class  myMiniCatComparator implements Comparator<MiniCat>{


    @Override
    public int compare(MiniCat o1, MiniCat o2) {
        return o1.level-o2.level;
    }
}

class  myCatComparator implements Comparator<Cat>{


    @Override
    public int compare(Cat o1, Cat o2) {
        return o1.age-o2.age;
    }
}

class  myAnimalComparator implements Comparator<Animal>{


    @Override
    public int compare(Animal o1, Animal o2) {
        return o1.name.compareTo(o2.name);
    }
}

六、类型擦除

1-概念

• 泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是泛型代码能够很好地和之前版本的代码兼容。那是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为–类型擦除。

2-无限制类型擦除

进入JVM后默认改为了Object。类似集合平时使用的时候没有传泛型类型，集合都是默认存的object

3-有限制类型擦除

4-擦除方法中类型定义的参数

5-桥接方法

• 桥接方法是针对接口以及接口实现类来说的
• 实现类会新建一个对应的方法，然后新建的方法再调用原方法

七、泛型与数组

日常开发，尽量不要使用泛型数组，使用泛型集合

• 可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象

• 可以通过java.lang.reflect.Array的newInstance(Class,int)创建T[]数组

public class Fruit<T> {
    private T[] array;

    public Fruit(Class<T> clz, int length){
        //通过Array.newInstance创建泛型数组
        array = (T[])Array.newInstance(clz, length);
    }
}