Java——泛型

1.什么是泛型

泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译 器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

语法格式：

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

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

代码示例1：

class MyArray<E>{//定义一个泛型类
    Object []array=new Object[10];
    public void setArray(E x,int pos){
        array[pos]=x;
    }
    public E getArray(int pos){
        return (E) array[pos];//将Object强转为E
    }
}

public class Main {
public static void main(String[] args) {
        MyArray<Integer> myArray=new MyArray<>();//实例化一个泛型类对象
//new MyArray<>的<>中写包装类，可写可不写
        myArray.setArray(10,0);
        myArray.setArray(20,1);
        myArray.setArray(30,2);
        System.out.println(myArray.getArray(0));
        System.out.println(myArray.getArray(1));
        System.out.println(myArray.getArray(2));
}
}

1. 类名后的 代表占位符，表示当前类是一个泛型类

了解： 【规范】类型形参一般使用一个大写字母表示，常用的名称有：

E 表示 Element

K 表示 Key

V 表示 Value

N 表示 Number

T 表示 Type

S, U, V 等等 - 第二、第三、第四个类型

注意：泛型只能接受类，所有的基本数据类型必须使用包装类！

2.泛型的上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

语法格式：

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

示例：

public class MyArray<E extends Number> {
   ...
}

当实例化一个MyArray类时，<>只接受 Number 的子类型作为 E 的类型实参

了解： 没有指定类型边界 E，可以视为 E extends Object

3.使用泛型寻找数组最大值

方法限定符 类型形参列表> 返回值类型 方法名称(形参列表) { ... }

代码示例1：

class ArrayMax<E extends Comparable<E>>{//继承Comparable接口
    Object[]arr=new Object[10];
    public E findMax(E[]array){
        E max=array[0];
        for (int i = 1; i <array.length ; i++) {
            if(max.compareTo(array[i])<0){//因为当E为引用类型时，无法用==比较大小，所以要实现Comparable接口
                max=array[i];
            }
        }
        return max;
    }
}

public class Main{
  public static void main(String[] args) {
        Integer []arr={1,2,3,4,5,6,7,8};
        ArrayMax<Integer> arrayMax=new ArrayMax<>();//实例化泛型类对象
        int x=arrayMax.findMax(arr);
        System.out.println(x);
    }
}

代码示例2：

泛型方法，在方法中实现接口

class ArrayMax1{
    public <E extends Comparable<E>>E findMax(E []array){
        E max=array[0];
        for (int i = 1; i <array.length ; i++) {
            if(max.compareTo(array[i])<0){
                max=array[i];
            }
        }
        return max;
    }
}

public class Main{
public static void main3(String[] args) {
        ArrayMax<Integer>arrayMax=new ArrayMax<>();
        Integer []arr={12,3,4,2,211,21,231};
        int x=arrayMax.findMax(arr);
        System.out.println(x);
    }

}

代码示例3：

静态泛型方法：

class ArrayMax2{
    public static <E extends Comparable<E>>E findMax(E[]array){
        E max=array[0];
        for (int i = 1; i <array.length ; i++) {
            if(max.compareTo(array[i])<0){
                max=array[i];
            }
        }
        return max;
    }
}

public class Main {
    public static void main(String[] args) {
        Integer []arr={12,3,4,2,211,21,231};
        System.out.println(ArrayMax2.findMax(arr));//直接通过类名调用方法
    }
}