20、泛型

泛型与File

目录

1、为什么要有泛型

2、在集合中使用泛型

3、自定义泛型结构

4、泛型在继承上的体现

5、通配符的使用

6、泛型应用举例

一、为什么要有泛型

1、理解：标签

    //在集合中使用泛型的情况
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(34);
        list.add(84);
        list.add(94);

        //问题一：类型不安全——>要求：在添加数据时进行类型检查——>泛型
        list.add("Tom");
        for (Object score : list){
            //问题二：强转时容易出现ClassCastException
            int stuScore = (int)score;
            System.out.println(stuScore);
        }
    }

二、在集合中使用泛型

总给：

• 1、集合接口或集合类在 jdk 5.0 之后都修改为带泛型的结构
• 2、在实例化集合类时，可以指明具体的泛型类型
• 3、在声明集合类或接口完以后，在集合类或接口中凡是定义类或接口时，内部结构使用到类的泛型的位置，都指定为你实例化时的泛型类型。
• 比如： add(E e) ——> 实例化以后 add(Integr e)
• 4、注意点：泛型的类型必须是一个类，不能时基本数据类型，需要用基本数据类型的位置，用包装类替换
• 5、如果实例化时，没有指明泛型的类型，默认类型为java.util.Object类型

在集合中使用泛型的情况:以ArrayList为例

   
    @Test
    public void test2(){
        //ArrayList<Integer> list = new ArrayList<Integer>();
        // jdk 7新特性：类型推断——>后面<>里的内容可以省略
        ArrayList<Integer> list = new ArrayList<>();
        //需求：存放学生的成绩
        list.add(34);
        list.add(84);
        list.add(94);
        //编译时，进行类型检查，保证数据的安全
        //list.add("Tom");
        //方式一：
        for (Integer score : list){
            //避免了强转操作
            int stuScore = score;
            System.out.println(stuScore);
        }
        //方式二:
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    

在集合中使用泛型的情况:以HashMap为例

    @Test
    public void test3(){
        Map<String,Integer> map = new HashMap<String,Integer>();

        map.put("A",90);
        map.put("B",90);
        map.put("C",90);
        map.put("D",90);

        Set<Map.Entry<String,Integer>>  entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
        while(iterator.hasNext()){
            Map.Entry<String,Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key+"--"+value);
        }
    }

实现comparable接口时

public class Employee implements Comparable<Employee>{
    private String name;
    private int age;

    @Override
    public int compareTo(Employee o) {
        return name.compareTo(o.name);
    }
}

定制排序

@Test
    public void test4(){
        Comparator comparator = new Comparator<Employee>() {

            @Override
            public int compare(Employee e1, Employee e2) {
                return e1.age - e2.age;
            }
        };
        Set<Employee> set = new TreeSet<>(comparator);

        set.add(new Employee("A",12));
        set.add(new Employee("B",11));
        set.add(new Employee("C",10));
    }

三、自定义泛型结构

泛型结构：泛型类、泛型接口；泛型方法

class Person<T> {
// 使用T类型定义变量
private T info;
// 使用T类型定义一般方法
public T getInfo() {
return info;
}
public void setInfo(T info) {
this.info = info;
}
// 使用T类型定义构造器
public Person() {
}
public Person(T info) {
this.info = info;
}

泛型方法的使用

*泛型方法，可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非是在实例化类时确定的

public <E> List<E> copyArraylist(E[] arr){
    Arraylist<E> list = mew ArrayList<>();
    
    for(E e:arr){
        list.add(e);
    }
    return list;
}

@Test//注，该方法可以是静态的
public void test4(){
    Order<String> order = new Order<>();
    //泛型方法啊在调用时，指明泛型参数的类型。
    Iteger[] arr = new Integer[]{1,2,3,4};
    List<Integer> integer = order.copyArrayList(arr);
}

总结：

11.

T[] rr = (T[]) new Object[10];

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}

@Test
    public void test(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        Order order1 = new Order();
        order1.setOrderT(123);
        order1.setOrderT("ABC");

        //要求：如果大家定义的类是带泛型的，建议在实例化的时候要指明类的泛型
        Order<String> order2 = new Order<>("A",12,"order:A");
        order2.setOrderT("A:hello");
    }
    @Test
    public void test2(){
        //SubOrder已经不是泛型类了
        SubOrder sub1 = new SubOrder();
        //由于子类在继承来泛型的父类时，指明了泛型的类型。则实例化子类的对象时，不再需要指明泛型
        sub1.setOrderT(111);
        //SubOrder已经不是泛型类了
        SubOrder2<String> sub2 = new SubOrder2<>();
        sub2.setOrderT("AAA");
    }

public class SubOrder extends Order<Integer> {}//SubOrder已经不是泛型类了

public class SubOrder2<T> extends Order<T> {}//SubOrder已经不是泛型类了

四、泛型在继承上的体现

• 虽然类A是类B的父类，但是G和G二者不具备子父类关系，二者是并列关系
• 补充：类A是类B的父类，A 和B

public void testGenericAndSubClass() {
Person[] persons = null;
Man[] mans = null;
// 而 Person[] 是 Man[] 的父类.
persons = mans;
Person p = mans[0];
// 在泛型的集合上
List<Person> personList = null;
List<Man> manList = null
// personList = manList;(报错)
}

五、通配符的使用（？）

• 1、通配符（？）作为Object和String的通用父类
• 2、类A是类B的父类，G和G是没有关系的，二者共同的父类是G<?>
• 3、添加：对于list<?>就不能向其内部添加数据，除了添加null之外
• 4、获取（读取）:允许读取数据，读取数据的类型为Object
  

2.

@Test
    public void test3(){
        List<Object> list1 = null;
        List<String> list2 = null;
        List<?> list = null;

        list = list1;
        list = list2;

        //添加：对于list<?>就不能向其内部添加数据，除了添加null之外
        list.add();
    }

3.

List<Object>list1 = null;
List<String>list2 = null;
List<?> list = null;//?

list = list1;
list = list2;

publidc void print(List<?> list){
    Iterator<?> iterator = list.iterator;
    while(iterator.hasNext()){
        Object obj = iterator.next();
        System.out.println(obj);
    }
}

有限制条件的通配符

• ？ extends Person: <>里面可以是小于等于Person的类
• ？ super Person:<>里面可以是大于等于Person的类
• ？：<>里面可以是所有的类

拓展：有限制条件的泛型

• T extends Person:T<=Person,T必须是Person的子类
• T super Person:T>=Person，T必须是Person的父类

   @Test
    public void test4(){
        List<? extends Person> list1 = new ArrayList<>();
        List<? super Person> list2 = new ArrayList<>();

        List<Student> list3 = new ArrayList<>();
        List<Person> list4 = new ArrayList<>();
        List<Object> list5 = new ArrayList<>();

        list1 = list3;//通过
        list1 = list4;//通过
//        list1 = list5;//编译不通过

//        list2 = list3;//编译不通过
        list2 = list4;//通过
        list2 = list5;//通过
        
        //读取数据
        Person p = list1.get(0);//通过
//        Student s = list.get(0);//编译不通过
        
        Object obj = list2.get(0);//通过
//        Person p = list2.get(0);//编译不通过

        //写入数据
//        list1.add(new Person());//编译不通过,左开右闭区间
//        list1.add(new Student());//编译不通过
//        list1.add(new Object());//编译不通过，父类不能赋给子类

        list2.add(new Person());//通过
        list2.add(new Student());//通过
//        list2.add(new Object());//编译不通过
    }

六、泛型应用举例