Java泛型详解

简介: Java泛型详解

Java泛型详解

 

Java泛型(Generics)是一种强大的编程工具,使得代码可以在编译时进行类型检查,并提供更高的代码重用性和安全性。泛型允许定义类、接口和方法时,可以对其操作的数据类型进行参数化,从而使得这些类、接口和方法能适用于多种数据类型。

 

为什么使用泛型?

 

1. **类型安全**:在编译时检测类型错误,减少运行时异常。

2. **代码重用**:编写一次代码,可以应用于多种数据类型。

3. **可读性和可维护性**:通过泛型,可以明确表达意图,使代码更易理解和维护。

 

泛型语法

 

泛型使用尖括号 `<>` 来定义类型参数,例如 `List<T>` 中的 `T`。

 

泛型类

 

一个泛型类是带有一个或多个类型参数的类。例如:

 

```java
public class Box<T> {
    private T t;
 
    public void set(T t) {
        this.t = t;
    }
 
    public T get() {
        return this.t;
    }
}
```

 

可以像这样使用这个泛型类:

 

```java
public class Main {
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>();
        integerBox.set(10);
        System.out.println("Integer Value: " + integerBox.get());
 
        Box<String> stringBox = new Box<>();
        stringBox.set("Hello");
        System.out.println("String Value: " + stringBox.get());
    }
}
```

 

泛型方法

 

泛型方法是在声明方法时引入一个或多个类型参数。这些类型参数放置在方法的返回类型之前。例如:

 

```java
public class GenericMethodExample {
 
    // 泛型方法 printArray
    public static <E> void printArray(E[] inputArray) {
        for (E element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }
 
    public static void main(String[] args) {
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4, 5.5 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.print("Array of Integers: ");
        printArray(intArray);
 
        System.out.print("Array of Doubles: ");
        printArray(doubleArray);
 
        System.out.print("Array of Characters: ");
        printArray(charArray);
    }
}
```

 

泛型接口

 

泛型也可以应用于接口。例如:

 

```java
public interface Pair<K, V> {
    public K getKey();
    public V getValue();
}
 
public class OrderedPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;
 
    public OrderedPair(K key, V value) {
        this.key = key;
        this.value = value;
    }
 
    public K getKey() { return key; }
    public V getValue() { return value; }
}
 
public class Main {
    public static void main(String[] args) {
        Pair<String, Integer> pair = new OrderedPair<>("One", 1);
        System.out.println("Key: " + pair.getKey() + ", Value: " + pair.getValue());
    }
}
```

 

有界类型参数

 

可以通过`extends`关键字来限制类型参数。例如,限制类型参数必须是某个类的子类或实现某个接口:

 

```java
public class Util {
    public static <T extends Comparable<T>> int compare(T t1, T t2) {
        return t1.compareTo(t2);
    }
}
 
public class Main {
    public static void main(String[] args) {
        System.out.println(Util.compare(10, 20)); // 输出负数,因为10小于20
    }
}
```

 

通配符

 

通配符是另一种泛型机制,用于灵活地指定类型。例如:

 

无界通配符

 

表示任何类型:

```java
public static void printList(List<?> list) {
    for (Object elem : list)
        System.out.print(elem + " ");
    System.out.println();
}
```

 

有界通配符

 

上界通配符:`<? extends T>` 表示类型是T或T的子类型。

 

```java
public void processElements(List<? extends Number> list) {
    for (Number num : list) {
        System.out.println(num.doubleValue());
    }
}
```

 

下界通配符:`<? super T>` 表示类型是T或T的父类型。

 

```java
public void addNumbers(List<? super Integer> list) {
    list.add(10);
    list.add(20);
}
```

 

类型擦除

 

泛型在编译时会进行类型擦除,以确保与非泛型代码的兼容性。这意味着所有类型参数都会被擦除,替换为其限定类型(无限定时为Object)。例如:

 

```java
public class Box<T> {
    private T t;
 
    public void set(T t) {
        this.t = t;
    }
 
    public T get() {
        return t;
    }
}
```

 

在编译后实际上类似于:

 

```java
public class Box {
    private Object t;
 
    public void set(Object t) {
        this.t = t;
    }
 
    public Object get() {
        return t;
    }
}
```

 

总结

 

Java泛型是一个重要且强大的特性,能够提高代码的类型安全性、可重用性和可读性。通过泛型类、泛型方法、泛型接口、有界类型参数和通配符等机制,开发者可以编写更加健壮和灵活的代码。理解和掌握泛型的使用,对于编写高质量的Java程序至关重要。

目录
相关文章
|
1天前
|
安全 Java
Java进阶之泛型
【7月更文挑战第10天】Java泛型,自Java 5引入,旨在提升类型安全和代码重用。通过泛型,如List&lt;String&gt;,可在编译时捕获类型错误,防止ClassCastException。泛型包括泛型类、接口和方法,允许定义参数化类型,如`class className&lt;T&gt;`,并用通配符&lt;?&gt;、extends或super限定边界。类型擦除确保运行时兼容性,但泛型仅做编译时检查。使用泛型能增强类型安全性,减少强制转换,提高性能。
10 1
|
1天前
|
Java
Java进阶之泛型
Java进阶之泛型
7 1
|
6天前
|
Java 程序员
深入理解Java中的泛型编程
深入理解Java中的泛型编程
|
10天前
|
存储 安全 Java
|
15天前
|
存储 安全 Java
JAVA 泛型新篇章:编译时类型安全的新境界!
【6月更文挑战第28天】Java 泛型增强了编译时类型安全,避免运行时类型转换异常。例如,未使用泛型的代码可能因隐含的类型转换抛出`ClassCastException`。泛型允许指定容器如`List&lt;String&gt;`的元素类型,确保编译期检查。此外,泛型类如`Stack&lt;T&gt;`能适应多种类型,提高代码重用。使用泛型方法如`&lt;T&gt; void processElements(List&lt;T&gt;)`可增强方法的通用性。泛型是Java中提升可靠性和灵活性的关键工具。
|
3天前
|
安全 Java 编译器
Java面试题:解释Java泛型的主要用途,并说明泛型擦除的概念。
Java面试题:解释Java泛型的主要用途,并说明泛型擦除的概念。
4 0
|
3天前
|
存储 安全 Java
Java面试题:请解释Java中的泛型集合框架?以及泛型的经典应用案例
Java面试题:请解释Java中的泛型集合框架?以及泛型的经典应用案例
8 0
|
5天前
|
Java 程序员
深入理解Java中的泛型编程
深入理解Java中的泛型编程
|
12天前
|
安全 算法 Java
Java中的泛型详解:边界、类型擦除与实际应用
Java中的泛型详解:边界、类型擦除与实际应用
|
15天前
|
存储 安全 Java
JAVA泛型:类型安全,从编译时开始!
【6月更文挑战第28天】Java泛型是JDK 5引入的特性,用于在编译时实现类型安全的集合。它通过类型参数增强代码灵活性和重用性,减少错误。示例展示了泛型列表`List&lt;Integer&gt;`和`List&lt;String&gt;`如何确保元素类型正确,防止编译时类型不符。泛型提升了代码的类型安全、可读性和维护性。