java的泛型

一。泛型的作用

用来限制输入数据或者参数的类型

public class test7{

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("qqyumidi");
        list.add("corn");
        list.add(100);

        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i); // 这里会报错，因为get是string类型的方法，不能用到int类型中
            System.out.println("name:" + name);
        }
    }
}

为了避免这种错误，可以让list只放一种数据类型，在他的入口加以限制。

public class test7{
    public static void main(String[] args) {
        List <String> list = new ArrayList();
//        list.add(100);会发生编译错误，这样就能确保list中只有string类型
            list.add("aa");
        for (int i = 0; i < list.size(); i++) {
            String name = (String) list.get(i);
            System.out.println("name:" + name);
        }
    }
}

 自定义泛型类

就是在定义时并不指明该方法的具体的类型，而是用E来代替，在调用时再给，给了之后，类中的所有出现E的地方都会是那个类型。

package com.reflection;

public class test7 {
    public static void main(String[] args) {
     Boxx<String> boxx1= new Boxx<String>("ss");
        Boxx<Integer> boxx2= new<Integer> Boxx(100);
//     boxx1.setdata(10000);会报错，因为boxX1中的参数T全部是String类型
        System.out.println(boxx1.returndata());
        System.out.println(boxx2.returndata());
    }
}
class Boxx<T> {
    Boxx(T a) {
        this.data = a;
    }
    private T data;
    public T returndata() {
        return data;
    }
    public void setdata(T b) {
        this.data=b;
    }
}

泛型方法的类型通配符

泛型方法就是把泛型作为参数的方法。
这就是个泛型方法,它只接受 map，而且map的key是String类型，value是User类型

 public static void display(Map<String,User> a)
    {
       System.out.println(a);
    }

Number是integer的父类，但是在泛型中不能这么写，下面的例子会报错

public class GenericTest {

    public static void main(String[] args) {

        Box<Number> name = new Box<Number>(99);
        Box<Integer> age = new Box<Integer>(712);

        getData(name);

        //The method getData(Box<Number>) in the type GenericTest is
        //not applicable for the arguments (Box<Integer>)
        getData(age);   // 1

    }

    public static void getData(Box<Number> data){
        System.out.println("data :" + data.getData());
    }

}

所以我想写一个方法，不仅对String参数的该类使用，也能对其他参数的该类使用，就要用到类型通配符，如下

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);
        Box<Number> number = new Box<Number>(314);

        getData(name);
        getData(age);
        getData(number);
    }

    public static void getData(Box<?> data) {
        System.out.println("data :" + data.getData());
    }

}

通配符上限和下限

通配符上限，是为了让函数只能执行某个类型和他的子类，

通配符下线，是为了让函数只能执行某个类型和他的父类

类型通配符上限通过形如Box<? extends Number>形式定义，相对应的，类型通配符下限为Box<? super Number>形式

public class GenericTest {

    public static void main(String[] args) {

        Box<String> name = new Box<String>("corn");
        Box<Integer> age = new Box<Integer>(712);
        Box<Number> number = new Box<Number>(314);

        getData(name);
        getData(age);
        getData(number);

        //getUpperNumberData(name); // 有错误，因为string类型不是number的子类
        getUpperNumberData(age);    // 没问题
        getUpperNumberData(number); // 没问题
    }

    public static void getData(Box<?> data) {
        System.out.println("data :" + data.getData());
    }

    public static void getUpperNumberData(Box<? extends Number> data){
        System.out.println("data :" + data.getData());
    }

}

Java总结篇系列：Java泛型 - HappyCorn - 博客园