泛型是一种编程语言特性，它允许您在定义类、接口、方法或函数时指定类型参数

泛型是一种编程语言特性，它允许您在定义类、接口、方法或函数时指定类型参数。这样，您可以编写更灵活、更可重用的代码。以下是一些使用泛型的常见案例：

1. **集合类**：
   使用泛型可以定义一个通用的集合类，比如列表、队列、堆栈等，这些集合可以存储任何类型的数据。

   ```java
   public class List<T> {
       private T[] array;
       private int size = 0;
       private static final int DEFAULT_CAPACITY = 10;

       public void add(T item) {
           if (array == null) {
               array = (T[]) new Object[DEFAULT_CAPACITY];
           }
           if (size == array.length) {
               array = Arrays.copyOf(array, 2 * size + 1);
           }
           array[size++] = item;
       }

       public T get(int index) {
           return array[index];
       }

       public int size() {
           return size;
       }
   }
   ```

2. **函数式接口**：
   泛型可以用于定义函数式接口，使得接口的实现可以传递不同类型的参数。

   ```java
   @FunctionalInterface
   public interface Function<T, R> {
       R apply(T t);
   }

   public class Main {
       public static void main(String[] args) {
           Function<String, Integer> toInteger = String::length;
           System.out.println(toInteger.apply("Hello")); // 输出 5
       }
   }
   ```

3. **泛型方法**：
   在Java中，你可以定义泛型方法，这些方法可以接收不同类型的参数并返回不同类型的结果。

   ```java
   public class Utils {
       public static <T extends Comparable<T>> int compare(T a, T b) {
           return a.compareTo(b);
       }

       public static void main(String[] args) {
           int result = compare(10, 20);
           System.out.println(result); // 输出 -1
       }
   }
   ```

4. **泛型类**：
   定义一个泛型类，使得类的实例可以处理不同类型的数据。

   ```java
   public class Box<T> {
       private T t;

       public void set(T t) { this.t = t; }
       public T get() { return t; }
   }

   public class Main {
       public static void main(String[] args) {
           Box<String> stringBox = new Box<>();
           stringBox.set("Hello");
           System.out.println(stringBox.get()); // 输出 Hello

           Box<Integer> intBox = new Box<>();
           intBox.set(123);
           System.out.println(intBox.get()); // 输出 123
       }
   }
   ```

5. **类型安全的数组**：
   使用泛型可以创建类型安全的数组。

   ```java
   public class Array<T> {
       private T[] array;

       public Array(int size) {
           array = (T[]) new Object[size];
       }

       public void set(int index, T value) {
           array[index] = value;
       }

       public T get(int index) {
           return array[index];
       }
   }
   ```

6. **限制泛型类型**：
   可以使用类型限制来限制泛型参数的类型。

   ```java
   public class NumberBox<T extends Number> {
       private T number;

       public void setNumber(T number) {
           this.number = number;
       }

       public T getNumber() {
           return number;
       }
   }

   public class Main {
       public static void main(String[] args) {
           NumberBox<Integer> intBox = new NumberBox<>();
           intBox.setNumber(123);
           System.out.println(intBox.getNumber()); // 输出 123
       }
   }
   ```

这些案例展示了泛型在不同场景下的应用，使得代码更加灵活和可重用。