JavaSE——泛型

1、介绍

泛型的使用
1.jdk5.0新增的特性

public static void main(String[] args) throws Exception {
    ArrayList<Integer> a = new ArrayList<Integer>();
    a.add(2);
    a.add(5);
    a.add(4);
    a.add(8);
    Iterator<Integer> it = a.iterator();
    while(it.hasNext()){
        System.out.println(it.next());
    }
}

2、自定义泛型类

public class test<T>{
    String name;
    int age;
    T testT;
    public test(){};
    public test(String n,int a,T t){
        name=n;
        age=a;
        testT=t;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public T getTestT() {
        return testT;
    }

    public void setTestT(T testT) {
        this.testT = testT;
    }

    public static void main(String[] args) {
        test<String> a = new test<String>("dcd",20,"我是泛型");
        System.out.println(a.getTestT());
    }
}

1.静态方法中不能使用类的泛型：因为泛型实在创建对象的时候才有的，但是静态方法要更早。
2.异常类不能是泛型的
3.定义泛型数组的方式

T[] arr=new T[10];//错的
T[] arr=(T[]) new Object[10];//正确的，但是要写的是泛型类型的元素

4.泛型的继承

class Father<T1,T2>{}
class son1 extends Father{}//等价于继承了<Object,Object>
class son2 extends Father<Integer,String>{}
class son3<T1,T2> extends Father<T1,T2>{}
class son4<T2> extends Father<T1,T2>{}

class Father<T1,T2>{}
class son1<A,B> extends Father{}
class son2<A,B> extends Father<Integer,String>{}
class son3<T1,T2,A,B> extends Father<T1,T2>{}
class son3<T2,A,B> extends Father<Integer,T2>{}

3、自定义泛型方法

自定义泛型方法和所在的类是否是泛型没有关系

public class test{
   public static void main(String[] args) {
       F f = new F();
       Integer[] arr = {1, 2, 3, 4};
       List<Integer> list = f.copyFromArrayToiList(arr);
       Iterator<Integer> it = list.iterator();
       while(it.hasNext()){
           System.out.println(it.next());
       }
   }
}

class F{
   public <E> List<E> copyFromArrayToiList(E[] arr){//前面加上<E>是为了区分类，不然编译器以为是一个类
       ArrayList<E> list = new ArrayList<>();
       for(E e:arr){
           list.add(e);
       }
       return list;
   }
}

4、泛型在继承方面的体现

//A和B是子父类关系，G<A>和G<B>两种类型并没有子父类关系，是并列关系，所以不能相互复制
List<Object> list1=null;
List<String> list2=null;
list1=list2;//编译错误
//类A和类B是子父类关系，A<G>,B<G>是子父类关系
List<String> list3=null;
ArrayList<String> list4=null;
list3=list4;//可以

5、通配符的使用

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

        List<?> list=null;
        list=list1;
        list=list2;

        print(list1);
        print(list2);
    }

    public static void print(List<?> list){//如果不适用通配符的话要写两个函数，很麻烦
        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            Object obj=it.next();
            System.out.println(obj);
        }
    }
}

注意

//添加
List<?> list=null;
list.add(null);//啥都不能加，只能加null
//读取
Object o=list.get(0)//允许读取

有限制条件的通配符的使用

List<? extends People> list1=null;
List<? super People> list2=null;

List<stu> list3=null;
List<People> list4=null;
List<Object> list5=null;

//<? extends People>相当于<=
list1=list3;//yes
list1=list4;//yes
list1=list5;//error
//<? super People>相当于>=
list2=list3;//error
list2=list4;//yes
list2=list5;//yes

//list1.add()
list1.add(new People());//error ?相当于负无穷，可以添加子类，但不能添加父类，所以new任何一个都有可能是父类，是不合理的。
list2.add(new People());//yes