java泛型

一、什么是泛型

Java泛型（generics）是JDK5中引入的一个新特性，泛型是提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型的数据结构。泛型的本质是类型参数化或参数化类型，在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。通俗讲可以在编译时期进行类型检查，而且可以避免频繁类型转化。

代码中的<Integer>就是泛型，我们把类型像参数一样传递，尖括号中间就是数据类型，我们可以称之为实际类型参数，这里实际类型参数的数据类型只能为引用数据类型。

二、泛型基本使用

1、不使用泛型也是可以的

@Test
    public void test1() {
        List list = new ArrayList();
        list.add("java");
        list.add(2);
        String str = (String) list.get(0);
        Integer i = (Integer) list.get(1);
        System.out.println(str);
        System.out.println(i);
    }
    //运行结果
    java
    2

缺点：

①需要强制类型转换：没有设置数据类型，则list就是内部就是Object[]数组，在get()元素时，返回的是object类型，所以，获取对象时，需要强制类型转换，其他的Collection、Map如果不使用泛型，也存在这个问题

②可以向集合中添加任意类型的数据，存在数据不安全风险，如下所示:

public void test1() {
        List list = new ArrayList();
        list.add("java");
        list.add(2);
        String str = (String) list.get(0);
        String i = (String) list.get(1);//添加进列表的整型，而获取的是字符型
        System.out.println(str);
        System.out.println(i);
    }

使用泛型可以解决这些问题。

泛型有如下优点：

• 可以减少类型转换的次数，代码更加简洁；
• 程序更加健壮：只要编译期没有警告，运行期就不会抛出ClassCastException异常；
• 提高了代码的可读性：编写集合的时候，就限定了集合中能存放的类型。

2、使用泛型

@Test
public void testGeneric2() throws Exception {
    // 声明泛型集合的时候指定元素的类型
    List<String> list = new ArrayList<String>();
    list.add("China");
    // list.add(1);// 泛型要解决的就是在编译时期报错，提前检查)
    String str = list.get(0); //使用时候返回的就是String类型，不要强制转换
}
@Test
public void test3() {
    // 两端的数据类型必须要一致
    List<Object> list1 = new ArrayList<Object>();
    List<String> list2 = new ArrayList<String>();
    // 右侧的泛型可以不写
    List<String> list3 = new ArrayList<>();
    // 只在右侧写泛型不起作用
    List list4 = new ArrayList<String>();
    list4.add(1);

    // 两边不一致编译时候报错
    // List<Object> list5 = new ArrayList<String>();
    // 泛型类型必须为引用数据类型
    // List<int> list6 = new ArrayList<>();
}

三、泛型擦除

泛型只在编译时期有效，编译后的字节码文件中不存在有泛型信息！

1. 帮助开发者写出正确的代码。

2. 虚拟机的向下兼容问题

List<String> list1 = new ArrayList<String>();  //创建泛型
List<Integer> list2 = new ArrayList<Integer>();  
Class c1 = list1.getClass();  //获取泛型的类型
Class c2 = list2.getClass();  
System.out.println(c1 == c2); //输出true

在运行时是没有泛型的说法的，所以ArrayList.class 和ArrayListist.class 其实都是ArrayList.class

四、泛型方法

public class GenericDemo2 {

    public Student add1(Student student, Teacher teacher) {
        return null;
    }

    public <K,T> K add(K k, T t) {
        return k;
    }

    @Test
    public void test1() {
        // 使用泛型方法:  在使用泛型方法的时候，确定泛型类型
        Float result1 = add(1.0f, 1);
        System.out.println(result1);

        String result2 = add("abc", 1);
        System.out.println(result2);
    }
}

五、泛型类

不用像泛型方法那样每个方法都要声明。

public class BaseDao<T> {
    public <K> K save(K k) {
        return k;
    }
    public void add(T t) {
    }

    public void update(T t) {
    }
}

@Test
public void test2() {
    Student student = new Student();
    BaseDao<Student> baseDao1 = new BaseDao<>();
    baseDao1.add(student);
    baseDao1.update(student);

    Teacher teacher = new Teacher();
    BaseDao<Teacher> baseDao2 = new BaseDao<>();
    baseDao2.add(teacher);
    baseDao2.update(teacher);
}

六、泛型接口

public interface IBaseDao<T> {
    void add(T t );
    void update(T t );
}
//泛型接口类型确定： 在业务实现类中直接确定接口的类型
public class PersonDao implements IBaseDao<Person> {
}

七、泛型关键字

T	Type--具体的java类
E	Element--在集合中使用，因为集合中存放的是元素
K V	Key Value -- 分别代表java键值中的Key Value
N	Number 数值类型
?	称为通配符，表示不确定的java类型

在泛型中：extends 元素的类型必须继承指定的类

super 元素的类型必须是指定的类的父类

使用“”通配符，可以使方法更加灵活，可以接受不同类型的 List 列表，同时又不会对List进行修改，保证代码的安全性。

既要限定传递过来的是集合类型，但是又不确定里面类型List list；

public void add(List<?> list) {

}
// extends      元素的类型必须继承自指定的类
/**
* list集合只能处理 Double/Float/Integer等类型
* 限定元素范围：元素的类型要继承自Number类  (上限)
* @param list
*/
public void add(List<? extends Number> list) {
}

@Test
public void testGeneric23() throws Exception {
    List<Double> list1 = new ArrayList<Double>();
    List<Float> list2 = new ArrayList<Float>();
    List<Integer> list3 = new ArrayList<Integer>();

    List<String> list4 = new ArrayList<String>();

    // 调用
    add(list1);
    add(list2);
    add(list3);
    //add(list4);
}

/**
* super限定元素范围：必须是String父类   【下限】
* @param list
*/
public void add(List<? super String> list) {
}

@Test
public void testGeneric24() throws Exception {
    // 调用上面方法，必须传入String的父类
    List<Object> list1 = new ArrayList<Object>();
    List<String> list2 = new ArrayList<String>();

    List<Integer> list3 = new ArrayList<Integer>();
    //add(list3);
}