（泛型类定义与方法的调用）编写一个Java程序，定义泛型类和泛型类的方法，然后创建一个泛型类对象，调用泛型类对象输出相应的结果；

可以尝试以下代码：

public class GenericDemo<T> {
    private T data;

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

    public T getData() {
        return data;
    }

    public <E> void print(E element) {
        System.out.println(element);
    }

    public static void main(String[] args) {
        GenericDemo<Integer> demo = new GenericDemo<>(123);
        System.out.println(demo.getData());

        demo.print("这是一个泛型类的方法");
    }
}

在该程序中，我们定义了一个泛型类 `GenericDemo`，该类中有一个泛型类型的属性 `data` 和一个泛型方法 `print`。在 `main` 方法中，我们创建了一个 `GenericDemo` 类的对象 `demo`，并指定泛型类型为 `Integer`，然后调用了该对象的 `getData` 方法输出 `123`。接着，我们调用了 `demo` 对象的 `print` 方法，并传入了一个字符串类型的参数，该方法成功输出了字符串。

相关问题

4、（泛型类定义与方法的调用）编写一个Java程序，定义泛型类和泛型类的方法，然后创建一个泛型类对象，调用泛型类对象输出相应的结果

可以参考以下代码：

public class GenericDemo<T> {
    private T data;

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

    public T getData() {
        return data;
    }

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

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

    public static void main(String[] args) {
        GenericDemo<Integer> demo1 = new GenericDemo<>(100);
        System.out.println("泛型类对象的数据为：" + demo1.getData());

        String[] arr = {"Hello", "World", "!"};
        GenericDemo<String> demo2 = new GenericDemo<>("GenericDemo");
        demo2.printArray(arr);
    }
}

运行结果：

泛型类对象的数据为：100
Hello World !

在上面的代码中，我们定义了一个泛型类 `GenericDemo<T>`，该类有一个泛型变量 `T`，并且提供了一个构造函数和一些方法。我们定义了一个泛型方法 `printArray(E[] arr)`，该方法接收一个泛型数组并输出其元素。在 `main()` 方法中，我们创建了两个泛型类对象，分别是 `GenericDemo<Integer>` 和 `GenericDemo<String>` 类型的对象，并分别调用了 `getData()` 和 `printArray()` 方法。

编写一个Java程序，定义泛型类和泛型类的方法，然后创建一个泛型类对象，调用泛型类对象输出相应的结果

好的，以下是一个简单的 Java 程序，其中定义了一个泛型类和一个泛型方法，然后创建了一个泛型类对象并调用了它的方法来输出相应的结果：

class GenericClass<T> {
    private T value;

    public GenericClass(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

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

public class GenericExample {
    public static void main(String[] args) {
        GenericClass<Integer> intObj = new GenericClass<>(10);
        System.out.println("Integer Value: " + intObj.getValue());

        GenericClass<String> strObj = new GenericClass<>("Hello");
        System.out.println("String Value: " + strObj.getValue());

        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"John", "Mary", "Tom", "Jerry"};

        System.out.print("Int Array: ");
        intObj.printArray(intArray);

        System.out.print("String Array: ");
        strObj.printArray(strArray);
    }
}

在上面的程序中，我们定义了一个名为 GenericClass 的泛型类，它有一个泛型类型参数 T，并拥有一个名为 getValue 的方法，用于获取泛型类型参数 T 的值。此外，我们还定义了一个名为 printArray 的泛型方法，它有一个泛型类型参数 E，用于打印任意类型的数组。

在主方法中，我们创建了一个 Integer 类型的泛型类对象 intObj 和一个 String 类型的泛型类对象 strObj，并调用了它们的 getValue 方法来输出它们的值。然后，我们创建了一个 Integer 类型的数组 intArray 和一个 String 类型的数组 strArray，并调用了泛型类对象的 printArray 方法来输出它们的值。

当我们运行这个程序时，它会输出以下内容：

Integer Value: 10
String Value: Hello
Int Array: 1 2 3 4 5 
String Array: John Mary Tom Jerry 

这表明我们成功地定义了泛型类和泛型类的方法，并创建了一个泛型类对象来调用它的方法输出相应的结果。