泛型

一、初识泛型（什么是泛型）

• 泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型
• 泛型也可以看成是一个变量，用来接收数据类型
• public class ArrayList<E>{ …} ，<E>就是一个泛型

public class Demo01Generic {
    public static void main(String[] args) {
        show01();
        show02();
    }

/*
    创建集合对象，不使用泛型
    好处：
       集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
     弊端：
        不安全，会引发异常
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);
        //使用迭代器遍历list接口
        //获取迭代器
        Iterator it = list.iterator();
        //使用迭代器中的方法hasNext和next遍历集合
        while (it.hasNext()){
            //取出元素也是Object类型
            Object obj = it.next();
            System.out.println(obj);

            //想用使用String类特有的方法，length获取字符串的长度;不能使用 多态 Object obj = "abc"
            //需要向下转型
            //会抛出ClassCastException类型转换异常，不能把Integer类型转换为String类型
            //String s = (String)obj;
            //System.out.println(s.length());
        }
    }

    /*
    创建集合对象，使用泛型
    好处：
    1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
    2.把运行期异常（代码运行之后会抛出的异常）提前到了编译期（写代码的时候会报错）
    弊端：
       泛型是什么类型，只能存储什么类型的数据
     */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        //list.add(1);//Required type: String Provided:int
        //使用迭代器遍历list集合
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s+"->"+s.length());
        }
    }
}

二、自定义泛型类

(1)定义GenericClass<E>泛型类

/*
  定义一个含有泛型的类，模拟ArrayList集合
  泛型是一个未知的数据类型，当我们不确定用什么数据类型的时候，可以使用泛型
  泛型可以接受任意的数据类型，可以使用Integer，String，student
  创建对象的时候确定泛型的数据类型
 */
public class GenericClass<E>{
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

(2)使用GenericClass<E>泛型类

public class Demo02GenericClass {
    public static void main(String[] args) {
        GenericClass gc = new GenericClass();
        gc.setName("只能是字符串");
        Object name1 = gc.getName();
        System.out.println(name1);

        //创建GenericClass对象，泛型使用Integer类型
        GenericClass<Integer> gc2 = new GenericClass<>();
        gc2.setName(1);
        int name2 = gc2.getName();
        System.out.println(name2);

        //创建GenericClass对象，泛型使用String类型
        GenericClass<String> gc3 = new GenericClass();
        gc.setName("只能是字符串");
        String name = gc3.getName();
        System.out.println(name);
    }
}

三、自定义泛型接口(类似于泛型类)

(1)定义GenericInterface<T>接口

public interface GenericInterface<T> {
    /*
   定义含有泛型的接口
 */
    public abstract void mehthod(T t);
}

(2)使用GenericInterface<T>接口(方式一，类似于普通的接口实现类)

/*
   含有泛型的接口，第一种使用方式:定义接口的实现类，实现接口，指定接口的泛型
   public interface Iterator<E>{
    E next();
   }
   Scaner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认为String
   public final class Scanner implements Iterator<String>{
      public String next(){
      }
   }
 */
public class GenericInterfaceImpl1 implements GenericInterface<String>{

    @Override
    public void mehthod(String s) {
        System.out.println(s);
    }
}

(3)使用GenericInterface<T>接口(方式二，类似于定义泛型类)

/*
  含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
  就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
  pulic interface List<E>{
  boolean add(E e);
  E get(int index);
  }
   public class ArrayList<E> implements list<E>{
     boolean add(E e);
     E get(int index);
   }
 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
    @Override
    public void mehthod(I i) {
        System.out.println(i);
    }
}

四、泛型通配符

/*
   泛型的通配符：
   ?代表任意的数据类型
   使用方式:
     不能创建对象使用
     只能作为方法的参数使用
 */
public class Demo05Generic {
    public static void main(String[] args) {
       ArrayList<Integer> list01 = new ArrayList<>();
       list01.add(1);
       list01.add(2);
       ArrayList<String> list02 = new ArrayList<>();
       list02.add("a");
       list02.add("b");
       printArray(list01);
       printArray(list02);
//       print(list01);
//       print(list02);
    }
    /*
      定义一个方法，能遍历所有类型的ArrayList集合
      这时候我们不知道ArrayList集合使用什么数据类型，可以泛型通配符?来接收数据类型
      注意：
         泛型没有继承概念的
       */
    public static void printArray(ArrayList<?> list){
         //使用迭代器遍历集合
        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            //it.next()方法，取出的元素是Object,可以接受任意的数据类型
            Object o = it.next();
            System.out.println(o);
        }
    }

   /* public static <E> void print(ArrayList<E> list){
        Iterator<E> it = list.iterator();
        while (it.hasNext())
            System.out.println(it.next());
    }*/
}