详解Java中的泛型（泛型的语法，擦除机制，泛型的上界）

本文介绍: 泛型（Ge n er i cs）是Jav a SE 5中引入的一个新特性，可以使Jav a中的类和方法具有更广泛的类型范围。通俗的说，它使得我们可以在定义类和方法时指定一个或多个类型参数，从而可以在不考虑具体类型的情况下，代码中直接使用这些类型参数。泛型可以增强代码的安全性、可读性和可重用性。例如，可以使用泛型实现容器类（如Ar r a yLi st、Ha shMap）等。在使用泛型时，需要在编写代码时指定泛型类型，这样可以在编译期间检查代码的类型安全性。

一.什么是泛型

二.Java中为什么要使用泛型

三.泛型的语法

class MyArray {
    public Object[] array = new Object[10];
    public Object getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,Object val) {
        this.array[pos] = val;
    }
}

    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setVal(0, 10);//整形可以存放
        myArray.setVal(1, "hello");//字符串也可以存放
        String ret = myArray.getPos(1);//编译报错，原因是因为我们数组的类型是Object类型
        //但是我们这里接收的元素却是String类型
        //也就是说我们相当于进行了向下转型，所以这里会报错
        //如果我们进行强制转化就可以解决这个问题
        //String ret = (String) myArray.getPos(1);
        System.out.println(ret);
    }

class 泛型类名称&lt;类型形参列表&gt; {
    // 这里可以使用类型参数
}
class ClassName&lt;T1, T2, ..., Tn&gt; {
}

class 泛型类名称&lt;类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
    // 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
    // 可以只使用部分类型参数
}

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

MyArray<Integer> list = new MyArray<Integer>();

MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为 Integer

class MyArray<T> {
    public T[] array = (T[])new Object[10];//1
    //public T[] array;
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}

    public static void main(String[] args) {
        MyArray<Integer> myArray1 = new MyArray<>();//2
        myArray1.setVal(0,10);
        myArray1.setVal(1,12);
        
        MyArray<String> myArray2 = new MyArray<>();//3
        myArray2.setVal(0,"hello");
        myArray2.setVal(1,"world");
        
        MyArray<Float> myArray3 = new MyArray<>();//4
        myArray3.setVal(0,1.23f);
        myArray3.setVal(1,3.14f);
    }

T[] arrary = new T[5];//是不对的

class 泛型类名称<类型形参 extends 类型边界> {
    //... ...
}

public class MyClass<T extends MyClass2> {
    // ...
}

public class Box<T extends Comparable<T>> {
    private T value;

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

    public T getValue() {
        return value;
    }

    public boolean isGreaterThan(Box<T> otherBox) {
        return value.compareTo(otherBox.getValue()) > 0;
    }
}

在这个示例中，我们使用<T extends Comparable<T>>来定义类型参数上界，确保T必须是实现了Compar able接口的类。这样，我们就可以在isGreaterThan()方法中使用value.compareTo()方法来比较value字段和另一个Box对象的值了。