【Java基础】泛型(一)-基础使用

本文以Java的官方文档为参考,辅以代码示例,尽可能详尽的叙述泛型的每一个特性

什么是泛型

泛型(Generics)也称为参数化类型(parameterized types),也就是将类型本身作为接口、类、方法中的参数,相应地声明泛型接口、泛型类、泛型方法,在具体调用时再传入类型参数。从而实现同一种接口、类、方法适用于不同的类型。

为什么要有泛型

  1. 代码重用

泛型程序设计,意味着代码可以针对不同类型重用,你不可能希望针对String和Integer分别编写一个ArrayList

  1. 编译时类型检查

Java5之前,如果想实现泛型就需要这样做:例如定义一个包含Object数组的ArrayList

List v = new ArrayList();
v.add("test"); // 不会做类型检查
Integer i = (Integer)v.get(0); // 运行时异常(Runtime error)

这里其实利用了多态,编译时对set操作不会做类型检查,也不会报get操作的异常。强转的错误在运行时才会抛异常(向下转型不安全

如果一个错误没有被发现,那么系统会进入不可预知的状态,会产生更严重的后果,并且使得错误更难被发现,所以,一个鲁棒的系统应该尽可能早地和多地报告异常。这个哲学思想也可以叫做“故障导向安全原则”。

java5之后引入泛型,实现方式:加入类型参数,(类型本身作为一个参数),好处在于

  1. 更易读:代码会有很好的可读性,人们就知道ArrayList存的是什么类型
  2. 更安全:而且编译时set的时候会有类型检查,get的时候也不用手工强转了

泛型类

泛型类的声明和使用

假设有一个Box类,我希望可以set和get任意类型的object,在没有泛型机制时的定义如下:

public class Box {
    private Object object;

    public void set(Object object) { this.object = object; }
    public Object get() { return object; }
}

显然,如上节中提到,get方法调用时可能会出现运行时异常,因此我们利用泛型来实现Box类

首先,泛型类的定义格式如下:

class name<T1, T2, ..., Tn>

尖括号中是类型参数,可以被用在类中的任意位置,包括对象类型,方法入参类型,返回值类型。

由此,Box类的定义如下:

public class Box<T> {
    // T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

可以看出这里就是将原来Object类型全部换成了类型参数T

创建类对象,将T替换为实际的类型参数即可(就像给方法传参一样,将形参T变为实参Integer)

Box<Integer> integerBox = new Box<Integer>();

简化的使用方式:类型推断

Java 7之后可以利用类型推断,省略构造器后面的泛型:

Box<Integer> integerBox = new Box<>();

泛型接口

泛型接口的声明和使用

泛型接口与泛型类的定义大同小异,以一个简化的List接口为例

public interface List<E> {
    boolean add(E e);
    E get(int index);
}

实现或者继承泛型接口,有两种情况:

一种是不替换泛型形参E,即不指定具体的类型。这时类名后面必须也把泛型实参添加上,以ArrayList为例

public class ArrayList<E> extends AbstractList<E>
    implements List<E> { //ArrayList后面必须添加
    boolean add(E e);
    E get(int index);
}

另一种就是替换泛型形参E。这时实现类中所有形参出现的地方必须替换为实参,例如我定义了一个只存String类型的StringArrayList

public class StringArrayList extends ArrayList<String> { 
    boolean add(String e); //方法重写
    String get(int index);
}

泛型方法

泛型方法的声明和使用

泛型方法是带类型参数的方法,注意类型参数在修饰符后面,返回类型前面。

泛型方法的作用范围只在本方法中,因此可以作为方法入参类型,或者返回值类型

典型例子就是Arrays.asList方法(泛型方法其实在Collections, Arrays等工具类中应用的很广泛

public static <T> List<T> asList(T... a) { //这里返回List,其实就相当于T用在了泛型方法的返回值类型中
    return new ArrayList<>(a);
}

这时如何使用上面的泛型方法?有以下两种:

  1. 替换尖括号内的类型参数(相当于传参
String[] stringArr = new String[]{"abc", "123", "opq"};
List<String> StringList = Arrays.<String>asList(stringArr);
  1. 编译器自行推断 一般我们在使用工具类的泛型方法时基本没见过上面的语法,其实编译器可以通过传入参数进行推断
List<String> StringList = Arrays.asList(stringArr);

注意事项:静态方法使用泛型

上面提到类型形参T可以用在类中的任意位置,但实际上不可以作为静态方法的入参和返回值类型,如果想让静态方法用到泛型,就得让静态方法自身变为泛型方法。

public class Box<T> {
    //这里Box后面的泛型和静态方法的泛型并不是一个类型
    public static <T> void show(T t){

    }
}

限定类型参数

泛型上边界的使用

有时你会希望泛型的类型有一定的限制,比如希望定义一个只能存Number类型的Box,就可以这样声明

public class Box<T extends Number> 

这时的Number就是泛型类型T的上边界,T也被称作限定类型参数(Bounded Type Parameters)

注意,你可以定义多个上边界,语法如下:

<T extends A & B & C>

需要注意的是,上边界可能是class,也可能是interface,class要放在interface的前面,否则编译不过

限定类型参数有什么好处

其实限定了参数的边界,也是为了利用泛型在编译期检查类型的特点,如果你希望T继承了某种类型,你就可以在编译时发现传入的参数是否正确,可以用以下这个例子来理解

官方的教程中提到:限定类型参数尤其在泛型方法的实现中应用广泛,一般是要求T类型的对象本身具备一些功能以Collections接口的sort方法为例(先忽视通配符?和下边界super)

public static <T extends Comparable<? super T>> void sort(List<T> list) {
		list.sort(null);
}

    
public static <T> void sort(List<T> list, Comparator<? super T> c) {
		list.sort(c);
}

这两种方法其实也就对应了序列排序的两种常见办法:

  1. 序列中的对象继承Comparable接口,并且在compare方法中实现比较逻辑
  2. 外部传入Comparator接口的实现类,并且要实现其中compare方法(更松耦合,不要求对象具备Comparable接口的功能了)

问题来了,list.sort()其实就能实现这两种排序了(传参为null就是第一种,不为null就是第二种),为什么还要用Collections接口包装一下呢?

试想这样一个反例:自定义了Box类作为序列的元素,Box很简单,没有继承Comparable接口,sort方法也没传入Comparator比较器,这时你没办法给序列排序,因为你根本就没指定Box对象的比较逻辑。

此时运行sort会抛出ClassCastException异常,因为boxList.sort()方法的逻辑是:传入的Comparator实现类为null,就会认为对象继承了Comparable接口,将对象向上转型为Comparable类型,而Box并没有继承Comparable接口,所以会抛异常

ArrayList<Box> boxList = new ArrayList<>();
//省略添加元素的过程...
boxList.sort(null); //运行时抛出ClassCastException

而这时,如果用的是Collections.sort()方法,就可以在编译时利用限定边界的特性发现Box并没有继承Comparable,从而将异常转为编译期异常,你就直接会在IDE中发现一条红线了

Collections.sort(boxList)

总之,还是为了在编译时提早发现类型参数不符合限定边界的情况,也让T类型的对象在做强转的时候更加安全

(关于泛型的下边界,之后会和泛型通配符一起讲解)

你可能感兴趣的:(#,Java基础,java)