JAVA-泛型

一.泛型

1.泛型的简介

泛型，是一种未知的数据类型，当不知道用什么数据类型时，就可以使用泛型。

2.泛型的种类

1. E(Element) 在集合中使用，表示在集合中存放的元素
2. T(Type) 表示Java类，包括基本类和自己定义的类
3. K(Key) 表示键，比如Map中的key
4. V(Value) 表示值
5. N(Number) 表示数值类型
6. ? 表示不确定的Java类型

3.注意点

例如:

public class ArrayList<E>{
       public boolean add(E e){}
       public E get(int index){}
}

1.创建集合对象时，就会确定泛型的数据类型。比如，我们在定义时输入：

ArrayList<String> list=new ArrayList<String>();

String作为参数传递，把String赋值给泛型E

4.为什么我们使用泛型？

例如：

public class Generic {
    public static void main(String[] args) {
        show1();
    }

    private static void show1() {
        ArrayList list = new ArrayList();//此时,默认为Object类
        list.add("k");
        list.add(1);
        Iterator it = list.iterator();
        for (Object o : list) {//增强for循环，不报错
            System.out.println(o);
        }
        while (it.hasNext()) {//想使用String的方法length,抛出异常
            Object obj = it.next();
            String s = (String) obj;
            System.out.println(s.length());
        }
    }
}

当我们想使用String类中的length方法时，发现异常：ClassCastException。因为我们现在不使用泛型时，默认传入ArrayList的参数是Object类，String类是Object的子类，Object类不能使用子类独有方法。
泛型优点如下：

1. 将运行期异常（运行时报错）提升到编译期（写代码会报错）
2. 避免类型转换的麻烦

5.泛型定义——类

/*
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
*/

public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

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

6.泛型定义——方法

/*修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
          方法体
}
 */
public class GenericMethod {
    public <M> void method01(M m){
        System.out.println(m);
    }
}

7.泛型定义——接口以及实现方式

public interface GenericInterface<I>{
    public abstract void method(I i);

}

/*两种定义方式：
1.定义接口的实现类，实现接口，指定接口泛型
public interface Iterator<E>{
   E next();
}
Scanner类实现了Iterator接口，指定接口泛型为String
public final class Scanner implements Iterator<String>{
     public String next(){}
     }
 */
public class GenericInterfaceImpl1 implements GenericInterface<String> {
    @Override
    public void method(String s) {
    }
}


/*
 第二种方法：接口用什么泛型，实现类就用什么泛型，类跟接口走
 public interface List<E>{
  boolean add(E e);
  E get(int index);
 }
 public class ArrayList<E> implements List<E>{
     public boolean add(E e){}
     public E get(int index){}
 }
*/
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

8.泛型通配符——？

个人认为此部分重点有两个：

1. 泛型的上限：？extends E 代表只能使用E类型本身/子类
2. 泛型的下限：？super E 代表只能使用E类型的本身/父类