什么是泛型

Java泛式其实就是我们一开始并不知道这个类或者变量是什么数据类型，但这个类或者变量就存在在那里，会根据我们导入的参数之类的数据类型来判断，从而创建改数据类型的数据。

作用：规定集合/类只能存指定类型，编译时做类型校验。

没有泛型会怎么样

集合类默认存Object，什么类型都能放。所以我们取数据的时候必须强制向下转型，而这个过程很容易抛出错误。

1
2
3
4
5
ArrayList list = new ArrayList();
list.add(123);
list.add("张三");
// 取出要强转
String s = (String) list.get(0); //运行报错

泛型基本格式

  • E：Element元素
  • T：Type类型
  • K：Key键
  • V：Value值

集合使用泛型（最常用）

1
ArrayList<String> list = new ArrayList<>();
  • <String>限定这个集合只能存放String类型
  • 存入其他类型，编译会报错
  • 取出不用强制转换
1
2
3
4
5
6
7
// 只能存整数
ArrayList<Integer> list = new ArrayList<>();
list.add(10);
// list.add("abc"); 编译报错

// 直接取出，无需强转
Integer num = list.get(0);

自定义泛型

1
public class 类名<T>{}

T就是不确定类型，创建对象时传入。格式：

1
2
3
4
5
6
7
8
9
10
11
// 泛型类
public class MyGeneric<T>{
    private T data;

    public T getData() {
        return data;
    }
    public void setData(T data) {
        this.data = data;
    }
}

使用：

1
2
3
4
5
6
7
// 指定T为String
MyGeneric<String> g1 = new MyGeneric<>();
g1.setData("泛型测试");

// 指定T为Integer
MyGeneric<Integer> g2 = new MyGeneric<>();
g2.setData(666);

泛型方法

1
public <T> void 方法名(T t){}

这个时候我们就好奇了，如果类上面写的T，然后方法这里也是T。可是类和方法的T传入的并不一样呢？

1
2
3
4
5
6
7
8
9
// 类泛型 T
public class Demo<T> {

    // 方法自己独立泛型 T
    public <T> void test(T val){
        // 这里的T 是【方法泛型】，不是类泛型
        System.out.println(val);
    }
}

这个时候我们就要知道：方法自定定义的泛型>类身上定义的泛型。

1
2
3
4
// 类指定泛型是 String
Demo<String> d = new Demo<>();
// 方法传 Integer
d.test(100);

最近优先，局部盖全局。

泛型接口

1
public interface 接口名<T>{}

这个有两种实现方法：
实现类确定泛型类型：

1
public class Demo implements MyInter<String>{}

实现类延续泛型：

1
public class Demo<T> implements MyInter<T>{}

泛型通配符’?’

?代表任意未知类型

任意类型

1
public void test(List<?> list){}

上限限定

1
public void test(List<? extends 父类> list){}

下限限定

1
public void test(List<? super 子类> list){}

泛型特点⭐

  • 泛型只在编译阶段生效，运行期会被擦除：运行时全部变回Object
  • 泛型不能使用基本数据类型，必须使用包装类：Integer、Double、Boolean
  • 泛型不支持多继承直接写，只能单上限
  • 不能创建泛型数组
  • 静态方法不能使用类上定义的泛型

说些什么吧！

twikoo