？表示不确定的 java 类型
T (type) 表示具体的一个java类型
K V (key value) 分别代表java键值中的Key Value
E (element) 代表Element
一个简单的泛型类
GenericsTest类引入了一个类型变量T，它指定了方法的返回类型以及域和局部变量的类型
可以看到不指定类型时需要强转、指定类型时就不需要了
public class GenericsTest<T> {
private T t;
public void set(T t){
this.t=t;
}
public T get(){
return this.t;
}
@Test
void test(){
GenericsTest number=new GenericsTest();
number.set(13);
//不指定类型时需要强转
Integer num =(Integer) number.get();
System.out.println(num);
GenericsTest<String>name=new GenericsTest<>();
name.set("liuyuan");
//指定类型就不需要强转了
String getName = name.get();
System.out.println(getName);
}
}
泛型方法
泛型方法可以在普通类中定义也可以在泛型类中定义,调用泛型方法时可以在方法名前的尖括号中放入具体的类型
public class GenericsTest<T> {
private T t;
public void set(T t){
this.t=t;
}
public T get(){
return this.t;
}
/**
* 类型变量放在修饰符public static后面，返回类型的前面
* @param a
* @param <T>
* @return
*/
public static <T> T getMiddle(T ...a){
return a[a.length/2];
}
@Test
void testGetMiddle(){
//大多情况可以直接省略<String>不写，编译器能够推断出类型
String middle = GenericsTest.getMiddle("left", "middle","middle2", "right");
System.out.println(middle);
// 可以指定类型
Integer middle1 = GenericsTest.<Integer>getMiddle(123, 22, 56);
System.out.println(middle1);
}
}
类型变量的限定
场景：对数组排序想要最小值，但是必须下面的smallest实现了Comparable接口我们才能使用其compareTo方法对其进行判断，此时通过对类型变量T设置限定实现
<T extends Comparable>
此时确定了T所属的类有了compareTo方法就能实现我们想要的结果
public static <T extends Comparable> T getMinNum(T arr[]){
if(arr == null || arr.length== 0 ) return null;
T smallest=arr[0];
for (int i = 0; i < arr.length; i++) {
if(smallest.compareTo(arr[i])>0){
smallest=arr[i];
}
}
return smallest;
}
@Test
void getMinNumTest(){
String arr []=new String[]{
"b","a","d"};
String minNum = getMinNum(arr);
System.out.println(minNum);
Integer arr1 []=new Integer[]{
6,4,1};
System.out.println(getMinNum(arr1));
}
提一嘴：这里的关键词为什么用extends去限定，T应该是绑定的类型的子类，而T和绑定类型可以是接口或类，选择extends更接近子类概念 所以不用implements
另外：一个类型变量或通配符可以有多个限定
T extends Comparable & Seralizable，限定类型用&分割，而逗号用来分割类型变量
最大值和最小值案例
1、<T extends Comparable>限定类型变量
2、参数返回Pair
public static <T extends Comparable> Pair<T> getMAxAndMin(T arr[]){
if(arr == null || arr.length == 0)return null;
T min=arr[0];
T max=arr[0];
for (int i = 0; i < arr.length; i++) {
if(min.compareTo(arr[i])>0){
min=arr[i];
}
if(max.compareTo(arr[i])<0){
max=arr[i];
}
}
return new Pair(min,max);
}
@AllArgsConstructor
public class Pair<T>{
@Getter
@Setter
T first;
@Getter
@Setter
T second;
}
泛型类型的继承规则
使用泛型类型时，比如List<Animal.Dog>是List<Animal>的子类吗？？？肯定不是
通配符类型
通配符解决什么问题???：
比如想要打印动物的信息：
public void printAnimal2(List<Animal> animals){
for (int i = 0; i < animals.size(); i++) {
System.out.println(animals.get(i));
}
但是你不能把List<Animal.Dog>也就是狗的集合传进去，这点是受限制的，解决办法就是使用通配符类型。
1、public void printAnimal3(List<? extends Animal>animals) 类型List<Animal.Dog>是List<Animal>的子类型
2、换种姿势实现上述需求
public <T extends Animal> void printAnimal(List<T> animals) 指定了List<T> animals只能够是Animal的子类
两种方式实现代码如下：
@AllArgsConstructor
@Data
public class Animal {
private String name;
private String sex;
private Integer age;
public static class Dog extends Animal{
public Dog(String name, String sex, Integer age) {
super(name, sex, age);
}
}
public static class Cat extends Animal{
public Cat(String name, String sex, Integer age) {
super(name, sex, age);
}
}
}
想把List<Animal.Dog>打印出来报错
@Test
void testPrintAnimal(){
List<Animal.Dog> dogs=new ArrayList<>();
dogs.add(new Animal.Dog("dog","1",18));
// error
printAnimal2(dogs);
}
public void printAnimal2(List<Animal> animals){
for (int i = 0; i < animals.size(); i++) {
System.out.println(animals.get(i));
}
}
而这样就可以两种方式都可以实现
//<T extends Animal> 对T进行了限制 只能是Animal子类
public <T extends Animal> void printAnimal(List<T> animals){
for (int i = 0; i < animals.size(); i++) {
System.out.println(animals.get(i));
}
}
//? extends Animal 标示任何泛型List类型，类型参数是Animal子类即可
public void printAnimal3(List<? extends Animal>animals){
for (int i = 0; i < animals.size(); i++) {
System.out.println(animals.get(i));
}
}
@Test
void testPrintAnimal(){
List<Animal.Dog> dogs=new ArrayList<>();
dogs.add(new Animal.Dog("dog","1",18));
printAnimal(dogs);
printAnimal3(dogs);
}