Java集合框架:泛型

JAVA中所有的参数必须提前声明参数类型，例如方法的形参中，如果我们在定义这个方法时不知道这个参数的类型，要等具体调用时才知道，怎么办呢？

我们可以使用泛型来代替那些定义时还不明确的参数类型。

泛型的本质是参数化类型，是将类的类型参数化，具体调用的时候再给具体的类型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

泛型类： public class 类名<T>{ }

泛型接口：public interface 接口名<T>{ }

泛型方法：public <T> 返回值类型 方法名( ){ }

在类中

案例

定义一个学生类 定义一个属性 age，希望age的类型可以是Integer也可以是String

代码

- 1 定义学生类 在类的后面添加泛型 `<T>` ，在定义age属性和相关getset方法时，就使用T
- 2 测试 创建2个学生类对象， 分别传入不同的泛型Integer和String

可以定义多个泛型，逗号分开

//类中定义泛型 <T>
public class Student01<T, E> {

    //这里使用泛型T
    T age;
    E height;

    public T getAge() {
        return age;
    }

    public void setAge(T age) {
        this.age = age;
    }

    public E getHeight() {
        return height;
    }

    public void setHeight(E height) {
        this.height = height;
    }
}

测试代码：
//创建学生对象  传入泛型 具体类型Integer和Double
Student01<Integer, Double> stu01 = new Student01<>();
stu01.setAge(10);
stu01.setHeight(10.5);


//创建学生对象  传入泛型 具体类型String
Student01<String, String> stu02 = new Student01<>();
stu02.setAge("20");
stu02.setHeight("50");

 在方法中

在show方法上定义泛型 ，在参数中 给age定义类型时使用了泛型T

• 一般配合参数使用，在调用的时候，传入什么类型， T就是什么类型

public class AA {
    //方法中定义的泛型
    //一般配合参数使用，在调用的时候，传入什么类型， T就是什么类型
    public <T> void show(T age) {
        T a = age;
        System.out.println(a);
    }
}
测试代码：
public class DEmo01 {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.show(10);
        aa.show("20");
        aa.show(10.5);
    }
}

接口中（重点）

- 定义了一个接口 里面定义了泛型
- 两个实现类

//定义接口中的泛型T 在方法中使用了这个T定义参数e
interface inter1<T> {
    public void show(t e, int a);

}
//1 写一个类继承接口inter1的时候 就把泛型确定好，比如这里是String，那么show方法中的参1也就是String
class A implements inter1<Integer> {
    @Override
    public void show(t e, int a) {
        System.out.println(e + "----" + a);
    }
}
//2  B后面的E是给类定义了一个泛型
// inter1后面的E是使用了类的泛型，把它再传给接口inter1里的泛型T
// show方法是对接口的抽象方法的实现，参数里的E 和Inter1<E>这里的E保持一致
// method参数里的E只是使用了类的泛型E
class B<E> implements inter1<E> {
    @Override
    public void show(t e, int a) {
        System.out.println(e + "----" + a);
    }
    public void method(E height) {
        System.out.println(height);
    }
}

测试方法:
 public static void main(String[] args) {
A a = new A();
a.show(10, 20);

B<String> b = new B<>();
b.show("aaa", 100);
}

类型通配符 ？

类型通配符: <?>

- ArrayList<?>: 表示元素类型未知的ArrayList,它的元素可以匹配任何的类型
- 如果使用了<?>,ArrayList就不能添加数据了,获取出来的也是Object类型
- 使用通配符的集合不能够修改数据了

代码

- showList方法，接收一个集合类型的数据，可以打印结合中所有数据，但不知道集合里具体类型，索引泛型写了?
- main方法中 创建了两个不同类型的集合对象，传入测试

 public static void main(String[] args) {
        ArrayList<String> list01 = new ArrayList<>();
        list01.add("aa");
        list01.add("bb");
        list01.add("cc");
        showList(list01);

        ArrayList<Boolean> list02 = new ArrayList<>();
        list02.add(true);
        list02.add(false);
        list02.add(false);
        showList(list02);
    }

    public static void showList(ArrayList<?> list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }

类型通配符上限: <? extends 类型> (源码中常见)

• ArrayList<? extends Number>: 它表示的类型是Number或者其子类型

类型通配符下限: <? super 类型> （用的很少）

• ArrayList <? super Number>: 它表示的类型是Number或者其父类型