Java学习（13）—— 泛型

一.   泛型

      1. 集合中使用泛型

        （1）集合接口或集合类都是带有泛型的结构；

        （2）在实例化集合类时，可以指明具体的泛型类型；

        （3）泛型的类型必须是类，不能是基本数据类型，如果要用到基本数据类型，使用包装类替换；

        （4）实例化时如果没有指明泛型的类型，则默认为java.lang.Object类型

import java.util.*;

public class Test{
    public static void main(String[] args) {
        //在集合中使用泛型
        ArrayList<Integer> list = new ArrayList<Integer>();   //增加泛型，使得集合中的数据都是整型
        list.add(13);
        list.add(12);
        list.add(25);
        list.add(10);
        //list.add("A");   编译时就会检查参数类型，如果不是整型，则会报错

        for(Integer integer:list){
            int i = integer;
            System.out.println(i);
        }
    }
}

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test{
    public static void main(String[] args) {
        //在HashMap中使用泛型
        HashMap<String,Integer> map = new HashMap<String,Integer>();
        map.put("Tom",22);
        map.put("Bob",23);
        map.put("Joe",25);
        //map.put(12,"A");   会报错

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

        2.自定义泛型类或接口

public class Test{
    public static void main(String[] args) {
        //如果定义了泛型类，实例化时没有指定类的泛型，则认为该泛型是Object类型
        Person person1 = new Person();
        person1.setSex(12);
        person1.setSex("男");

        //如果定义的类是带泛型的，建议在实例化时要指明类的泛型
        Person<String> person =  new Person<String>("Tom",23,"man");
        person.setSex("男生");   //只能使用泛型指定的数据类型

        //由于子类在继承带泛型的父类时，指明了泛型的类型，则实例化子类对象时，不需要再指明泛型类型
        Man man = new Man();
        man.setSex('男');    //由于子类指明了泛型的类型为Character，因此只能使用char型

        //子类在继承带泛型的父类时，没有指明泛型的类型，则实例化子类对象时，需要指明泛型类型
        Woman<String> woman = new Woman<String>();
        woman.setSex("女生");     //使用上面指定的泛型类型
    }
}

class Person<T>{      //自定义泛型类
    String name;
    int age;
    T sex;     //在不确定变量的类型时，可以使用泛型；在实例化时需要给变量指定数据类型

    public Person(){

    }

    public Person(String name,int age,T sex){
        this.name = name;
        this.age= age;
        this.sex = sex;
    }

    public T getSex(){
        return sex;
    }

    public void setSex(T sex){
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }
}

class Man extends Person<Character>{   //Man不是泛型类

}

class Woman<T> extends Person<T>{     //Woman是泛型类

}

        3.自定义泛型方法

import java.util.ArrayList;
import java.util.List;

public class Test{
    public static void main(String[] args) {
        Person<String> person = new Person<>();

        Integer[] array = new Integer[]{12,13,10,25};
        List<Integer> list =  person.gradeList(array);
        System.out.println(list);    //[12, 13, 10, 25]
    }
}

class Person<T>{
    String name;
    int age;
    T sex;

    public Person(){

    }

    public Person(String name,int age,T sex){
        this.name = name;
        this.age= age;
        this.sex = sex;
    }

    //自定义泛型方法
    public <E> List<E> gradeList(E[] array){     //泛型方法中的泛型参数与类的泛型参数无关，泛型方法与该类是不是泛型类无关
        ArrayList<E> list = new ArrayList<>();
        for(E e:array){
            list.add(e);
        }
        return list;
    }
}

        4.通配符：？

       （1）类A是类B的父类，但是G<A>和G<B>不具备子父类关系，是并列的；

       （2）类A是类B的父类，则A<G>还是B<G>的父类；

import java.util.ArrayList;
import java.util.List;

public class Test{
    public static void main(String[] args) {
        Object obj = "A";
        String str = "AA";
        obj = str;

        Object[] arr1 = new Object[3];
        String[] arr2 = new String[3];
        arr1 = arr2;

        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        //list1 = list2;    编译错误，list1和list2是并列关系，不具备子父类关系

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

         （3）类A是类B的父类，但是G<A>和G<B>不具备子父类关系，他们共同的父类是G<?>

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test{
    public static void main(String[] args) {
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        List<?> list = new ArrayList<>();     //list是list1和list2的父类
        list = list1;
        list = list2;

        Test test = new Test();
        test.print(list1);
        test.print(list2);

    }

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

import java.util.ArrayList;
import java.util.List;

public class Test{
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("A");
        list1.add("B");
        list1.add("C");

        List<?> list = new ArrayList<>();
        list =list1;

        //list.add("D");    不能向List<?>中添加数据

        Object obj = list.get(0);    //可以读List<?>中的数据
        System.out.println(obj);     //A
    }
}

        （4）有限制条件的通配符

                ？extends A：G<? extends A>可以作为G<A>和G<B>的父类，其中B是A的子类

                ？super A：G<? super A>可以作为G<A>和G<B>的父类，其中B是A的父类

import java.util.ArrayList;
import java.util.List;

public class Test{
    public static void main(String[] args) {
        List<? extends Person> list1 = new ArrayList<>();    // ?小于等于Person
        List<? super Person> list2 = new ArrayList<>();      // ?大于等于Person

        List<Man> 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;


        //读取数据
        list1 = list4;
        Object o = list1.get(0);
        Person p1 = list1.get(0);
        //Man m = list1.get(0);   编译错误

        list2 = list4;
        Object o1 = list2.get(0);
        //Person p2 = list2.get(0);     编译错误
    }
}

class Person{

}

class Man extends Person{

}