Java技术教程 – Java中的泛型（Generics）详解与案例

Java 技术教程 – Java中的泛型（Generics）详解与案例

引言

泛型（Generics）是Java SE 5引入的一项强类型机制，它允许你在编译时期指定类、接口和方法中将要操作的数据类型。使用泛型的好处主要包括类型安全和代码重用。本文将详细介绍Java中泛型的使用及其案例。

泛型类

泛型类是指在类声明中类型参数化的类。例如，创建一个可以存储任意类型对象的盒子类：


public class Box<T> {
    private T content;

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

    public T getContent() {
        return content;
    }
}

在这个例子中，`Box`是一个泛型类，T是一个类型参数，它可以在创建对象时指定。

泛型方法

泛型方法是指在方法声明中类型参数化的方法。例如，一个可以打印任意类型对象的方法：


public class Util {
    public static <T> void print(T value) {
        System.out.println(value);
    }

    public static void main(String[] args) {
        Util.print(100);       // 输出：100
        Util.print("Hello");   // 输出：Hello
    }
}

`<T>`声明了这是一个泛型方法，T是一个类型参数。

泛型接口

泛型接口是指在接口声明中类型参数化的接口。例如，定义一个可以存储任意类型对象的容器接口：


public interface Container<T> {
    void add(T item);
    T get(int index);
}

然后可以创建一个具体实现类：


public class MyContainer<T> implements Container<T> {
    private List<T> items = new ArrayList<T>();

    @Override
    public void add(T item) {
        items.add(item);
    }

    @Override
    public T get(int index) {
        return items.get(index);
    }
}

泛型案例：使用泛型实现一个简单的泛型数组

下面是一个使用泛型实现的简单泛型数组类，它可以存储任意类型的对象：


public class GenericArray<T> {
    private T[] array;
    private int size;

    public GenericArray(int capacity) {
        array = (T[]) new Object[capacity];
        size = 0;
    }

    public void add(T item) {
        if (size == array.length) {
            resize();
        }
        array[size++] = item;
    }

    private void resize() {
        T[] newArray = (T[]) new Object[array.length * 2];
        System.arraycopy(array, 0, newArray, 0, array.length);
        array = newArray;
    }

    public T get(int index) {
        if (index >= size || index < 0) {
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        return array[index];
    }

    public int getSize() {
        return size;
    }

    public static void main(String[] args) {
        GenericArray<String> strArray = new GenericArray<>(3);
        strArray.add("Hello");
        strArray.add("World");
        System.out.println(strArray.get(1)); // 输出：World

        GenericArray<Integer> intArray = new GenericArray<>(3);
        intArray.add(100);
        intArray.add(200);
        System.out.println(intArray.get(0)); // 输出：100
    }
}

这个案例展示了如何使用泛型来创建一个可以被类型参数化的数组类，使得该类能够存储任意类型的对象。