泛型

泛型是一种未知的数据类型，不清楚使用什么类型的数据时可以使用泛型；

也可以看成一个变量，用来接收数据

例如ArrayList<E>其中的E就是一个泛型

创建集合对象的时候会确定泛型的数据类型

使用泛型的优缺点：

 public static void method1(){
        /*
    不使用泛型
    好处：集合不使用泛型，默认类型是Object类的，可以接收任意数据类型
    缺点：不安全，会引发异常（ClassCastException）；

*/

        ArrayList list01= new  ArrayList<>();
        list01.add("123");
        list01.add(1);
        Iterator<Object> it = list01.iterator();
        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
            //遍历集合
            //想要获取字符串的长度
            //这是一个多态，应先向下转型
            String s = (String) obj;
            System.out.println(s.length());//会出现ClassCastException，1 不是String类型
        }
    }
 使用泛型
        好处：1.避免了类型转换麻烦，存储的是什么类型，取出的是什么类型；
              2.把运行期间的异常（运行后抛出的异常）提升到了编译期（写代码的时候报错）；
        缺点：存储数据类型单一

        */

定义一个含有泛型的类和方法

public class DefineClass<E> {
    //在创建对象时确定泛型的类型
    private int num ;
    //也可以有确定的类型，与普通类一样
    private E str;

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public E getStr() {
        return str;
    }

    public void setStr(E str) {
        this.str = str;
    }
    //定义一个含有泛型的方法
    public static <E> int method(E e,E e1){

        System.out.print("传递的是："+e+"e1 "+e1);
        return 1;
    }

    //在调用方法是确定泛型的类型（传递的是什么类型，泛型就是什么类型）；

    public  <E> int method1(E e,E e1){
//非静态方法不会随对象的类型走，同样在调用方法的时候确定泛型的类型
        System.out.print("传递的是："+e+"e1 "+e1);
        return 1;
    }

}

定义一个含有泛型的接口

public interface DefineInterface<E> {
    public abstract void method02(E e);
}

public class DefinrInterfaceImpl1<E> implements 
  DefineInterface<E> {
//在实现时确定接口的泛型类型
    @Override
    public void method02(E integer) {
        System.out.print("=======");
    }
}

public class Test {
    public static void main(String[] args) {
        DefinrInterfaceImpl1 impl1 = new DefinrInterfaceImpl1();
        impl1.method02(2);

        DefinrInterfaceImpl1<Integer > impl2 = new DefinrInterfaceImpl1<>();
        impl1.method02(22);
        //接口使用什么泛型，实现类就用什么泛型，创建对象时确定泛型类型
        //带有泛型的类

       DefineClass test = new DefineClass();
        test.setStr(2222);
    }
}

泛型统配符

/* 泛型通配符<?> 不确定用什么数据类型，可以使用通配符；

只能又来接收数据，不能存储数据

不能创建对象使用，只能作为方法参数使用

例子：遍历集合 */

public static void printArray(ArrayList<?> list){
    Iterator<?> it = list.iterator();
    while(it.hasNext()){
        Object obj = it.next();//只有Object类可以接收任意类型
        System.out.println(obj);
    }
}

统配符的高级使用---受限泛型

泛型的上限限定：？ extends E ；代表泛型只能是E类型的子类或者本身；

？ super E ；代表泛型只能是E类型的父类或者本身；