JAVA泛型

Java中的泛型是一种类型参数化的机制，可以在编译时期检查类型的安全性，避免类型转换异常等问题。泛型可以应用于类、接口、方法等，使得代码更加灵活、可重用性更高。

定义泛型的语法格式如下：

class 类名 <T> {
    // T 为类型参数
    // 可以在类中使用 T 作为类型
}

interface 接口名 <T> {
    // T 为类型参数
    // 可以在接口中使用 T 作为类型
}

方法名 <T> (参数列表) {
    // T 为类型参数
    // 可以在方法中使用 T 作为类型
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

其中，T是类型参数，可以是任意标识符，但通常使用T、E、K、V等表示类型参数。

在使用泛型时，可以通过的方式指定类型参数，如：

List list = new ArrayList(); // 创建一个字符串类型的列表
1

在定义泛型类或接口时，可以使用多个类型参数，如：

class Pair<T, U> {
    private T first;
    private U second;
    // ...
}
1
2
3
4
5

这样就可以定义一个可以存储任意类型的键值对的类。在使用时，可以指定不同的类型参数，如：

Pair<String, Integer> p1 = new Pair<>("hello", 1);
Pair<Integer, Double> p2 = new Pair<>(2, 3.14);
1
2

这样就可以创建出不同类型的键值对对象。

答案2

Java泛型是一种在编译时期进行类型检查的机制，它可以让代码更加灵活和安全。泛型可以用于类、接口、方法的定义中，可以让这些定义中的类型参数在使用时被具体指定。

泛型的定义使用尖括号（<>）来包含类型参数，例如：

public class MyList<T> {
    private T[] data;
    // ...
}
1
2
3
4

在这个示例中，MyList 类的定义中包含了一个类型参数 T，表示这个列表中存储的元素的类型是未知的。在使用这个类时，可以通过指定类型参数来指定存储的元素的具体类型，例如：

MyList<String> list = new MyList<String>();
list.add("hello");
list.add("world");
1
2
3

这里指定了 MyList 类的类型参数为 String，因此 list 对象可以存储字符串类型的元素。

除了类定义中的泛型，还可以在接口、方法中定义泛型。例如：

public interface MyMap<K, V> {
    V get(K key);
    void put(K key, V value);
}

public <T> T myMethod(T[] array) {
    // ...
}
1
2
3
4
5
6
7
8

在这个示例中，MyMap 接口和 myMethod 方法都定义了类型参数，可以在使用时指定具体的类型。

示例代码：

public class MyList<T> {
    private T[] data;
    private int size;

    public MyList() {
        data = (T[]) new Object[10];
        size = 0;
    }

    public void add(T element) {
        if (size >= data.length) {
            T[] newData = (T[]) new Object[data.length * 2];
            System.arraycopy(data, 0, newData, 0, data.length);
            data = newData;
        }
        data[size++] = element;
    }

    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        return data[index];
    }

    public int size() {
        return size;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

这个示例中定义了一个泛型类 MyList，它可以存储任意类型的元素。在 add 方法中，如果数组已满，会自动扩容。在 get 方法中，如果索引超出了范围，会抛出异常。在使用时，可以指定具体的类型参数，例如：

MyList<String> list = new MyList<String>();
list.add("hello");
list.add("world");
System.out.println(list.get(0)); // 输出 "hello"
1
2
3
4