java 使用泛型的例子

一个使用泛型的例子是创建一个通用的容器类，可以存储任何类型的对象。例如：

public class Container<T> {
  private T value;

  public void setValue(T value) {
    this.value = value;
  }

  public T getValue() {
    return value;
  }
}

使用时可以指定具体的类型：

Container<String> stringContainer = new Container<String>();
stringContainer.setValue("Hello, world!");
String value = stringContainer.getValue();

Container<Integer> intContainer = new Container<Integer>();
intContainer.setValue(42);
int intValue = intContainer.getValue();

相关问题

我需要一个java全面泛型例子

当然，这个问题很好，这是一个Java全面泛型例子：

public class GenericExample<T> {

    private T data;

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

    public T getData() {
        return data;
    }

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

    public static void main(String[] args) {
        // Example 1: Using generic class with Integer type parameter
        GenericExample<Integer> integerExample = new GenericExample<>(10);
        System.out.println("Data in integerExample: " + integerExample.getData());

        // Example 2: Using generic class with String type parameter
        GenericExample<String> stringExample = new GenericExample<>("Hello, world!");
        System.out.println("Data in stringExample: " + stringExample.getData());

        // Example 3: Using generic method to print array of any type
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] stringArray = {"a", "b", "c", "d", "e"};
        printArray(intArray);
        printArray(stringArray);
    }

    public static <E> void printArray(E[] elements) {
        for (E element : elements) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

在这个例子中，我们定义了一个泛型类`GenericExample<T>`，它有一个类型参数`T`，代表这个类可以接受任何类型的数据。我们在构造函数中传入一个类型为`T`的数据，然后使用`getData()`方法获取这个数据。我们还定义了一个`setData()`方法，可以用来更新这个数据。

在`main()`方法中，我们创建了两个`GenericExample`对象，一个使用`Integer`类型参数，另一个使用`String`类型参数，以便演示该类可以接受任何类型的数据。我们还定义了一个泛型方法`printArray(E[] elements)`，该方法可以打印任何类型的数组，包括`Integer`和`String`类型数组。在`main()`方法中，我们演示了如何使用该方法打印`Integer`和`String`类型的数组。

希望这个例子能够回答您的问题！

java类 泛型的使用

泛型是Java中一种强大的特性，它允许我们在编写类或方法时使用类型参数，从而增加代码的灵活性和重用性。

要在Java类中使用泛型，可以在类名后面使用尖括号<>来定义类型参数。例如，我们可以创建一个泛型类来表示一个箱子，可以存放不同类型的物品：

public class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

在上面的例子中，`T`是一个类型参数，它表示箱子可以存放的物品的类型。通过使用类型参数，我们可以在实例化`Box`类时指定具体的类型。

下面是如何使用泛型类的示例：

Box<String> stringBox = new Box<>();
stringBox.setItem("Hello");
String item = stringBox.getItem(); // 返回 "Hello"

Box<Integer> integerBox = new Box<>();
integerBox.setItem(42);
int item = integerBox.getItem(); // 返回 42

通过在实例化`Box`类时指定不同的类型参数，我们可以创建不同类型的箱子，并且在编译时进行类型检查，以确保类型的安全性。

除了类，我们还可以在方法中使用泛型。这样可以使方法更加通用，适用于不同的数据类型。例如：

public class Utils {
    public static <T> void printArray(T[] array) {
        for (T item : array) {
            System.out.println(item);
        }
    }
}

在上面的例子中，`<T>`表示这是一个泛型方法，并且`T`是一个类型参数。我们可以使用这个方法打印任意类型的数组：

String[] stringArray = {"Hello", "World"};
Utils.printArray(stringArray);

Integer[] intArray = {1, 2, 3};
Utils.printArray(intArray);

通过使用泛型，我们可以编写更加通用和灵活的代码，提高代码的可复用性和类型安全性。