一、泛型的介绍

按照之前的写法，有几个问题
1. 程序中有大量的黄色警告
2. 在遍历的时候，迭代器不知道元素本身的类型，需要向下转型

二、泛型的使用方法

使用泛型[参数化类型]改进集合的使用。
语法格式：<引用数据类型>

public class FanXingDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList();//<String>就是泛型，作用是定义了我们后面向ArrayList添加的元素只能是字符串
        //创建元素对象
        //将元素添加到集合中
        list1.add("hello");
        list1.add("world");
        list1.add("java");
        list1.add("hadoop");
        list1.add("hello");
        list1.add("world");
        //list1.add(10);

        Iterator<String> iterator = list1.iterator();
        while (iterator.hasNext()) {
            String s = iterator.next();
            System.out.println(s + "--" + s.length());
        }

    }
}

三、泛型的使用场景

1.在类上使用泛型

泛型是将来用于接收一个引用数据类型的，相当于一个参数
既然是参数，就需要符合标识符的命名规则
一般情况下，使用一个或多个大写字母表示

public class Demo<W> {
    public void fun1(W w) {
        System.out.println("接收到的参数是：" + w);
    }
}

class Test1{
    public static void main(String[] args) {
//        Demo demo = new Demo();
//        demo.fun1("hello");
//        demo.fun1(10);
//        demo.fun1(12.34);


        Demo<String> d1 = new Demo<>();
        d1.fun1("hello");
//        d1.fun1(10);

    }
}

2.在方法上使用泛型

public class Demo1 {
    //泛型方法
    public <Q> void fun1(Q q) {
        System.out.println("接收到的参数是：" + q);
    }

    //普通的方法
    public void fun2(Object obj) {
        System.out.println("接收到的参数是：" + obj);
    }
}

class Test2{
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.fun1("hello");
        demo1.fun1(100);
    }
}

3.在接口上使用泛型

//泛型接口
public interface Inter1<P> {
    void show1(P p);
}
//继承并重写该接口中的方法
class Inter1Impl<P>implements Inter1<P>{
    @Override
    public void show1(P p) {
        System.out.println("该数据的类型是："+p);
    }
}
class Test3{
    public static void main(String[] args) {
        Inter1Impl<String> stringInter1 = new Inter1Impl<>();//创建一个具体实现类的对象，并且泛型是String类型
        stringInter1.show1("java");
    }
}

四、泛型通配符的使用场景

泛型通配符：

任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E
向下限定，E及其子类
? super E
向上限定，E及其父类

先简单定义一个动物父类，里面有Dog和Cat子类

public class Animal {
}

class Dog extends Animal {

}

class Cat extends Animal {

}

使用泛型通配符

class Demo5{
    public void show1(Collection<?> c1){
        System.out.println("任意类型泛型通配符");
    }
    // 表示可以传入一个Collection集合，元素的类型是Animal或Animal子类的类型
    public void show2(Collection<? extends Animal> c1){
        System.out.println("元素的类型是Animal或Animal子类的类型");
    }
    // 表示可以传入一个Collection集合，元素的类型是Dog或Dog父类的类型
    public void show3(Collection<? super Dog> c1){
        System.out.println("元素的类型是Dog或Dog的父类");
    }
}
public class Demo4 {
    public static void main(String[] args) {
        Demo5 demo5 = new Demo5();
        ArrayList<Object> objects = new ArrayList<>();
        ArrayList<Animal> animals = new ArrayList<>();
        ArrayList<Dog> dogs = new ArrayList<>();
        ArrayList<Cat> cats = new ArrayList<>();

        demo5.show1(objects);
        demo5.show1(animals);
        demo5.show1(dogs);
        demo5.show1(cats);

//        demo5.show2(objects);//不行，因为? extends E向下限定，E及其子类
        demo5.show2(animals);
        demo5.show2(dogs);
        demo5.show2(cats);

        demo5.show3(objects);
        demo5.show3(animals);
        demo5.show3(dogs);
//        demo5.show3(cats);//不行，因为? super E向上限定，E及其父类
    }

}