java学习总结二：泛型

一、泛型定义&基本使用

泛型是JDK1.5以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化！

@Test
public void testGeneric() throws Exception {
    // 集合的声明
    List list = new ArrayList();
    list.add("China");
    list.add(1);

    // 集合的使用
    String str = (String) list.get(0);
}

// 使用泛型
@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

三、泛型方法/泛型类/泛型接口

作用：设计公用的类、方法，对公用的业务实现进行抽取！使程序更灵活！

1、泛型方法:

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);
    }
}

2、泛型类

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

PageInfo pageInfo;

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);
}

3、泛型接口

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

四、泛型关键字

常用的 ？, T, E, K, V, N的含义

我们在泛型中使用通配符经常看到T、F、U、E，K，V其实这些并没有啥区别,我们可以选 A-Z 之间的任何一个字母都可以，并不会影响程序的正常运行。

只不过大家心照不宣的在命名上有些约定:

1. T (Type) 具体的Java类
2. E (Element)在集合中使用，因为集合中存放的是元素
3. K V (key value) 分别代表java键值中的Key Value
4. N （Number）数值类型
5. ? 表示不确定的 Java 类型

泛型中：

1. ? 在泛型代码中，问号(?)称为通配符，用来表示不确定的 Java 类型
2. extends 元素的类型必须继承自指定的类
3. 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);
}