Java泛型详解

泛型的理解
泛型的概念
所谓泛型,就是允许在定义类、接口时通过一个标识表示类中某个属性的类型 或者是 某个方法的返回值类型及参数类型。这个类型参数将在使用时(例如,继承或实现这个接口,用这个类型声明变量、创建对象时)确定(即传入实际的类型参数,也称为类型实参)。

泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法

泛型的引入背景
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象,所以在JDK1.5之前只能把元素类型设计为Object,JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定,其他的部分是确定的,例如关于这个元素如何保存,如何管理等是确定的,因此此时把元素的类型设计成一个参数,这个类型参数叫做泛型。Collection,List,ArrayList 这个就是类型参数,即泛型。

2.1 类型安全
​ 泛型的主要目标是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在非常高的层次上验证类型假设。通过在变量声明中捕获这一附加的类型信息,泛型允许编译器实施这些附加的类型约束。类型错误就可以在编译时被捕获了,而不是在运行时当作ClassCastException展示出来。将类型检查从运行时挪到编译时有助于Java开发人员更早、更容易地找到错误,并可提高程序的可靠性。

//没有泛型的情况
public static void main(String[] args) {
    ArrayList list = new ArrayList<>();
    list.add("11");
    list.add(123);//编译正常
}

//有泛型的情况
public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("11");
    list.add(123);//编译报错
}

2.2 消除强制类型转换
泛型的一个附带好处是,消除源代码中的许多强制类型转换

//没有泛型的代码段需要强制转换
public static void main(String[] args) {
    List list = new ArrayList();
    list.add(123);
    Integer integer = (Integer) list.get(0);
}

//有泛型的代码段不需要强制转换
public static void main(String[] args) {
    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    int s = list.get(0);
}

2.3 更高的运行效率
**​ 避免了不必要的装箱、拆箱操作,提高程序的性能。**在非泛型编程中,将简单类型作为Object传递时会引起Boxing(装箱)和Unboxing(拆箱)操作,这两个过程都是具有很大开销的。引入泛型后,就不必进行Boxing和Unboxing操作了,所以运行效率相对较高,特别在对集合操作非常频繁的系统中,这个特点带来的性能提升更加明显。

//没有使用泛型
public static void main(String[] args) {
    //由于是object类型,会自动进行装箱操作。
    Object a = 1;
    //强制转换,拆箱操作。这样一去一来,当次数多了以后会影响程序的运行效率。
    int b = (int) a;
}

//使用了泛型

潜在的性能收益

​ 提高了代码的重用性,泛型的程序设计,意味着编写的代码可以被很多不同类型的对象所重用

  1. 泛型的使用
    泛型的三种使用方式:泛型类,泛型方法,泛型接口

一般泛型有约定的符号:E 代表 Element, 通常在集合中使用;T 代表 Type,通常用于表示类;K 代表 Key,V 代表 Value, 通常用于键值对的表示;? 代表泛型通配符。

泛型的表达式有如下几种:

普通符号 <T>

无边界通配符 <?>

上界通配符 <? extends E> 父类是 E

下界通配符 <? super E>E 的父类

泛型只在编译阶段有效

泛型类
当泛型用在类和接口时,就被称为泛型类、泛型接口。这个最典型的运用就是各种集合类和接口,比如,List、ArrayList 等等。

那么,我们泛型怎么用在类上面呢?

首先,定义一个泛型类。

public class IdGen<T> {
    protected T id;

    public Generic(T id) {
        this.id = id;
    }
}

IdGen 是一个 id 生成类。第一行代码中, 是泛型标识,代表你定义了一个类型变量 T。第二行代码,我使用这个类型变量,把 id 定义成一个泛型。

然后,在实例化、继承的的时候,指定具体的类型。

public class IdGen<T> {
    // ..省略部分代码

    // 通过继承,确定泛型变量
    static class User extends IdGen<Integer> {
        public User(Integer id) {
            super(id);
        }
    }

    public static void main(String[] args) {
        // 通过实例化,确定泛型变量
        IdGen idGen = new IdGen<String>("1");
        System.out.println(idGen);

        User user = new User(1);
        System.out.println(user);
    }
}

用户类继承了 IdGen,在代码extends IdGen中,指定了 Integer 作为 id 的具体类型;而 IdGen 实例化的时候,在代码new IdGen(“1”)中,则指定了 String 作为 id 的具体类型。

泛型方法
泛型不仅能用在类和接口上,还可以用在方法上。

比如,怎么把一个类的成员变量转换成 Map 集合呢?

这时候,我们可以写一个泛型方法。

public class Generic {
    public static <T> Map obj2Map(T obj) throws Exception {
        Map map = new HashMap<>();

        // 获取所有字段:通过 getClass() 方法获取 Class 对象,然后获取这个类所有字段
        Field[] fields = obj.getClass().getDeclaredFields();
        for (Field field : fields) {
            // 开放字段操作权限
            field.setAccessible(true);
            // 设置值
            map.put(field.getName(), field.get(obj));
        }

        return map;
    }
}

同样的, 是泛型标识,代表你定义了一个类型变量 T,用在这个方法上。T obj 使用类型变量 T,定义一个 obj 参数。最后,在调用方法的的时候,再确定具体的类型。

泛型通配符
泛型通配符用 ? 表示,代表不确定的类型,是泛型的一个重要组成。

有一点很多文章都没提到,大家一定要记住!!!

使用泛型有三个步骤:定义类型变量、使用类型变量、确定类型变量。在第三步,确定类型变量的时候,如果你没法明确类型变量,这时候可以用泛型通配符。

一般情况下,我们不需要用到泛型通配符,因为你能明确地知道类型变量,你看下面代码。

public class Application {

    public static Integer count(List<Integer> list) {
        int total = 0;
        for (Integer number : list) {
            total += number;
        }
        list.add(total);
        return total;
    }

    public static void main(String[] args) {
        // 不传指定数据,编译报错
        List<String> strList = Arrays.asList("0", "1", "2");
        int totalNum = count(strList);

        // 绕过了编译,运行报错
        List strList1 = Arrays.asList("0", "1", "2");
        totalNum = count(strList1);
    }
}

你非常清楚 count() 方法是干什么的,所以你在写代码的时候,直接就能指明这是一个 Integer 集合。这样一来,在调用方法的时候,如果不传指定的数据进来,就没法通过编译。退一万步讲,即使你绕过了编译这一关,程序也很可能没法运行。

所以,如果你非常清楚自己要干什么,可以很明确地知道类型变量,那没必要用泛型通配符。

然而,在一些通用方法中,什么类型的数据都能传进来,你没法确认类型变量,这时候该怎么办呢?

你可以使用泛型通配符,这样就不用确认类型变量,从而实现一些通用算法。

比如,你要写一个通用方法,把传入的 List 集合输出到控制台,那么就可以这样做。

public class Application {
    public static void print(List<?> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    public static void main(String[] args) {
        // Integer 集合,可以运行
        List<Integer> intList = Arrays.asList(0, 1, 2);
        print(intList);

        // String 集合,可以运行
        List<String> strList = Arrays.asList("0", "1", "2");
        print(strList);
    }
}

List list 代表我不确定 List 集合装的是什么类型,有可能是 Integer,有可能是 String,还可能是别的东西。但我不管这些,你只要传一个 List 集合进来,这个方法就能正常运行。

这就是泛型通配符。此外,有些算法虽然也是通用的,但适用范围不那么大。比如,用户分为:普通用户、商家用户,但用户有一些特殊功能,其它角色都没有。这时候,又该怎么办呢?

你可以给泛型通配符设定边界,以此限定类型变量的范围。

泛型通配符的上边界
上边界,代表类型变量的范围有限,只能传入某种类型,或者它的子类。

你看下这幅图就明白了。

利用 的方式,可以设定泛型通配符的上边界。你看下这个例子就明白了。

public class TopLine {

    public static void print(List<? extends Number> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    public static void main(String[] args) {
        // Integer 是 Number 的子类,可以调用 print 方法
        print(new ArrayList<Integer>());

        // String 不是 Number 的子类,没法调用 print 方法
        print(new ArrayList<String>());
    }

}

你想调用 print() 方法中,那么你可以传入 Integer 集合,因为 Integer 是 Number 的子类。但 String 不是 Number 的子类,所以你没法传入 String 集合。

泛型通配符的下边界
下边界,代表类型变量的范围有限,只能传入某种类型,或者它的父类。你看下这幅图就明白了。
Java泛型详解_第1张图片
利用 的方式,可以设定泛型通配符的上边界。你看下这个例子就明白了。

public class LowLine {

    public static void print(List<? super Integer> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    public static void main(String[] args) {
        // Number 是 Integer 的父类,可以调用 print 方法
        print(new ArrayList<Number>());

        // Long 不是 Integer 的父类,没法调用 print 方法
        // print(new ArrayList());
    }
}

你想调用 print() 方法中,那么可以传入 Number 集合,因为 Number 是 Integer 的父类。但 Long 不是 Integer 的父类,所以你没法传入 Long 集合。

泛型是一种特殊的类型,你可以把泛型用在类、接口、方法上,从而实现一些通用算法。

此外,使用泛型有三个步骤:定义类型变量、使用类型变量、确定类型变量。

在确定类型变量这一步中,你可以用泛型通配符来限制泛型的范围,从而实现一些特殊算法。

你可能感兴趣的:(java,jvm,开发语言)