Java 泛型大揭秘：类型参数、通配符与优秀实践

迷路的架构师 2023-03-28 原文

引言

在编程世界中，代码的可重用性和可维护性是至关重要的。为了实现这些目标，Java 5 引入了一种名为泛型（Generics）的强大功能。本文将详细介绍 Java 泛型的概念、优势和局限性，以及如何在实际编程中应用泛型。

泛型是一种允许程序员在类、接口和方法中使用类型参数的编程范式。这意味着，我们可以编写一段具有通用性质的代码，从而减少重复的代码，同时提高代码的可读性和可维护性。泛型允许我们在编译时检查类型安全，减少运行时类型转换错误，使得代码更加健壮。此外，泛型还有助于减少代码中的类型强制转换，从而提高代码质量。

在接下来的文章中，我们将深入探讨 Java 泛型的各个方面，包括类型参数、泛型类、泛型接口、泛型方法、类型擦除、泛型的实际应用和最佳实践等。无论您是初学者还是有经验的 Java 开发者，这篇文章都将帮助您更好地理解和掌握 Java 泛型的概念和应用。

Java 泛型基础

在深入了解 Java 泛型的具体应用之前，我们需要先掌握一些基本概念。在本节中，我们将介绍类型参数、泛型类、泛型接口和泛型方法的概念和用法。

1.类型参数

类型参数是泛型编程的核心。它是一个占位符，用于表示一种未知的类型。在 Java 中，类型参数通常用尖括号（<>）括起来，并放在类名或接口名后面。例如，对于一个名为 Box 的泛型类，我们可以使用类型参数 T 来表示盒子中存储的对象类型：

public class Box<T> {
    // ...
}

2.泛型类

泛型类是使用类型参数定义的类。类型参数可以在类中的字段、方法参数和返回类型中使用，从而提供更高的灵活性和代码重用性。以下是一个简单的泛型类示例，用于存储和获取一个对象：

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

使用泛型类时，我们需要为类型参数指定具体的类型。例如，我们可以创建一个用于存储整数的 Box 实例：

Box<Integer> integerBox = new Box<>();
integerBox.setContent(42);
Integer value = integerBox.getContent();

3.泛型接口

与泛型类类似，泛型接口也可以使用类型参数。以下是一个泛型接口的示例，用于定义一个可以进行比较的对象：

public interface Comparable<T> {
    int compareTo(T other);
}

实现泛型接口时，需要为类型参数指定具体的类型。例如，我们可以创建一个实现 Comparable 接口的 Person 类：

public class Person implements Comparable<Person> {
    private String name;

    // ...

    @Override
    public int compareTo(Person other) {
        return this.name.compareTo(other.name);
    }
}

4.泛型方法

泛型方法是在方法级别使用类型参数的方法。与泛型类和接口不同，泛型方法可以在普通类和接口中定义。泛型方法的类型参数位于方法返回类型之前，并用尖括号括起来。以下是一个泛型方法的示例，用于交换数组中两个元素的位置：

public static <T> void swap(T[] array, int i, int j) {
    T temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

调用泛型方法时，编译器通常可以根据方法参数推断出类型参数的具体类型。例如：

Integer[]

类型参数约束

在使用泛型时，有时我们希望限制类型参数可以接受的类型范围。例如，我们可能只想接受实现了某个接口或继承了某个特定类的类型。在这种情况下，我们可以使用有界类型参数来约束类型参数的范围。

1.有界类型参数

有界类型参数允许我们通过指定一个或多个边界来限制类型参数可以接受的类型范围。边界可以是类或接口，使用关键字 extends 来指定。例如，我们可以创建一个泛型类 NumericBox，它只接受 Number 类及其子类的类型参数：

public class NumericBox<T extends Number> {
    private T content;

    // ...
}

在这个例子中，T 必须是 Number 类或其子类，如 Integer、Double 等。尝试使用非 Number 类型将导致编译错误：

NumericBox<Integer> integerBox = new NumericBox<>(); // 有效
NumericBox<String> stringBox = new NumericBox<>(); // 编译错误

2.多个边界

在某些情况下，我们可能希望类型参数满足多个约束。Java 允许我们通过使用 & 符号来指定多个边界。需要注意的是，多个边界中最多只能有一个类，其余边界必须是接口。例如，我们可以创建一个泛型类 PrintableComparableBox，它接受实现了 Comparable 和 Printable 接口的类型参数：

public class PrintableComparableBox<T extends Comparable<T> & Printable> {
    private T content;

    // ...
}

3.通配符

通配符是 Java 泛型中的一种特殊类型参数，用 ? 表示。它表示未知类型，使我们能够编写更灵活的泛型代码。通配符可用于泛型类、泛型接口和泛型方法的参数和返回类型。

通配符可以有两种形式：有界通配符和无界通配符。有界通配符使用 extends 或 super 关键字来限制通配符可以表示的类型范围。例如，我们可以创建一个方法，该方法接受一个 List 参数，其中元素类型为 Number 类或其子类：

public static void processNumbers(List<? extends Number> numbers) {
    // ...
}

在这个例子中，我们可以使用 List<Integer>、List<Double> 等类型作为参数，但不能使用 List<String> 类型。

泛型和继承

在 Java 泛型中，继承与泛型类、泛型接口和泛型方法有关。本节将探讨如何在这些场景中使用泛型继承，以及如何覆盖泛型方法。

1.子类化泛型类

当创建一个泛型类的子类时，可以选择继续保留泛型参数，也可以为泛型参数指定一个具体类型。以下是一个示例，展示了如何继承一个泛型类 Box：

public class Box<T> {
    private T content;

    // ...
}

// 保留泛型参数
public class SpecialBox<T> extends Box<T> {
    // ...
}

// 为泛型参数指定具体类型
public class IntegerBox extends Box<Integer> {
    // ...
}

在这个例子中，SpecialBox 类继续保留了泛型参数 T，而 IntegerBox 类则为泛型参数指定了具体类型 Integer。

2.子类化泛型接口

与泛型类类似，实现泛型接口时也可以选择保留泛型参数或为泛型参数指定一个具体类型。以下是一个示例，展示了如何实现一个泛型接口 Comparable：

public interface Comparable<T> {
    int compareTo(T other);
}

// 保留泛型参数
public class GenericComparable<T> implements Comparable<T> {
    // ...
}

// 为泛型参数指定具体类型
public class StringComparable implements Comparable<String> {
    // ...
}

在这个例子中，GenericComparable 类继续保留了泛型参数 T，而 StringComparable 类则为泛型参数指定了具体类型 String。

3.覆盖泛型方法

当一个类继承自一个包含泛型方法的类时，子类需要覆盖这些泛型方法。覆盖泛型方法时，需要保留方法的类型参数，且方法签名必须与父类中的方法相匹配。以下是一个示例，展示了如何覆盖一个泛型方法：

public class Parent {
    public <T> T doSomething(T input) {
        // ...
    }
}

public class Child extends Parent {
    @Override
    public <T> T doSomething(T input) {
        // ...
    }
}

在这个例子中，Child 类覆盖了 Parent 类中的泛型方法 doSomething，同时保留了方法的类型参数 T。

类型擦除和泛型限制

虽然泛型为 Java 语言带来了许多优势，但它也有一些限制。本节将详细介绍类型擦除的概念以及泛型中的一些限制。

1.类型擦除

类型擦除是 Java 编译器处理泛型的一种机制。为了保持向后兼容性，当编译泛型代码时，编译器会移除所有类型参数和类型信息，将泛型类型替换为它们的原始类型或有界类型。以下是一个泛型类 Box 的例子：

public class Box<T> {
    private T content;

    public void setContent(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }
}

编译后，类型擦除会将 Box 类转换为以下形式：

public class Box {
    private Object content;

    public void setContent(Object content) {
        this.content = content;
    }

    public Object getContent() {
        return content;
    }
}

如上所示，类型擦除将泛型类型 T 替换为 Object 类型。这意味着运行时不再具有泛型类型信息，因此泛型代码无法在运行时检查类型信息。

2.泛型数组限制

由于类型擦除的存在，我们无法创建具有泛型类型参数的数组。例如，以下代码将导致编译错误：

T[] array = new T[10]; // 编译错误

要创建泛型数组，可以使用 Object[] 数组并在运行时执行类型转换。例如：

Object[] array = new Object[10];
array[0] = new Integer(42);
T value = (T) array[0];

3.泛型限制

除了数组限制之外，泛型还有一些其他限制，例如：

无法对泛型类型参数进行 instanceof 操作。这是因为类型擦除后，泛型类型参数的信息在运行时不可用。
无法直接实例化泛型类型参数。要创建泛型类型参数的实例，可以使用反射或传递工厂对象。
泛型类型参数不能是基本类型。要使用基本类型，可以使用它们的包装类，如 Integer、Double 等。
静态成员不能使用泛型类型参数。因为静态成员在类级别上定义，而泛型类型参数在实例级别上定义。

通配符的使用和限制

通配符（Wildcard）是 Java 泛型中一种特殊的类型参数，用于表示未知类型。通配符提高了泛型代码的灵活性，但也引入了一些限制。本节将详细介绍通配符的使用和限制。

1.通配符的使用

通配符用 ? 表示，并可以用于泛型类、泛型接口和泛型方法的参数和返回类型。以下是一个示例，展示了如何使用通配符作为方法参数：

public static void printBoxContent(Box<?> box) {
    System.out.println(box.getContent());
}

在这个例子中，printBoxContent 方法接受一个类型为 Box<?> 的参数，表示它可以接受任何类型的 Box 对象。

2.有界通配符

有界通配符使用 extends 或 super 关键字来限制通配符可以表示的类型范围。例如，以下方法接受一个元素类型为 Number 或其子类的 List：

public static void processNumbers(List<? extends Number> numbers) {
    // ...
}

在这个例子中，我们可以使用 List<Integer>、List<Double> 等类型作为参数，但不能使用 List<String> 类型。

3.通配符限制

尽管通配符提供了更大的灵活性，但它们也引入了一些限制。当使用通配符时，需要注意以下事项：

无法创建具有通配符类型的对象。例如，以下代码将导致编译错误：

Box<?> box = new Box<?>(); // 编译错误

当使用通配符类型参数时，类型安全可能受到限制。例如，以下代码将导致编译错误，因为编译器无法确保 box.setContent() 方法的参数类型与 Box<?> 的实际类型匹配：

public static void setBoxContent(Box<?> box, Object content) {
    box.setContent(content); // 编译错误
}

要解决这个问题，可以使用泛型方法而不是通配符。例如：

public static <T> void setBoxContent(Box<T> box, T content) {
    box.setContent(content);
}

通配符为 Java 泛型带来了更高的灵活性，但在使用过程中需要注意一些限制。理解通配符的使用和限制对于编写类型安全和易于维护的泛型代码至关重要。

泛型的实际应用

在实际编程中，泛型在许多场景中都发挥着重要作用。本节将介绍一些使用泛型的典型应用场景，以帮助您更好地理解泛型在实际开发中的价值。

1.泛型集合

Java 集合框架广泛使用泛型来提供类型安全的数据结构，如 List、Set、Map 等。使用泛型集合可以避免类型转换和运行时类型错误。

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");

for (String name : names) {
    System.out.println(name);
}

在这个例子中，我们创建了一个 List 对象来存储 String 类型的元素。由于泛型的使用，我们不需要在获取元素时进行类型转换。

2.泛型类和接口

在实际开发中，我们可能需要创建通用的数据结构和算法。泛型类和接口允许我们编写可以处理多种数据类型的通用代码。

public interface Transformer<T, R> {
    R transform(T input);
}

public class UpperCaseTransformer implements Transformer<String, String> {
    @Override
    public String transform(String input) {
        return input.toUpperCase();
    }
}

在这个例子中，我们创建了一个名为 Transformer 的泛型接口，以及一个实现该接口的 UpperCaseTransformer 类。这使得我们可以编写通用的转换逻辑，而无需为每种数据类型创建单独的类。

3.泛型方法

泛型方法允许我们编写通用的、可重用的方法，而无需在类级别指定类型参数。以下是一个使用泛型方法实现的交换数组元素的示例：

public static <T> void swap(T[] array, int i, int j) {
    T temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

在这个例子中，我们创建了一个名为 swap 的泛型方法，它可以用于交换任何类型的数组元素。

通过了解泛型在实际应用中的使用场景，我们可以更好地利用泛型编写类型安全、可重用和灵活的代码。泛型是 Java 语言中一个强大且重要的特性，掌握泛型的使用对于成为一个高效的 Java 开发者至关重要。

泛型的最佳实践

在使用 Java 泛型时，遵循一些最佳实践可以帮助您编写更加健壮、安全和可维护的代码。本节将介绍泛型编程的一些最佳实践。

1.使用泛型类型参数确保类型安全

当您需要使用通用数据结构或算法时，应该优先使用泛型类型参数，而不是将类型参数替换为 Object。这样可以确保类型安全，减少运行时错误的风险。

// 使用泛型类型参数
public class Box<T> {
    private T content;

    // ...
}

// 不推荐的做法：使用 Object 替代泛型类型参数
public class Box {
    private Object content;

    // ...
}

2.优先使用有界通配符

当您需要使用泛型类型参数的方法参数或返回类型时，优先使用有界通配符来提高代码的灵活性。使用有界通配符可以让您的代码接受更广泛的类型，同时保持类型安全。

// 使用有界通配符
public void processBoxes(List<? extends Box> boxes) {
    // ...
}

// 不推荐的做法：不使用通配符
public void processBoxes(List<Box> boxes) {
    // ...
}

3.在需要时使用泛型方法

当您需要编写通用方法时，但不希望在整个类上使用泛型参数时，可以使用泛型方法。泛型方法允许您在方法级别指定类型参数，从而提供更大的灵活性。

public static <T> T getFirst(List<T> list) {
    if (!list.isEmpty()) {
        return list.get(0);
    }
    return null;
}

4.避免使用原始类型

使用原始类型（未指定类型参数的泛型类型）可能会导致类型安全问题。在使用泛型类和接口时，应避免使用原始类型，并为类型参数提供具体类型或通配符。

// 使用具体类型
List<String> names = new ArrayList<>();

// 使用通配符
List<?> items = new ArrayList<>();

// 不推荐的做法：使用原始类型
List names = new ArrayList();

5.为泛型类型参数选择有意义的名称

为泛型类型参数选择有意义的名称可以提高代码的可读性。通常，单个大写字母（如 T、E、K、V 等）用作类型参数名称。例如，T 通常表示 "类型"（Type），E 表示 "元素"（Element），K 和 V 分别表示 "键"（Key）和 "值"（Value）。

public class KeyValuePair<K, V> {
  private K key;
  private V value;

  public KeyValuePair(K key, V value) {
      this.key = key;
      this.value = value;
  }

  // ...

6.注意类型擦除带来的限制

了解类型擦除如何影响泛型代码，并注意避免可能导致编译错误或运行时错误的操作。例如，避免创建泛型数组、直接实例化泛型类型参数等。

在文档中注明泛型类型参数的约束和用途

为了帮助其他开发者理解和使用您的泛型代码，应在文档注释中清楚地描述泛型类型参数的约束和用途。

/**
 * This class represents a cache for storing objects of type V, keyed by objects of type K.
 *
 * @param <K> the type of the keys used to access the cache
 * @param <V> the type of the objects stored in the cache
 */
public class Cache<K, V> {
    // ...
}

遵循这些泛型最佳实践可以帮助您编写更加健壮、安全和可维护的代码。在实际开发中，始终关注并应用这些最佳实践，以充分利用 Java 泛型所提供的优势。

总结

在本文中，我们详细讨论了 Java 泛型的各个方面，包括泛型的基本概念、类型参数约束、泛型与继承、类型擦除与泛型限制、通配符的使用与限制、泛型的实际应用以及泛型编程的最佳实践。通过这些讨论，我们了解到泛型是 Java 语言中一个非常强大和重要的特性，它可以帮助我们编写更加类型安全、可重用和灵活的代码。

要成为一名高效的 Java 开发者，掌握泛型的使用是至关重要的。在实际开发中，应始终关注并应用泛型最佳实践，以充分利用泛型所提供的优势。此外，不断学习和实践是提高编程技能的关键，因此请继续关注更多关于 Java 以及其他编程相关主题的文章和教程。

希望本文能够帮助您更好地理解和掌握 Java 泛型，为您的编程之旅提供有益的指导。

优秀 Java span style color 开发前端 $Java Java 泛型

有关Java 泛型大揭秘：类型参数、通配符与优秀实践的更多相关文章

ruby-on-rails - 使用 Ruby on Rails 进行自动化测试 - 最佳实践 - 2
很好奇，就使用rubyonrails自动化单元测试而言，你们正在做什么？您是否创建了一个脚本来在cron中运行rake作业并将结果邮寄给您？git中的预提交Hook？只是手动调用？我完全理解测试，但想知道在错误发生之前捕获错误的最佳实践是什么。让我们理所当然地认为测试本身是完美无缺的，并且可以正常工作。下一步是什么以确保他们在正确的时间将可能有害的结果传达给您？最佳答案不确定您到底想听什么，但是有几个级别的自动代码库控制:在处理某项功能时，您可以使用类似autotest的内容获得关于哪些有效，哪些无效的即时反馈。要确保您的提
ruby-on-rails - 如何在 ruby 中使用两个参数异步运行 exe？ - 2
exe应该在我打开页面时运行。异步进程需要运行。有什么方法可以在ruby中使用两个参数异步运行exe吗？我已经尝试过ruby命令-system()、exec()但它正在等待过程完成。我需要用参数启动exe，无需等待进程完成是否有任何rubygems会支持我的问题？最佳答案您可以使用Process.spawn和Process.wait2:pid=Process.spawn'your.exe','--option'#Later...pid,status=Process.wait2pid您的程序将作为解释器的子进程执行。除
ruby - RSpec - 使用测试替身作为 block 参数 - 2
我有一些Ruby代码，如下所示:Something.createdo|x|x.foo=barend我想编写一个测试，它使用double代替block参数x，这样我就可以调用:x_double.should_receive(:foo).with("whatever").这可能吗？最佳答案 specify'something'dox=doublex.should_receive(:foo=).with("whatever")Something.should_receive(:create).and_yield(x)#callthere
ruby - 如何在 Ruby 中拆分参数字符串 Bash 样式？ - 2
我正在为一个项目制作一个简单的shell，我希望像在Bash中一样解析参数字符串。foobar"helloworld"fooz应该变成:["foo","bar","helloworld","fooz"]等等。到目前为止，我一直在使用CSV::parse_line，将列分隔符设置为""和.compact输出。问题是我现在必须选择是要支持单引号还是双引号。CSV不支持超过一个分隔符。Python有一个名为shlex的模块:>>>shlex.split("Test'helloworld'foo")['Test','helloworld','foo']>>>shlex.split('Test"
ruby - Infinity 和 NaN 的类型是什么？ - 2
我可以得到Infinity和NaNn=9.0/0#=>Infinityn.class#=>Floatm=0/0.0#=>NaNm.class#=>Float但是当我想直接访问Infinity或NaN时:Infinity#=>uninitializedconstantInfinity(NameError)NaN#=>uninitializedconstantNaN(NameError)什么是Infinity和NaN？它们是对象、关键字还是其他东西？最佳答案您看到打印为Infinity和NaN的只是Float类的两个特殊实例的字符串
ruby - 检查方法参数的类型 - 2
我不确定传递给方法的对象的类型是否正确。我可能会将一个字符串传递给一个只能处理整数的函数。某种运行时保证怎么样？我看不到比以下更好的选择:defsomeFixNumMangler(input)raise"wrongtype:integerrequired"unlessinput.class==FixNumother_stuffend有更好的选择吗？最佳答案使用Kernel#Integer在使用之前转换输入的方法。当无法以任何合理的方式将输入转换为整数时，它将引发ArgumentError。defmy_method(number)
java - 等价于 Java 中的 Ruby Hash - 2
我真的很习惯使用Ruby编写以下代码:my_hash={}my_hash['test']=1Java中对应的数据结构是什么？最佳答案 HashMapmap=newHashMap();map.put("test",1);我假设？关于java-等价于Java中的RubyHash，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.com/questions/22737685/
ruby-on-rails - 在默认方法参数中使用 .reverse_merge 或 .merge - 2
两者都可以defsetup(options={})options.reverse_merge:size=>25,:velocity=>10end和defsetup(options={}){:size=>25,:velocity=>10}.merge(options)end在方法的参数中分配默认值。问题是:哪个更好？您更愿意使用哪一个？在性能、代码可读性或其他方面有什么不同吗？编辑:我无意中添加了bang(!)...并不是要询问nobang方法与bang方法之间的区别最佳答案我倾向于使用reverse_merge方法:option
ruby - 定义方法参数的条件 - 2
我有一个只接受一个参数的方法:defmy_method(number)end如果使用number调用方法，我该如何引发错误？？通常，我如何定义方法参数的条件？比如我想在调用的时候报错:my_method(1) 最佳答案您可以添加guard在函数的开头，如果参数无效则引发异常。例如:defmy_method(number)failArgumentError,"Inputshouldbegreaterthanorequalto2"ifnumbereputse.messageend#=>Inputshouldbegreaterthano
ruby - Ruby 有 `Pair` 数据类型吗？ - 2
有时我需要处理键/值数据。我不喜欢使用数组，因为它们在大小上没有限制(很容易不小心添加超过2个项目，而且您最终需要稍后验证大小)。此外，0和1的索引变成了魔数(MagicNumber)，并且在传达含义方面做得很差(“当我说0时，我的意思是head...”)。散列也不合适，因为可能会不小心添加额外的条目。我写了下面的类来解决这个问题:classPairattr_accessor:head,:taildefinitialize(h,t)@head,@tail=h,tendend它工作得很好并且解决了问题，但我很想知道:Ruby标准库是否已经带有这样一个类？最佳