Question

我学到了关于泛型类的基本思想，可以用另一个类进行参数化（或键入）。我给出的例子是ArrayList<E>。

泛型类是专门引用ArrayList还是任何类型？

Answer 1

使用 < .. > 声明的所有类都是通用类。

某个给定类型T的ArrayList声明为：

ArrayList<T> list = new ArrayList<T>()

持有整数的ArrayList（当打算持有int时）应为

ArrayList<Integer> list = new ArrayList<Integer>()

您也可以创建自己的泛型类（这里是一个节点，用于某些单链表，包含一些未指定的类型E）

class Node<E> {
    private E element;
    private Node<E> next;

    public Node(E element) {
        this.element = element;
        this.next = null;
    }

    public E getElement() {
        return this.element;
    }

    public Node<E> getNext() {
        return this.next;
    }
}

注意：T不能是基本类型，例如char，int，boolean，double。您必须使用Character，Integer，Boolean或Double等包装。

Answer 2

Java中的泛型与C ++中的模板类似。我们的想法是允许类型（Integer，String，...等和用户定义的类型）成为方法，类和接口的参数。例如，像HashSet，ArrayList，HashMap等类很好地使用泛型。我们可以将它们用于任何类型。

通用类：

要创建泛型类的对象，我们使用以下语法。

//创建泛型类的实例 BaseType obj = new BaseType（）

注意：在参数类型中我们不能使用像这样的基元 'int'，'char'或'double'。

// A Simple Java program to show working of user defined
// Generic classes

// We use < > to specify Parameter type
class Test<T>
{
    // An object of type T is declared
    T obj;
    Test(T obj) {  this.obj = obj;  }  // constructor
    public T getObject()  { return this.obj; }
}

// Driver class to test above
class Main
{
    public static void main (String[] args)
    {
        // instance of Integer type
        Test <Integer> iObj = new Test<Integer>(15);
        System.out.println(iObj.getObject());

        // instance of String type
        Test <String> sObj =
                          new Test<String>("GeeksForGeeks");
        System.out.println(sObj.getObject());
    }
}

我们还可以在Generic类中传递多个Type参数。

// A Simple Java program to show multiple
// type parameters in Java Generics

// We use < > to specify Parameter type
class Test<T, U>
{
    T obj1;  // An object of type T
    U obj2;  // An object of type U

    // constructor
    Test(T obj1, U obj2)
    {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }

    // To print objects of T and U
    public void print()
    {
        System.out.println(obj1);
        System.out.println(obj2);
    }
}

// Driver class to test above
class Main
{
    public static void main (String[] args)
    {
        Test <String, Integer> obj =
            new Test<String, Integer>("GfG", 15);

        obj.print();
    }
}

通用函数：

我们还可以根据传递给泛型方法的参数类型编写可以使用不同类型的参数调用的泛型函数，编译器处理每个方法。

// A Simple Java program to show working of user defined
// Generic functions

class Test
{
    // A Generic method example
    static <T> void genericDisplay (T element)
    {
        System.out.println(element.getClass().getName() +
                           " = " + element);
    }

    // Driver method
    public static void main(String[] args)
    {
         // Calling generic method with Integer argument
        genericDisplay(11);

        // Calling generic method with String argument
        genericDisplay("GeeksForGeeks");

        // Calling generic method with double argument
        genericDisplay(1.0);
    }
}

泛型的优点：

使用Generics的程序比非通用代码有许多好处。

Code Reuse: We can write a method/class/interface once and use for any type we want.

.
Type Safety : Generics make errors to appear compile time than at run time (It’s always better to know problems in your code at compile time rather than making your code fail at run time). Suppose you want to create an ArrayList that store name of students and if by mistake programmer adds an integer object instead of string, compiler allows it. But, when we retrieve this data from ArrayList, it causes problems at runtime.


     // A Simple Java program to demonstrate that NOT using
        // generics can cause run time exceptions
        import java.util.*;

        class Test
        {
            public static void main(String[] args)
            {
                // Creatinga an ArrayList without any type specified
                ArrayList al = new ArrayList();

                al.add("Sachin");
                al.add("Rahul");
                al.add(10); // Compiler allows this

                String s1 = (String)al.get(0);
                String s2 = (String)al.get(1);

                // Causes Runtime Exception
                String s3 = (String)al.get(2);
            }
        }

Output :

Exception in thread "main" java.lang.ClassCastException: 
   java.lang.Integer cannot be cast to java.lang.String
    at Test.main(Test.java:19)

泛型如何解决这个问题？在定义ArrayList时，我们可以指定此列表只能使用String对象。 //使用泛型将运行时异常转换为 //编译时异常。 import java.util。*;

class Test
{
    public static void main(String[] args)
    {
        // Creating a an ArrayList with String specified
        ArrayList <String> al = new ArrayList<String> ();

        al.add("Sachin");
        al.add("Rahul");

        // Now Compiler doesn't allow this
        al.add(10); 

        String s1 = (String)al.get(0);
        String s2 = (String)al.get(1);
        String s3 = (String)al.get(2);
    }
}

Output:

15: error: no suitable method found for add(int)
        al.add(10); 
          ^

。不需要单独类型转换：如果我们不使用泛型，那么，在上面的例子中，每次我们从ArrayList检索数据时，我们必须对它进行类型转换。在每次检索操作中进行类型转换都是一个令人头痛的问如果我们已经知道我们的列表只包含字符串数据，那么我们不需要每次都对它进行类型化。

// We don't need to typecast individual members of ArrayList
import java.util.*;

class Test
{
    public static void main(String[] args)
    {
        // Creating a an ArrayList with String specified
        ArrayList <String> al = new ArrayList<String> ();

        al.add("Sachin");
        al.add("Rahul");

        // Typecasting is not needed 
        String s1 = al.get(0);
        String s2 = al.get(1);
    }
}

。实现通用算法：通过使用泛型，我们可以实现适用于不同类型对象的算法，同时它们也是类型安全的。

T可以用任何类型创建泛型类的对象吗？

2 个答案: