Java泛型基础

2022-07-19 本文已影响0人 Tinyspot

Preface

Generic Types
type parameter names are single, uppercase letters
The most commonly used type parameter names are:
- E - Element (used extensively by the Java Collections Framework)
- K - Key
- N - Number
- T - Type
- V - Value
- S,U,V etc. - 2nd, 3rd, 4th types

1. 基本概念

本质：泛型就是类型参数化，处理的数据类型不是固定的，而是可以作为参数传入
没有指定具体数据类型时，默认操作类型是 Object
只支持类类型，不支持基本类型
同一泛型类，本质上都是相同类型
好处
- 保证类型安全：泛型约束了变量的类型，保证了类型的安全性（在编译时就可检查类型匹配）
- 提高代码的重用性
- 消除强制类型转换：未使用泛型前，需要强制类型转换

2. 泛型基本用法

泛型类，是在实例化类的时候指明泛型的具体类型；
泛型方法，是在调用方法的时候指明泛型的具体类型，更加灵活

2.1 泛型类

泛型类：类名<T>，T 是类型占位符，表示一种引用类型

// T 表示类型参数
public class Result<T> {
    private boolean success;
    private String statusCode;
    private String message;
    // 方式一：作为变量类型
    private T data;

    // 方式二：作为方法参数
    protected void success(T data) {
        setData(data);
        setSuccess(true);
    }
    // 方式三：作为方法返回值
    public T getData() {
        return data;
    }
    // Getter/Setter ...
}
class MultiResult<T, S, U> {
    private T first;
    private S second;
    private U third;
}

使用示例：

public interface BusinessService {
    Result<User> queryUser();
    Result<Order> queryOrder();
}

2.2 泛型方法

泛型方法，就是在声明方法时定义一个或多个类型形参
当方法中的类型与类冲突时，方法中的 T 会覆盖类的 T

语法：[修饰符] [static] <T, R> 返回值类型 method(...) {}
注：<T> 必须存在，并且在方法返回值之前

public <T> T show(T t) {
    return t;
}

Demo demo = new Demo();
String str = demo.show("str");

<T> 声明此方法为泛型方法，指定方法类型，此类型既可以在参数中用，也可以在返回值中用

public static <T> T test(Class<T> clazz) {
    try {
        return clazz.newInstance();
    } catch (Exception e) {
        return null;
    }
}

public static <T> T test(Object obj) {
    return (T) obj;
}

// 方法签名 - 多类型  <T, R>
public <T, R> R count(T t) {
}

public interface Service {
    <T> ResultDTO<T> execute(ServiceCallback<T> callback, String serviceName);
}
public interface ServiceCallback<T> {    
}

2.3 泛型接口

public interface QueryService<T, R> {
    R execute(T obj);
}

泛型类派生子类，见 Java 泛型详解

public class QueryServiceImpl implements QueryService<String, Result> {
    @Override
    public Result execute(String obj) {
        return null;
    }
}

public class QueryServiceImpl2<T, R> implements QueryService<T, R> {
    @Override
    public R execute(T obj) {
        return null;
    }
}

QueryServiceImpl queryService = new QueryServiceImpl();
Result result = queryService.execute("111");

QueryServiceImpl2<String, Result> queryService2 = new QueryServiceImpl2<>();
Result result2 = queryService2.execute("222");

2.4 扩展：泛型接口和泛型方法混合

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);
    <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
}

3. 泛型通配符

3.1 类型通配符（?）

In generic code, the question mark (?), called the wildcard, represents an unknown type
List<?> 表示未知类型元素的 List，仅表示它是各种泛型 List 的父类，并不能把元素加入到其中

泛型类型不管继承关系，只管严格的匹配
例如：String 是 Object 的子类，但 List<String> 不是List<Object>类的子类
编译报错：不兼容的类型: java.util.List<java.lang.String>无法转换为java.util.List<java.lang.Object>

可将 List<Object> 改为 List<?>，但还需进行强制类型转换
改进，使用受限制通配符List<? extends Shape>，注意：因无法准确知道这个类型是什么，所以不能把 Shape 对象或其子类的对象加入这个泛型集合中

3.2 受限制通配符（泛型约束）

上界通配符 <? extends Type> : Get First，协变，无法确定子类类型，只读
下界通配符 <? super Type>: Put First，逆变，无法确定父类，只写

上界通配符

public static void main(String[] args) {
    // public interface List<E> extends Collection<E> {}
    List<String> strings = new ArrayList<>();
    List<Object> objects = new ArrayList<>();

    test(strings, objects); // 类型推断失败，编译报错
    test2(strings, objects);
}
public static <T> void test(Collection<T> from, Collection<T> to) {
    for (T ele : from) {
        to.add(ele);
    }
}
/**
 * Collection<? extends T> 类型改为 T 的子类
 *
 * Collection<? extends T>: 类型通配符的表示方式
 * Collection<T> to: 泛型方法的表示方式
 */
public static <T> void test2(Collection<? extends T> from, Collection<T> to) {
    for (T ele : from) {
        to.add(ele);
    }
}

public static void main(String[] args) {
    // public final class Integer extends Number implements Comparable<Integer> {}
    List<Number> numbers = new ArrayList<>();
    List<Integer> integers = new ArrayList<>();

    Number copy = copy(numbers, integers);
    Integer integer = copy2(numbers, integers);
    System.out.println(copy);
}
/**
 * 返回类型只会与 dest 相同
 */
public static <T> T copy(Collection<T> dest, Collection<? extends T> src) {
    T last = null;
    for (T ele : src) {
        last = ele;
        dest.add(ele);
    }
    return last;
}
/**
 * 改进：不管src集合元素的类型是什么，只要dest集合元素的类型与前者相同或是前者的父类即可
 * @return
 */
public static <T> T copy2(Collection<? super T> dest, Collection<T> src) {
    T last = null;
    for (T ele : src) {
        last = ele;
        dest.add(ele);
    }
    return last;
}
// 思考：copy(List<? super T> dest, List<? extends T> src)

3.3 T vs ?

? 和 T 都表示不确定的类型，区别在于我们可以对 T 进行操作，但是对 ?不行
T 是一个确定的类型，通常用于泛型类和泛型方法的定义
？是一个不确定的类型，通常用于泛型方法的调用代码和形参，不能用于定义类和泛型方法。

3.4 类型通配符 vs 泛型方法

类型通配符既可以在方法签名中定义形参的类型，也可以用于定义变量的类型；但泛型方法中的类型形参必须在对应方法中显式声明
如果某个方法中一个形参（a）的类型或返回值的类型依赖于另一个形参（b）的类型，则形参（b）的类型声明不应该使用通配符
扩展：何时使用泛型方法？何时使用类型通配符？

List<T> 中的 T 是一个形参，可以理解为一个占位符（表示一种引用类型），被使用时，会在程序运行的时候替换成具体的类型，比如替换成String，Integer之类的。
List<?> 中的 ? 是一个实参，这是Java定义的一种特殊类型，比Object更特殊，就像一个影子。比如List<Object>和List<String>是没有父子关系的，这是两个类型，List<Object>类型和List<String>类型；但是List<?> 是 List<String>的父类

References

泛型：工作原理及其重要性 - Oracle

结束语

碎片时间很难用来做系统化学习，所以纯移动端的内容做到最后都会变成以技术的名义养生：知道了各种奇技淫巧，然而并没有什么用。
当然作为知识树的查漏补缺还是不错的，前提是已经完成了系统学习。