说明

  • 在不确定参数具体类型的时候，可以使用泛型，代替具体类型。
  • 泛型可用于类和方法，泛型用于代替具体类型。

声明

类

声明
1
2
3
作用域 class 类名<泛型1, 泛型2…>{
    …
}

接口

声明
1
2
3
interface 接口名<泛型1, 泛型2…>{
    …
}

方法

TODO: 多个泛型参数？

声明
1
2
3
作用域 <泛型>返回类型 方法名 (泛型){
    …
}
e.g.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//声明泛型类
public class Test<T1, T2>{
    T1 a; //声明T1类型的a
    T2 b;  //声明T2类型的b
    //声明返回T1类型的方法
    public T1 getA(){
        return T1;
    }
    //声明参数为T2类型的方法
    public void setB(T2 b){
        this.b = b
    }
}

//声明普通类中的泛型方法
public class Gen{
    public <T>T print(T t){
        System.out.print(t.toString());
    }
}

调用

类名<具体类型1, 具体类型2> 对象名 = new 类名<具体类型1, 具体类型2>();

e.g.
1
2
3
4
5
6
7
8
Test<int , string> myTest = new Test<int ,String>();
ArrayList<String> arrL = new ArrayList<String>();
Test<double , double> myTest2 = …….();
int a = myTest.getA()
// Test T = new Test();//×
for(int i = 0 ;i< arrL.size(); i++){
    String s = arrL.get(i);
}

通配符

<?> 无限制通配符

  • <?>用于在不确定该泛型对象类型时使用
e.g.
1
2
3
4
5
6
7
8
9
// 方法say确定了参数只能是Test<int, String>类型
public void say(Test<int, String> s){
    System.out.println(s.getA());
}

//方法print则只规定了参数为Test即可，并没有确定具体的泛型类型，用 ? 代替
public void print(Test<?,?> s){
    System.out.println(s.getA());
}

extends/supper 子类/父类通配符

  • <? extends classA> 表示参数类型必须是classA的子类
  • <? supper classB> 表示参数类型必须是classB的父类
e.g.
1
2
3
4
5
6
7
8
9
10
11
12
ArrayList<? extends People> ….

//设有Student继承自People
//设有泛型类Gen<T>
public void speak(Gen<? extends People> p){
    …
}

Gen<Student> g = new Gen<Student>();
Gen<Dog> d = new Gen<Worker>()
speak(g);//√
//speak(d); //×因为dog不是people的子类