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接口。

相关推荐
以后不吃煲仔饭9 分钟前
Java基础夯实——2.7 线程上下文切换
java·开发语言
进阶的架构师10 分钟前
2024年Java面试题及答案整理(1000+面试题附答案解析)
java·开发语言
前端拾光者14 分钟前
利用D3.js实现数据可视化的简单示例
开发语言·javascript·信息可视化
The_Ticker15 分钟前
CFD平台如何接入实时行情源
java·大数据·数据库·人工智能·算法·区块链·软件工程
程序猿阿伟15 分钟前
《C++ 实现区块链:区块时间戳的存储与验证机制解析》
开发语言·c++·区块链
傻啦嘿哟33 分钟前
如何使用 Python 开发一个简单的文本数据转换为 Excel 工具
开发语言·python·excel
大数据编程之光37 分钟前
Flink Standalone集群模式安装部署全攻略
java·大数据·开发语言·面试·flink
初九之潜龙勿用38 分钟前
C#校验画布签名图片是否为空白
开发语言·ui·c#·.net
爪哇学长1 小时前
双指针算法详解:原理、应用场景及代码示例
java·数据结构·算法
Dola_Pan1 小时前
C语言:数组转换指针的时机
c语言·开发语言·算法