泛型的使用

最新推荐文章于 2024-09-08 10:40:56 发布

鼠鼠我呀2

最新推荐文章于 2024-09-08 10:40:56 发布

阅读量261

点赞数 1

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_44484668/article/details/132787321

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

I. 什么是泛型？

A. 泛型的定义

泛型（Generics）是一种允许你在编写类、接口和方法时使用类型参数的机制，以提高代码的灵活性和重用性。泛型允许你编写通用的代码，可以在不同的数据类型上工作，而无需为每种数据类型都编写单独的代码。

B. 泛型的优势

强类型化：泛型可以帮助程序员在编译时捕获类型错误，避免在运行时出现错误，提高了代码的可靠性和安全性。
代码重用：泛型可以应用于不同类型的数据结构和算法，提高了代码的重用性和可维护性。
性能优化：泛型可以产生更高效的代码，因为它可以避免因类型转换而引起的额外开销。
可读性：泛型可以使代码更加简洁、易读、易懂，使其更容易理解和维护。
适用于多种场景：泛型可以应用于多种场景，例如集合、算法、数据结构等，这使得它成为一种通用的解决方案，可以提高代码的可复用性和灵活性。

C. 泛型字母的含义

E (Element, 元素)
T (Type, Java类)
K (key, 键)
V (value, 值)
N (Number, 数值类型)

II. 泛型的基本使用

A. 泛型类

泛型类（Generic Class）是一种定义通用数据类型的类，可以在类定义时指定一种或多种类型参数（Type Parameters）。这些类型参数可以在类中作为一种占位符使用，然后在创建类的实例时通过传递实际类型参数（Type Arguments）来替换这些占位符。

泛型类的优点在于可以使用相同的代码来处理不同类型的数据，从而提高代码的复用性和可读性。常见的泛型类包括集合类、队列类、栈类等。

例如，下面是一个泛型类的示例代码：

public class MyGenericClass<T> {
    private T data;

    public MyGenericClass(T data) {
        this.data = data;
    }

    public T getData() {
        return this.data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

在这个示例中，我们定义了一个名为 MyGenericClass 的泛型类，它有一个类型参数 T。我们可以在创建 MyGenericClass 的实例时指定 T 的实际类型，例如：

MyGenericClass<String> stringObject = new MyGenericClass<>("Hello");
System.out.println(stringObject.getData());  // 输出 "Hello"

MyGenericClass<Integer> intObject = new MyGenericClass<>(123);
System.out.println(intObject.getData());     // 输出 123

这样，我们可以使用同一个 MyGenericClass 类来处理不同类型的数据，而不需要针对每种类型写不同的类。

B. 泛型方法

泛型方法是使用泛型类型的方法。它们允许在编写方法时指定一组类型参数，这些类型参数可以是任何类型，包括类、接口和其他泛型类型。泛型方法的一个主要优势是它们能够提供更强的类型安全性，因为编译器可以检查方法中使用的类型是否与指定的类型参数兼容。

泛型方法的语法很简单。在方法的返回类型之前添加一个类型参数列表，其中包含一个或多个类型参数，例如：

public <T> T genericMethod(T[] array) {
    // method implementation
}

在上面的示例中，类型参数列表 <T> 告诉编译器该方法是一个泛型方法，方法名后面的 <T> 指定该方法的返回类型是泛型类型 T，而参数列表中 T[] 则指定了一个类型为 T 的数组作为参数。

使用泛型方法时，可以将任何类型作为类型参数，例如：

String[] strArray = {"foo", "bar", "baz"};
Integer[] intArray = {1, 2, 3};
String str = genericMethod(strArray); // returns "foo"
Integer num = genericMethod(intArray); // returns 1

在这个例子中，genericMethod 方法使用了不同的类型参数，但它们都可以正常工作，并返回了正确的结果。

C. 泛型接口

泛型接口（Generic Interface）是一种接口，支持泛型类型参数。泛型接口与普通接口的区别在于，泛型接口可以在接口声明中指定一个或多个类型参数，这些类型参数可用于接口中的方法或属性定义中。泛型接口可以与泛型类一起使用，以提供类型安全性和代码重用性。

例如，以下是一个泛型接口的示例：

public interface List<T> {
    void add(T element);
    T get(int index);
}

在上面的示例中，List 接口中定义了一个类型参数 T，该参数可用于 add 和 get 方法中的参数和返回类型。

使用泛型接口的主要优点是，可以在编译时检查类型安全性，避免在运行时出现类型不匹配的异常。此外，泛型接口还可以提高代码的可读性和可维护性，因为方法和属性的含义更加清晰，使用者无需手动进行类型转换。

III. 泛型的类型限制

A. 通配符

泛型的通配符指的是Java中用于通配任意类型实参的特殊符号“?”。它可以用于泛型类、泛型方法和泛型接口等各种情况中，表示不确定的类型实参。通配符可以用于声明泛型变量、方法参数、返回值等，其作用是增强程序的灵活性和可复用性。通配符的使用方式有三种：无限制通配符“? ”、上限限定通配符“? extends T”和下限限定通配符“? super T”。

B. 上限限定

泛型的上限限定是指在泛型中使用通配符时，限制通配符所表示的泛型类型必须是某个特定类型或其子类型。例如，假设有一个泛型类Test<T>，要求泛型类型必须是Number或其子类，可以这样定义：Test<T extends Number>。这样一来，在使用Test类时，就只能传入Number或其子类作为类型参数，否则编译器会报错。

通过使用上限限定，可以提高程序的类型安全性，使得程序能够更好地遵循面向对象编程的原则。

C. 下限限定

泛型的下限限定是指在泛型中使用通配符时，限制通配符所表示的泛型类型必须是某个特定类型或其父类型。使用下限限定时，需要使用super关键字。例如，假设有一个泛型类Test<T>，要求泛型类型必须是Number的父类，可以这样定义：Test<T super Number>。这样一来，在使用Test类时，就只能传入Number的父类作为类型参数，否则编译器会报错。

通过使用下限限定，可以在一定程度上扩大泛型类型的范围，同时仍然保证了类型安全性。

VIII. 泛型应用实例

A. 数据结构的泛型应用

泛型在数据结构中的应用是很常见的。使用泛型可以使数据结构更具有灵活性和可扩展性，因为不同类型的数据都可以被存储在同一个数据结构中。以下是一些常见的数据结构的泛型应用实例：

数组

在Java中，数组可以使用泛型来声明不同类型的数组。例如，可以声明一个字符串类型的数组和一个整数类型的数组：

String[] stringArray = new String[10];
Integer[] intArray = new Integer[10];

列表

列表是一种常见的数据结构，可以使用泛型来创建不同类型的列表。例如，可以创建一个整型列表和一个字符串列表：

List<Integer> intList = new ArrayList<Integer>();
List<String> stringList = new ArrayList<String>();

队列

队列是另一种常见的数据结构，也可以使用泛型来创建多种类型的队列。例如，可以创建一个整数类型的队列和一个字符串类型的队列：

Queue<Integer> intQueue = new LinkedList<Integer>();
Queue<String> stringQueue = new LinkedList<String>();

栈是一种后进先出的数据结构，也可以使用泛型来存储不同类型的元素。例如，可以创建一个整数类型的栈和一个字符串类型的栈：

Stack<Integer> intStack = new Stack<Integer>();
Stack<String> stringStack = new Stack<String>();

除此之外，还有很多其他的数据结构，如Set、Map等也可以使用泛型来实现不同类型的存储。泛型的应用使得数据结构更具有通用性和灵活性，使得代码更加简单易读，提高代码的可维护性和可复用性。

B. 范型在网络编程中的应用

范型在网络编程中的应用十分广泛，例如在 Java 编程中，可以使用范型来定义网络请求的数据类型，如下所示：

public class HttpRequest<T> {
    private String url;
    private String method;
    private Map<String, String> headers;
    private T body;

    // getters and setters
}

上述代码中，HttpRequest 类中的 T 表示数据类型，在发送网络请求时可以根据需要指定具体的数据类型，例如发送一个 HttpRequest<String> 类型的请求，即表示请求返回的数据类型为字符串。

另外，在使用一些网络框架时，也常常会使用范型来定义网络请求的回调函数的参数类型，例如在 Retrofit 中，可以定义一个范型接口来表示网络请求的回调：

public interface Callback<T> {
    void onResponse(Call<T> call, Response<T> response);
    void onFailure(Call<T> call, Throwable t);
}

上述代码中，Callback 接口中的 T 表示网络请求返回的数据类型，当网络请求完成后，会调用 onResponse 方法或者 onFailure 方法，并传入相应的参数类型。

总之，范型在网络编程中可以有效地提高代码的复用和类型安全性，使得代码更加健壮和可维护。

C. 范型在数据库中的应用

在数据库中，我们经常需要存储和检索各种类型的数据。使用泛型，可以使数据库更加通用和易于使用。

例如，我们可以使用Java的泛型类库来实现一个通用的数据库访问类：

public class DatabaseAccess<T> { 
    public void save(T data) { 
        // save the data to the database 
    } 
  
    public T load(int id) { 
        // load data with the specified ID from the database 
        return null; // return the data 
    } 
  
    public void delete(int id) { 
        // delete the data with the specified ID from the database 
    } 
}

在这个例子中，我们使用泛型类型T来表示要保存、加载和删除的数据类型。然后我们可以使用这个通用的数据库访问类来处理任何类型的数据。

IX. 泛型在各种框架中的应用

A. Spring框架的泛型应用

Spring框架中广泛应用了泛型，特别是在依赖注入和AOP方面。

依赖注入

Spring框架使用泛型来实现依赖注入。依赖注入是将对象的创建和执行分离的一种方式，通过控制反转（IoC）将对象的创建和执行分离，使代码更加易于测试和维护。Spring框架在执行依赖注入时使用泛型来确定注入的对象的类型，例如：

public class UserServiceImpl implements UserService<User> {
     @Autowired
     private UserDao<User> userDao;
     // ...
}

在这个例子中，泛型 User 用于告诉Spring框架要注入的对象是 UserDao<User>。

Spring AOP（面向切面编程）是Spring框架的另一个关键特性，可以使开发人员在应用程序中注入代码以实现跨越应用程序的横切关注点，例如处理日志、异常、性能和安全问题等。Spring AOP使用泛型来代表切点和通知的类型，例如：

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.UserService.*(..))")
    public void logBefore(JoinPoint joinPoint) {
        // ...
    }
}

在这个例子中，泛型 * 被用来表示要切入的方法的参数类型和返回类型，这使得通知可以适用于任何参数和返回类型的方法。

B. Hibernate框架的泛型应用

Hibernate框架是一个ORM（对象关系映射）框架，使用泛型来实现类型安全的查询和结果集映射。在Hibernate中，泛型类型参数是实体类的类型，例如：

public class UserDaoImpl<T> implements BaseDao<T> {
    private final Class<T> persistentClass;
    public UserDaoImpl(Class<T> persistentClass) {
        this.persistentClass = persistentClass;
    }
    // ...
    public T getById(Long id) {
        return getSession().get(persistentClass, id);
    }
}

在这个例子中，泛型类型 T 用于表示实体类的类型，使得 getById 方法可以返回一个类型为 T 的实体对象。

C. MyBatis框架的泛型应用

MyBatis框架是一个轻量级的ORM框架，在MyBatis中，泛型用于指定查询的返回类型和方法的参数类型。例如：

public interface BaseDao<T> {
    T getById(Long id);
    List<T> getAll();
    void save(T entity);
    void update(T entity);
    void delete(Long id);
}

在这个例子中，泛型 T 用于表示实体类的类型，使得BaseDao接口中的方法可以返回类型为 T 的实体对象或列表，并且方法参数也可以是类型为 T 的实体对象。