java泛型

一,为什么会有泛型

假设我们想要定一个StringArrayList类:

go 复制代码
public class StringArrayList {
    private String[] array;
    private int size;
    public void add(String e) {...}
    public void remove(int index) {...}
    public String get(int index) {...}
}

然后我们又想要定义一个intArrayList类:

go 复制代码
public class IntegerArrayList {
    private Integer[] array;
    private int size;
    public void add(Integer e) {...}
    public void remove(int index) {...}
    public Integer get(int index) {...}
}

这不就重复书写代码了吗?

为了复用代码,我们就想着有一个字符来指代这个类型.于是就有了泛型,顾名思义,就是广义上的类型的别称.

go 复制代码
public class ArrayList<T> {
    private T[] array;
    private int size;
    public void add(T e) {...}
    public void remove(int index) {...}
    public T get(int index) {...}
}

这里ArrayList就是说明这是使用泛型定义的类,其中T就是这个类型代号.

具体使用的时候,把这个T用具体的类型去赋值即可.

go 复制代码
ArrayList<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

二,两种泛型

既然泛型是类型代号,那有一个类型代号,自然也可以有两个类型代号.

go 复制代码
public class Pair<T, K> {
    private T first;
    private K last;
    public Pair(T first, K last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public K getLast() { ... }
}

在使用的时候:

go 复制代码
Pair<String, Integer> p = new Pair<>("test", 123);

三,java泛型的实现方式:擦拭法

擦拭法就是说:虚拟机对泛型其实一无所知,所有的工作都是编译器做的。

当我们书写这样的泛型代码:

go 复制代码
public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

而虚拟机根本不知道泛型。这是虚拟机执行的代码:

go 复制代码
public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

这就导致了一些泛型的局限性:

3.1,不能是基本类型

例如int,因为实际类型是Object,Object类型无法持有基本类型:

go 复制代码
Pair<int> p = new Pair<>(1, 2); // compile error!

3.2,无法取得带泛型的Class

go 复制代码
public class Main {
    public static void main(String[] args) {
        Pair<String> p1 = new Pair<>("Hello", "world");
        Pair<Integer> p2 = new Pair<>(123, 456);
        Class c1 = p1.getClass();
        Class c2 = p2.getClass();
        System.out.println(c1==c2); // true
        System.out.println(c1==Pair.class); // true

    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

因为T是Object,我们对Pair和Pair类型获取Class时,获取到的是同一个Class,也就是Pair类的Class。

换句话说,所有泛型实例,无论T的类型是什么,getClass()返回同一个Class实例,因为编译后它们全部都是Pair。

3.3,无法判断带泛型的类型

go 复制代码
Pair<Integer> p = new Pair<>(123, 456);
// Compile error:
if (p instanceof Pair<String>) {
}

原因和前面一样,并不存在Pair.class,而是只有唯一的Pair.class。

四,entends字符

在Java的泛型中,extends关键字用于限定泛型类型参数的上界(Upper Bound),表示该类型参数必须是指定类型或指定类型的子类。这样可以在泛型类或方法中限制传入的类型参数范围,提高代码的类型安全性。

下面是一个简单的示例,演示了如何在泛型中使用extends关键字:

go 复制代码
// 定义一个泛型类,类型参数必须是Number类或其子类
class Box<T extends Number> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) {
        // 实例化一个Box对象,传入Integer类型参数
        Box<Integer> integerBox = new Box<>(10);
        System.out.println("Integer Value: " + integerBox.getValue());

        // 编译错误,String不是Number类或其子类
        // Box<String> stringBox = new Box<>("Hello");
    }
}

在上面的示例中,泛型类Box使用extends Number限定了类型参数T必须是Number类或其子类。因此,可以实例化Box对象,但不能实例化Box对象,因为String不是Number类或其子类。

五,super字符

在Java的泛型中,super关键字用于限定泛型类型参数的下界(Lower Bound),表示该类型参数必须是指定类型或指定类型的父类。使用super关键字可以在泛型类或方法中限制传入的类型参数范围,提高代码的灵活性和可复用性。

下面是一个简单的示例,演示了如何在泛型中使用super关键字:

go 复制代码
// 定义一个泛型类,类型参数必须是Comparable类或其父类
class Box<T super Comparable<T>> {
    private T value;

    public Box(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }
}

public class Main {
    public static void main(String[] args) {
        // 实例化一个Box对象,传入Integer类型参数
        Box<Integer> integerBox = new Box<>(10);
        System.out.println("Integer Value: " + integerBox.getValue());

        // 实例化一个Box对象,传入String类型参数
        Box<String> stringBox = new Box<>("Hello");
        System.out.println("String Value: " + stringBox.getValue());
    }
}

泛型类Box使用super Comparable限定了类型参数T必须是Comparable类或其父类。因此,可以实例化Box和Box对象,因为Integer和String都实现了Comparable接口。

相关推荐
逊嘘11 分钟前
【Java语言】抽象类与接口
java·开发语言·jvm
Half-up14 分钟前
C语言心型代码解析
c语言·开发语言
morris13118 分钟前
【SpringBoot】Xss的常见攻击方式与防御手段
java·spring boot·xss·csp
Source.Liu35 分钟前
【用Rust写CAD】第二章 第四节 函数
开发语言·rust
monkey_meng35 分钟前
【Rust中的迭代器】
开发语言·后端·rust
余衫马38 分钟前
Rust-Trait 特征编程
开发语言·后端·rust
monkey_meng42 分钟前
【Rust中多线程同步机制】
开发语言·redis·后端·rust
七星静香43 分钟前
laravel chunkById 分块查询 使用时的问题
java·前端·laravel
Jacob程序员44 分钟前
java导出word文件(手绘)
java·开发语言·word
ZHOUPUYU44 分钟前
IntelliJ IDEA超详细下载安装教程(附安装包)
java·ide·intellij-idea