S10L07 - 有界类型参数

html

掌握Java Generics中的Bounded Type Parameters
目录

介绍 — 第1页
Understanding Java Generics — 第3页
Bounded Type Parameters Explained — 第6页
使用 Wrapper Classes for Boundaries — 第10页
Implementing Bounded Type Parameters in Code — 第14页
Custom Classes 作为 Bounds — 第20页
最佳实践及使用案例 — 第25页
结论 — 第30页

---
介绍
Java Generics已经彻底改变了开发人员编写代码的方式，使得在无需显式类型转换的情况下能够进行类型安全的操作。Java Generics中的一个关键概念是bounded type parameters。本电子书深入探讨了 bounded type parameters，阐明了它们的重要性、实现及实际应用。
涵盖的关键点:

Java Generics概述
bounded type parameters的详细解释
利用 wrapper classes 强制类型边界
使用代码实例实现 bounded type parameters
为专业界限定制 custom classes
最佳实践及实际应用案例

无论您是希望掌握基础知识的初学者，还是旨在完善理解的开发人员，本指南都为您提供了有关Java中 bounded type parameters 的全面见解。
---
理解 Java Generics
Java Generics，Java 5中引入的，允许开发人员创建带有 type parameters 的类、接口和方法。此功能通过允许对各种类型的对象进行操作而不影响性能或可靠性，增强了代码的可重用性和类型安全性。
使用 Generics 的优点

类型安全: 确保与类型不匹配相关的代码错误在编译时而不是运行时被捕获。
消除类型转换: 减少显式类型转换的需求，使代码更简洁、错误更少。
代码重用性: 促进编写可以与任何对象类型一起使用的泛型算法。

常见的 Generic Constructs

Type Parameters: 由单个大写字母表示（例如，T表示 Type，E表示 Element）。
Parameterized Types: 接受 type parameters 的类型（例如，List<T>）。
Generic Methods: 引入自身 type parameters 的方法。





		
		
			
			
Java
			
			public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						public class Box<T> {
    private T content;
 
    public void setContent(T content) {
        this.content = content;
    }
 
    public T getContent() {
        return content;
    }
}
					
				
			
		


在上面的示例中，Box 类使用 type parameter T，允许它存储任何类型的对象。
---
Bounded Type Parameters Explained
Bounded type parameters 限制了可以作为 type parameters 参数的类型。这增加了控制层，确保只允许特定类型或其子类，增强了类型安全性并防止运行时错误。
为何使用 Bounded Type Parameters?

强制类型约束: 确保只使用兼容类型，维护操作的完整性。
利用多态: 允许泛型类型使用其 bounded types 的方法和属性。
防止无效操作: 限制类型为支持必要操作的类型，避免潜在的运行时问题。

Bounded Type Parameters 的语法
定义 bounded type parameters 主要有两种方式：

Upper Bounded Wildcards: 使用 extends 关键字将类型限制为特定类型或其子类。

    



		
		
			
			
Java
			
			public &lt;T extends Number&gt; void process(T number) {
    // Implementation
}
			
				
					
				
					1
2
3
				
						public &lt;T extends Number&gt; void process(T number) {
    // Implementation
}
					
				
			
		


    在此示例中，T 可以是 Number 的任何子类（例如，Integer、Double）。
  
Lower Bounded Wildcards: 使用 super 关键字将类型限制为特定类型或其超类。




		
		
			
			
Java
			
			public void addNumbers(List&lt;? super Integer&gt; list) {
    // Implementation
}
			
				
					
				
					1
2
3
				
						public void addNumbers(List&lt;? super Integer&gt; list) {
    // Implementation
}
					
				
			
		


    这里，list 可以接受 Integer 或其任何超类。
  

实际例子
考虑一个处理数值数据的方法。通过将 type parameter 限定为扩展 Number，我们确保该方法只能在数值类型上操作，利用 Number 类提供的 doubleValue() 等方法。




		
		
			
			
Java
			
			public &lt;T extends Number&gt; double calculateAverage(T[] numbers) {
    double sum = 0.0;
    for (T number : numbers) {
        sum += number.doubleValue();
    }
    return sum / numbers.length;
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public &lt;T extends Number&gt; double calculateAverage(T[] numbers) {
    double sum = 0.0;
    for (T number : numbers) {
        sum += number.doubleValue();
    }
    return sum / numbers.length;
}
					
				
			
		


此方法安全地计算数字数组的平均值，无论它们是 Integer、Double 还是任何其他 Number 的子类。
---
使用 Wrapper Classes for Boundaries
Java中的 Wrapper Classes 封装了基本类型，提供了一种将基本值用作对象的方法。它们在泛型中起着关键作用，尤其是在定义 bounded type parameters 时。
Java中常见的 Wrapper Classes


基本类型
Wrapper Class


byte
Byte


short
Short


int
Integer


long
Long


float
Float


double
Double


char
Character


boolean
Boolean


使用 Wrapper Classes 来实现 Bounds
通过利用 Wrapper Classes，开发人员可以在泛型方法和类中强制类型约束。例如，为确保泛型类型只接受数值，可以使用 Number Wrapper Class 来限定。




		
		
			
			
Java
			
			public class Data&lt;T extends Number&gt; {
    private T number;

    public Data(T number) {
        this.number = number;
    }

    public void display() {
        System.out.println("Number: " + number);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						public class Data&lt;T extends Number&gt; {
    private T number;
 
    public Data(T number) {
        this.number = number;
    }
 
    public void display() {
        System.out.println("Number: " + number);
    }
}
					
				
			
		


使用 Wrapper Classes 的优势

增强的功能性: Wrapper Classes 提供了用于转换和操作基本值的方法。
类型兼容性: 它们促进了在集合和泛型类型中使用基本类型。
不可变性: Wrapper 对象是不可变的，确保了线程安全性和一致性。

示例场景
考虑一种情境，您想创建一个处理数值操作的泛型类。通过使用 Number 限定 type parameter，您确保只处理数值类型，防止在非数值类型上执行无效操作。




		
		
			
			
Java
			
			public class Calculator&lt;T extends Number&gt; {
    private T value;

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

    public double square() {
        return value.doubleValue() * value.doubleValue();
    }

    public void display() {
        System.out.println("Value: " + value + ", Square: " + square());
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						public class Calculator&lt;T extends Number&gt; {
    private T value;
 
    public Calculator(T value) {
        this.value = value;
    }
 
    public double square() {
        return value.doubleValue() * value.doubleValue();
    }
 
    public void display() {
        System.out.println("Value: " + value + ", Square: " + square());
    }
}
					
				
			
		


在此示例中，尝试使用非数值类型如 String 来实例化 Calculator 将导致编译时错误，以促进类型安全。
---
在代码中实现 Bounded Type Parameters
要有效地在 Java Generics 中使用 bounded type parameters，了解它们的实现及相关细节至关重要。本节提供了实现 bounded type parameters 的逐步指南，配有代码示例和解释。
步骤 1: 定义 Generic Class 或 Method
首先，声明一个具有适当 type parameter bounds 的泛型类或方法。




		
		
			
			
Java
			
			public class Repository&lt;T extends Number&gt; {
    private T id;

    public Repository(T id) {
        this.id = id;
    }

    public T getId() {
        return id;
    }

    public void display() {
        System.out.println("Repository ID: " + id);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						public class Repository&lt;T extends Number&gt; {
    private T id;
 
    public Repository(T id) {
        this.id = id;
    }
 
    public T getId() {
        return id;
    }
 
    public void display() {
        System.out.println("Repository ID: " + id);
    }
}
					
				
			
		


在此示例中，Repository 类是泛型的，具有 bounded type parameter T，限定为 Number。这确保只有数值类型可以用来实例化 Repository。
步骤 2: 实现 Class
实现类的方法，利用 bounded type parameters 执行特定类型的操作。




		
		
			
			
Java
			
			public class Repository&lt;T extends Number&gt; {
    private T id;

    public Repository(T id) {
        this.id = id;
    }

    public T getId() {
        return id;
    }

    public void display() {
        System.out.println("Repository ID: " + id);
        System.out.println("ID as Double: " + id.doubleValue());
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						public class Repository&lt;T extends Number&gt; {
    private T id;
 
    public Repository(T id) {
        this.id = id;
    }
 
    public T getId() {
        return id;
    }
 
    public void display() {
        System.out.println("Repository ID: " + id);
        System.out.println("ID as Double: " + id.doubleValue());
    }
}
					
				
			
		


在这里，display 方法利用了 Number 类的 doubleValue() 方法，这是由于 bounded type parameter 的存在而可访问的。
步骤 3: 使用 Generic Class
使用不同的数值类型实例化泛型类，以观察强制的类型约束。




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Repository&lt;Integer&gt; intRepo = new Repository<>(101);
        intRepo.display();

        Repository&lt;Double&gt; doubleRepo = new Repository<>(202.5);
        doubleRepo.display();

        // The following line will cause a compile-time error
        // Repository&lt;String&gt; stringRepo = new Repository<>("303"); // Invalid
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						public class Main {
    public static void main(String[] args) {
        Repository&lt;Integer&gt; intRepo = new Repository<>(101);
        intRepo.display();
 
        Repository&lt;Double&gt; doubleRepo = new Repository<>(202.5);
        doubleRepo.display();
 
        // The following line will cause a compile-time error
        // Repository&lt;String&gt; stringRepo = new Repository<>("303"); // Invalid
    }
}
					
				
			
		


输出:




		
		
			
			
Java
			
			Repository ID: 101
ID as Double: 101.0
Repository ID: 202.5
ID as Double: 202.5
			
				
					
				
					1
2
3
4
				
						Repository ID: 101
ID as Double: 101.0
Repository ID: 202.5
ID as Double: 202.5
					
				
			
		


尝试使用 String 类型实例化 Repository 将导致编译时错误，展示了 bounded type parameters 在强制类型安全方面的有效性。
步骤 4: 处理多个 Bounds
Java 允许使用 & 符号来指定多个 bounds。例如，如果您希望 type parameter 同时扩展特定的类并实现某些接口，您可以定义多个 bounds。




		
		
			
			
Java
			
			public class AdvancedRepository&lt;T extends Number &amp; Comparable&lt;T&gt;&gt; {
    private T id;

    public AdvancedRepository(T id) {
        this.id = id;
    }

    public void compare(T otherId) {
        int comparison = id.compareTo(otherId);
        if (comparison &gt; 0) {
            System.out.println(id + " is greater than " + otherId);
        } else if (comparison &lt; 0) {
            System.out.println(id + " is less than " + otherId);
        } else {
            System.out.println(id + " is equal to " + otherId);
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						public class AdvancedRepository&lt;T extends Number &amp; Comparable&lt;T&gt;&gt; {
    private T id;
 
    public AdvancedRepository(T id) {
        this.id = id;
    }
 
    public void compare(T otherId) {
        int comparison = id.compareTo(otherId);
        if (comparison &gt; 0) {
            System.out.println(id + " is greater than " + otherId);
        } else if (comparison &lt; 0) {
            System.out.println(id + " is less than " + otherId);
        } else {
            System.out.println(id + " is equal to " + otherId);
        }
    }
}
					
				
			
		


这个 AdvancedRepository 类确保 type parameter T 不仅是 Number 的子类，同时也实现了 Comparable 接口，支持比较操作。
---
Custom Classes as Bounds
虽然 Java 为基本类型提供了大量的 Wrapper Classes，但也有一些情境中 Custom Classes 作为 type parameters 的 bounds。这允许开发人员强制实现标准类所不提供的特定行为或属性。
为 Bounding 创建 Custom Class
假设您有一个带有特定属性和方法的 Custom Class Person。您可能希望确保只有扩展 Person 的类才能与某些泛型类或方法一起使用。




		
		
			
			
Java
			
			public class Person implements Comparable&lt;Person&gt; {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Getters and Setters

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						public class Person implements Comparable&lt;Person&gt; {
    private String name;
    private int age;
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Getters and Setters
 
    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }
}
					
				
			
		


在 Generics 中使用 Custom Classes 作为 Bounds
随着 Person 类实现 Comparable，您现在可以将其用作泛型类或方法中的 bound。




		
		
			
			
Java
			
			public class PersonRepository&lt;T extends Person&gt; {
    private T person;

    public PersonRepository(T person) {
        this.person = person;
    }

    public void displayPerson() {
        System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());
    }

    public void compareAge(T otherPerson) {
        int comparison = person.compareTo(otherPerson);
        if (comparison &gt; 0) {
            System.out.println(person.getName() + " is older than " + otherPerson.getName());
        } else if (comparison &lt; 0) {
            System.out.println(person.getName() + " is younger than " + otherPerson.getName());
        } else {
            System.out.println(person.getName() + " is the same age as " + otherPerson.getName());
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						public class PersonRepository&lt;T extends Person&gt; {
    private T person;
 
    public PersonRepository(T person) {
        this.person = person;
    }
 
    public void displayPerson() {
        System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());
    }
 
    public void compareAge(T otherPerson) {
        int comparison = person.compareTo(otherPerson);
        if (comparison &gt; 0) {
            System.out.println(person.getName() + " is older than " + otherPerson.getName());
        } else if (comparison &lt; 0) {
            System.out.println(person.getName() + " is younger than " + otherPerson.getName());
        } else {
            System.out.println(person.getName() + " is the same age as " + otherPerson.getName());
        }
    }
}
					
				
			
		


实际例子
让我们用 Person 对象实例化 PersonRepository，并观察 bounded type parameters 的运作。




		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        Person john = new Person("John Doe", 30);
        Person jane = new Person("Jane Smith", 25);

        PersonRepository&lt;Person&gt; repo1 = new PersonRepository<>(john);
        repo1.displayPerson();
        repo1.compareAge(jane);

        // The following line will cause a compile-time error
        // PersonRepository&lt;String&gt; repo2 = new PersonRepository<>("Not a Person"); // Invalid
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						public class Main {
    public static void main(String[] args) {
        Person john = new Person("John Doe", 30);
        Person jane = new Person("Jane Smith", 25);
 
        PersonRepository&lt;Person&gt; repo1 = new PersonRepository<>(john);
        repo1.displayPerson();
        repo1.compareAge(jane);
 
        // The following line will cause a compile-time error
        // PersonRepository&lt;String&gt; repo2 = new PersonRepository<>("Not a Person"); // Invalid
    }
}
					
				
			
		


输出:




		
		
			
			
Java
			
			Name: John Doe, Age: 30
John Doe is older than Jane Smith
			
				
					
				
					1
2
				
						Name: John Doe, Age: 30
John Doe is older than Jane Smith
					
				
			
		


尝试使用不扩展 Person 的类型（例如 String）将导致编译时错误，确保仅使用有效类型。
使用 Custom Classes 作为 Bounds 的优势

增强类型安全性: 将泛型限制为特定类，防止了非预期的类型使用。
利用 Custom Behaviors: 允许在泛型操作中使用在 custom classes 中定义的方法和属性。
灵活性: 开发人员可以定义适用于特定应用需求的复杂边界。

---
最佳实践及使用案例
bounded type parameters 是 Java Generics 中的一个强大特性，但就像任何工具一样，适当使用时最为有效。本节概述了最佳实践并探讨了实际应用案例，以最大化 bounded type parameters 的优势。
最佳实践

使用上限 Bound 增加灵活性:

上限 bounds (extends) 通过允许指定类型的任何子类来提供灵活性。
示例: <T extends Number> 允许 Integer、Double 等。


限制 Bounds 的数量:

虽然 Java 允许多个 bounds，但建议限制它们以保持可读性并减少复杂性。
最好有一个类 bound 和多个接口 bound。

        



		
		
			
			
Java
			
			public class MultiBounded&lt;T extends Number &amp; Comparable&lt;T&gt; &amp; Serializable&gt; {
    // Implementation
}
			
				
					
				
					1
2
3
				
						public class MultiBounded&lt;T extends Number &amp; Comparable&lt;T&gt; &amp; Serializable&gt; {
    // Implementation
}
					
				
			
		


      


优先考虑组合而非继承:

与其在大量依赖继承来限制类型，不如考虑使用组合来增强灵活性和可维护性。


提供清晰的文档:

清晰地记录 bounded type parameters 的目的和约束，帮助其他开发人员理解并正确使用您的泛型类或方法。


避免过度使用通配符:

虽然通配符 (?) 有用，但过度使用可能会使代码难以阅读和维护。明智地使用 bounded type parameters，以在灵活性和可读性之间取得平衡。



实际应用案例

Data Access Objects (DAOs):

DAOs often interact with various entity types. Bounded type parameters 确保只处理有效的实体类型。

        



		
		
			
			
Java
			
			public interface DAO&lt;T extends BaseEntity&gt; {
    void save(T entity);
    T findById(int id);
    // Other CRUD operations
}
			
				
					
				
					1
2
3
4
5
				
						public interface DAO&lt;T extends BaseEntity&gt; {
    void save(T entity);
    T findById(int id);
    // Other CRUD operations
}
					
				
			
		


      


Generic Collections:

Collections like TreeSet 使用 bounded type parameters 确保元素可以被比较，保持顺序。

        



		
		
			
			
Java
			
			TreeSet&lt;T&gt; treeSet = new TreeSet&lt;&gt;();
			
				
					
				
					1
				
						TreeSet&lt;T&gt; treeSet = new TreeSet&lt;&gt;();
					
				
			
		



        这里，T 必须实现 Comparable<T>，确保元素可以排序。
      


Service Layers:

在面向服务的架构中，bounded type parameters 可以强制只实现特定的服务接口。

        



		
		
			
			
Java
			
			public class ServiceManager&lt;T extends ServiceInterface&gt; {
    private T service;

    public ServiceManager(T service) {
        this.service = service;
    }

    public void executeService() {
        service.performService();
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						public class ServiceManager&lt;T extends ServiceInterface&gt; {
    private T service;
 
    public ServiceManager(T service) {
        this.service = service;
    }
 
    public void executeService() {
        service.performService();
    }
}
					
				
			
		


      


Utility Libraries:

提供实用功能（例如排序、搜索）的库可以使用 bounded type parameters 在确保类型安全的同时操作广泛类型。

        



		
		
			
			
Java
			
			public class Utility {
    public static &lt;T extends Comparable&lt;T&gt;&gt; T findMax(T[] array) {
        T max = array[0];
        for (T item : array) {
            if (item.compareTo(max) &gt; 0) {
                max = item;
            }
        }
        return max;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						public class Utility {
    public static &lt;T extends Comparable&lt;T&gt;&gt; T findMax(T[] array) {
        T max = array[0];
        for (T item : array) {
            if (item.compareTo(max) &gt; 0) {
                max = item;
            }
        }
        return max;
    }
}
					
				
			
		


      


Builder Patterns:

在为对象构建实现 builder patterns 时，bounded type parameters 可以确保只构建具有特定属性的对象。

        



		
		
			
			
Java
			
			public class Builder&lt;T extends Product&gt; {
    private T product;

    public Builder(T product) {
        this.product = product;
    }

    public Builder&lt;T&gt; setName(String name) {
        product.setName(name);
        return this;
    }

    public T build() {
        return product;
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						public class Builder&lt;T extends Product&gt; {
    private T product;
 
    public Builder(T product) {
        this.product = product;
    }
 
    public Builder&lt;T&gt; setName(String name) {
        product.setName(name);
        return this;
    }
 
    public T build() {
        return product;
    }
}
					
				
			
		


      



常见的陷阱避免

过于严格的 Bounds: 设置 bounds 过于狭窄可能会限制泛型类或方法的可重用性。
忽视类型推断: Java 的类型推断能力可以简化泛型的使用。在不必要时避免显式指定 type parameters。
混合使用 Raw Types 与 Generics: 在使用泛型的同时使用 raw types 可能会导致未经检查的警告和潜在的运行时错误。

---
结论
bounded type parameters 是 Java Generics 的一个组成部分，提供了增强的类型安全性和灵活性。通过限制可用作参数的类型，开发人员可以创建稳健、可重用且易于维护的代码结构。无论是利用内置的 wrapper classes 还是创建 custom bounds，理解并有效地实现 bounded type parameters 都能使开发人员充分利用 Java 类型系统的潜力。
关键要点:

类型安全性: Bounded type parameters 防止了类型不匹配，确保只使用兼容的类型。
灵活性: 上限和下限 bounds 在保持类型约束控制的同时提供灵活性。
增强的功能性: 利用 bounded types 的方法（例如 Number 的 doubleValue()）丰富了泛型操作。
Custom Bounds: 创建 custom classes 作为 bounds 允许为应用需求量身定制特定的类型约束。
最佳实践: 遵循最佳实践确保泛型被有效使用，而不牺牲代码的可读性或可维护性。

在您的 Java 项目中采用 bounded type parameters，以编写更清晰、更安全和更高效的代码。
---
关键词: Java Generics, Bounded Type Parameters, Type Safety, Wrapper Classes, Generic Methods, Upper Bounded Wildcards, Lower Bounded Wildcards, Custom Classes, Java Programming, Type Constraints, Generic Classes, Java Development, Object-Oriented Programming, Code Reusability, Type Inference
注意: 本文由 AI 生成。
基本类型	Wrapper Class
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean