S10L05 - 参数类型

html

精通Java中的Generics：初学者和开发人员的综合指南
目录

介绍..................................................................................................................1
理解Java中的Generics..................................................................3
常见的Generics表示法...................................................................................5
创建Generic数据类..........................................................................7
使用Generics的键值对........................................................9
实现构造函数和Getters................................................11
重写toString方法.......................................................................13
初始化和使用Generic类................................................15
探索Generic方法................................................................................17
使用Generics的最佳实践................................................................19
结论................................................................................................................21


介绍
Generics是Java中的一个强大特性，使开发人员能够创建具有类型参数的类、接口和方法。这一功能不仅促进了代码的可重用性，还确保了类型安全，减少了运行时错误。在本电子书中，我们将深入探索Generics的世界，探讨其语法、常见表示法和实际应用。无论您是初学者还是具有基本知识的开发人员，本指南将为您提供掌握Java Generics全部潜力的必要工具。

理解Java中的Generics
Generics是在Java 5中引入的，旨在提供一种参数化类型的方式。通过允许类和方法在操作各种类型的对象时提供编译时的类型安全，Generics消除了类型转换的需要并提高了代码的清晰度。
为什么使用Generics？

类型安全：在编译时捕捉与类型相关的错误，而不是在运行时。
可重用性：编写一个Generic类或方法一次，并与不同类型一起使用它。
消除类型转换：减少显式类型转换的需要，使代码更简洁且不易出错。

示例
考虑一个简单的容器类，它保存一个单一对象。没有Generics，您需要使用Object并执行类型转换：




		
		
			
			
Java
			
			class Container {
    private Object obj;

    public Container(Object obj) {
        this.obj = obj;
    }

    public Object getObj() {
        return obj;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						class Container {
    private Object obj;
 
    public Container(Object obj) {
        this.obj = obj;
    }
 
    public Object getObj() {
        return obj;
    }
}
					
				
			
		


使用Generics，Container类可以参数化以保存任何特定类型：




		
		
			
			
Java
			
			class Container&lt;T&gt; {
    private T obj;

    public Container(T obj) {
        this.obj = obj;
    }

    public T getObj() {
        return obj;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						class Container&lt;T&gt; {
    private T obj;
 
    public Container(T obj) {
        this.obj = obj;
    }
 
    public T getObj() {
        return obj;
    }
}
					
				
			
		



常见的Generics表示法
Java Generics使用特定的单字母表示法作为类型的占位符。理解这些表示法对于编写清晰和符合惯例的Generic代码至关重要。


表示法
代表
使用场景


T
Type
表示一个Generic类型


E
Element
Java Collections API广泛使用


K
Key
表示键值对中的键


V
Value
表示键值对中的值


N
Number
表示数值类型


详细解释

T (Type)：最常用的Generic类型参数。表示任何类型。





		
		
			
			
Java
			
			class Box&lt;T&gt; { 
    private T t; 
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}
			
				
					
				
					1
2
3
4
5
				
						class Box&lt;T&gt; { 
    private T t; 
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}
					
				
			
		



E (Element)：通常由集合类使用，用于表示存储在集合中的元素。





		
		
			
			
Java
			
			class MyList&lt;E&gt; { 
    // 实现细节
}
			
				
					
				
					1
2
3
				
						class MyList&lt;E&gt; { 
    // 实现细节
}
					
				
			
		



K, V (Key, Value)：用于映射或任何键值对集合中。





		
		
			
			
Java
			
			class Pair&lt;K, V&gt; { 
    private K key; 
    private V value; 
    // 构造函数, getters, setters
}
			
				
					
				
					1
2
3
4
5
				
						class Pair&lt;K, V&gt; { 
    private K key; 
    private V value; 
    // 构造函数, getters, setters
}
					
				
			
		



N (Number)：表示数值类型，适用于执行数值操作的方法。





		
		
			
			
Java
			
			public &lt;N extends Number&gt; void process(N number) { 
    // 实现
}
			
				
					
				
					1
2
3
				
						public &lt;N extends Number&gt; void process(N number) { 
    // 实现
}
					
				
			
		



创建Generic数据类
创建Generic数据类允许您定义能够灵活处理各种数据类型的结构。以下，我们通过使用键值对的方式创建一个Generic Data类。
逐步指南
1. 使用类型参数定义类




		
		
			
			
Java
			
			public class Data&lt;K, V&gt; {
    private K key;
    private V value;

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

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						public class Data&lt;K, V&gt; {
    private K key;
    private V value;
 
    public Data(K key, V value) {
        this.key = key;
        this.value = value;
    }
 
    public K getKey() {
        return key;
    }
 
    public V getValue() {
        return value;
    }
 
    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
					
				
			
		


解释：

K 和 V 是类型参数，分别代表键和值的类型。
构造函数初始化键和值。
Getters提供对字段的访问。
toString 方法被重写，以提供有意义的字符串表示。

2. 使用Generic数据类




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data);
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data);
    }
}
					
				
			
		


输出：




		
		
			
			
Java
			
			Key: 10, Value: Chand
			
				
					
				
					1
				
						Key: 10, Value: Chand
					
				
			
		


解释：

创建了一个Data的实例，Integer作为键类型，String作为值类型。
toString 方法提供了可读的输出。


使用Generics的键值对
键值对在许多数据结构中是基础，如映射。Generics增强了它们的灵活性和类型安全。
创建键值对类




		
		
			
			
Java
			
			public class KeyValuePair&lt;K, V&gt; {
    private K key;
    private V value;

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

    public K getKey() { 
        return key; 
    }

    public V getValue() { 
        return value; 
    }

    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						public class KeyValuePair&lt;K, V&gt; {
    private K key;
    private V value;
 
    public KeyValuePair(K key, V value) {
        this.key = key;
        this.value = value;
    }
 
    public K getKey() { 
        return key; 
    }
 
    public V getValue() { 
        return value; 
    }
 
    @Override
    public String toString() {
        return "Key: " + key + ", Value: " + value;
    }
}
					
				
			
		


使用KeyValuePair类




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        KeyValuePair&lt;Integer, String&gt; pair = new KeyValuePair<>(10, "Chand");
        System.out.println(pair);
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        KeyValuePair&lt;Integer, String&gt; pair = new KeyValuePair<>(10, "Chand");
        System.out.println(pair);
    }
}
					
				
			
		


输出：




		
		
			
			
Java
			
			Key: 10, Value: Chand
			
				
					
				
					1
				
						Key: 10, Value: Chand
					
				
			
		


解释：

KeyValuePair 类被实例化为特定类型，确保键是 Integer，值是 String。
这种方法防止了类型不匹配，增强了代码的可读性。


实现构造函数和Getters
构造函数和Getters是任何类的基本组件，特别是Generic类。它们确保对象被正确初始化并且其数据可访问。
生成构造函数
在Data类的示例中，构造函数初始化键和值：




		
		
			
			
Java
			
			public Data(K key, V value) {
    this.key = key;
    this.value = value;
}
			
				
					
				
					1
2
3
4
				
						public Data(K key, V value) {
    this.key = key;
    this.value = value;
}
					
				
			
		


解释：

构造函数接受 K 和 V 类型的参数，并将它们赋值给类的字段。

创建Getters
Getters提供对类字段的读取访问：




		
		
			
			
Java
			
			public K getKey() { 
    return key; 
}

public V getValue() { 
    return value; 
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public K getKey() { 
    return key; 
}
 
public V getValue() { 
    return value; 
}
					
				
			
		


解释：

getKey() 返回类型为 K 的键。
getValue() 返回类型为 V 的值。


重写toString方法
toString 方法被重写，以提供对象的有意义的字符串表示，这在调试和日志记录中特别有用。
在Data类中的实现




		
		
			
			
Java
			
			@Override
public String toString() {
    return "Key: " + key + ", Value: " + value;
}
			
				
					
				
					1
2
3
4
				
						@Override
public String toString() {
    return "Key: " + key + ", Value: " + value;
}
					
				
			
		


解释：

此方法将键和值连接成一个可读的格式。

使用toString方法




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data.toString());
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
        System.out.println(data.toString());
    }
}
					
				
			
		


输出：




		
		
			
			
Java
			
			Key: 10, Value: Chand
			
				
					
				
					1
				
						Key: 10, Value: Chand
					
				
			
		



初始化和使用Generic类
正确初始化Generic类涉及明确指定类型参数或通过类型推断。
显式类型指定




		
		
			
			
Java
			
			Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
			
				
					
				
					1
				
						Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
					
				
			
		


解释：

Integer 被指定为键，String 为值。
通过限制键和值的类型，确保了类型安全。

使用钻石操作符进行类型推断
钻石操作符（<>）在Java 7中引入，允许编译器推断类型参数：




		
		
			
			
Java
			
			Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
			
				
					
				
					1
				
						Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
					
				
			
		


解释：

编译器推断10是 Integer 类型，"Chand" 是 String 类型，消除了在右侧重复类型参数的需要。


探索Generic方法
Generic方法是引入其自身类型参数的方法，允许更灵活和可重用的代码。
定义Generic方法




		
		
			
			
Java
			
			public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
			
				
					
				
					1
2
3
				
						public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
					
				
			
		


解释：

<E, N> 声明了两个类型参数：E 和 N。
方法 display 可以接受任何类型的 element 和 number 参数。

使用Generic方法




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.display("Test", 40);
    }

    public &lt;E, N&gt; void display(E element, N number) {
        System.out.println("Element: " + element + ", Number: " + number);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.display("Test", 40);
    }
 
    public &lt;E, N&gt; void display(E element, N number) {
        System.out.println("Element: " + element + ", Number: " + number);
    }
}
					
				
			
		


输出：




		
		
			
			
Java
			
			Element: Test, Number: 40
			
				
					
				
					1
				
						Element: Test, Number: 40
					
				
			
		


解释：

display 方法被调用时传入了 String 和 Integer，展示了其灵活性。

为Generic方法添加注释




		
		
			
			
Java
			
			/**
 * 显示元素和数字。
 *
 * @param element 任意类型的元素。
 * @param number  任意类型的数字。
 */
public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						/**
 * 显示元素和数字。
 *
 * @param element 任意类型的元素。
 * @param number  任意类型的数字。
 */
public &lt;E, N&gt; void display(E element, N number) {
    System.out.println("Element: " + element + ", Number: " + number);
}
					
				
			
		


解释：

Javadoc注释增强了代码的可读性，并为方法的用途和参数提供了文档。


使用Generics的最佳实践
为了有效利用Java中的Generics，请遵循以下最佳实践：
1. 使用有意义的类型参数名称
虽然像 T 和 E 这样的单字母表示法很常见，但使用更具描述性的名称可以增强代码的可读性。




		
		
			
			
Java
			
			// 不太具描述性
class Box&lt;T&gt; { /* ... */ }

// 更具描述性
class Box&lt;ItemType&gt; { /* ... */ }
			
				
					
				
					1
2
3
4
5
				
						// 不太具描述性
class Box&lt;T&gt; { /* ... */ }
 
// 更具描述性
class Box&lt;ItemType&gt; { /* ... */ }
					
				
			
		


2. 限制通配符的使用
过度使用通配符（?）会使代码难以理解。谨慎使用，必要时优先考虑有边界的类型参数。




		
		
			
			
Java
			
			public void processList(List&lt;? extends Number&gt; numbers) {
    // 实现
}
			
				
					
				
					1
2
3
				
						public void processList(List&lt;? extends Number&gt; numbers) {
    // 实现
}
					
				
			
		


3. 偏爱组合而非继承
在设计Generic类时，偏爱组合而非继承，以保持灵活性并减少耦合。
4. 避免使用基本类型参数
Generics仅适用于引用类型。在处理基本类型时，使用包装类（Integer 代替 int）。




		
		
			
			
Java
			
			// 正确
Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");

// 不正确
Data&lt;int, String&gt; data = new Data<>(10, "Chand"); // 编译错误
			
				
					
				
					1
2
3
4
5
				
						// 正确
Data&lt;Integer, String&gt; data = new Data<>(10, "Chand");
 
// 不正确
Data&lt;int, String&gt; data = new Data<>(10, "Chand"); // 编译错误
					
				
			
		


5. 保持Generic类型的一致性
确保类型参数在方法和类中一致使用，以保持类型安全。




		
		
			
			
Java
			
			public class Pair&lt;K, V&gt; {
    // 一致使用 K 和 V
}
			
				
					
				
					1
2
3
				
						public class Pair&lt;K, V&gt; {
    // 一致使用 K 和 V
}
					
				
			
		


6. 为Generic类和方法添加文档
为Generic类和方法提供清晰的文档，以解释类型参数的用途。

结论
Generics是Java编程中不可或缺的工具，提供了增强的类型安全性、可重用性和更清晰的代码。通过理解和有效地实现Generics，开发人员可以创建灵活且健壮的应用程序。本指南涵盖了Generics的基础知识，包括常见的表示法、Generic类、方法和最佳实践。随着您对Java深入学习，利用Generics无疑将有助于编写高效且可维护的代码。
注意：本文由AI生成。
表示法	代表	使用场景
T	Type	表示一个Generic类型
E	Element	Java Collections API广泛使用
K	Key	表示键值对中的键
V	Value	表示键值对中的值
N	Number	表示数值类型