说明

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

声明

声明
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的子类