当Java遇上泛型：类型安全的魔法之旅

泛型是jdk1.5之后出现的新特性，其本质是参数化类型（type parameters），通过参数化类型让代码可以应用于多种类型。

---

泛型是什么

泛型，即“参数化类型”，就是将类型由原来的具体类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

常用的泛型变量

• Element(E)：元素,多用于java框架集合

• Key(K) ：关键字

• Number(N) : 数字

• Type(T) : 类型

• Value(V) : 值

如果没有泛型会怎么样？

public class Demo {

    public static int add(int a ,int b){
        return a+b;
    }

    public  static  float add(float a,float b){
        return a+b;
    }
    
    public static void main(String[] args) {
        Demo.add(1, 2);
        Demo.add(1f, 2f);
    }
}

如果我们利用泛型，只需要定义一个方法

public class Demo {

    public static <T extends Number> int add(T a, T b) {
        System.out.println(a + "+" + b + "=" + (a.intValue() + b.intValue()));
        return a.intValue() + b.intValue();
    }

    public static void main(String[] args) {
        Demo.add(1, 2);
        Demo.add(1f, 2f);
    }
}

所以泛型的意义在于

1. 适用于多种数据类型执行相同的代码

2. 泛型中的类型在使用时指定，不需要强制转换类型（类型安全，编译器会检查类型）

泛型的使用

泛型类

示例：

public class DemoT<T> {
    private T data;

    public T getData(){
        return data;
    }

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

案例

@Data
public class Person<A> {
    private  String name;
    private int age;
    private A data;
}

public class Demo {
    public static void main(String[] args) {
        //传入String类型
        DemoT<String> t = new DemoT<>(); 
        t.setData("泛型");
    }
}

泛型接口

示例：

public interface IntercaceName<T> {
    T getData();
}

实现接口时，可以选择指定泛型类型，也可以选择不指定，如下：

指定类型：

public class Interface1 implements IntercaceName<String>{
    private String text;
    @Override
    public String getData() {
        return text;
    }
}

不指定类型：

public class Interface1<T> implements IntercaceName<T>{
    private T text;
    @Override
    public T getData() {
        return text;
    }
}

泛型方法

示例：

private static <T> T 方法名 (T a,T b){}

public class Demo {
    public static void main(String[] args) {
        print("泛型");
    }
    public static <A> void print(A a){
        System.out.println(a);
    }
}

泛型限制类型

在使用泛型时，可以指定泛型的限定区域

• 例如：必须是某某类的子类或 某某接口的实现类，格式：

<T extends 类或接口1 & 接口2>

泛型中的通配符 ？

//1. <? extends Parent> 指定了泛型类型的上届
//2. <? super Child> 指定了泛型类型的下届
//3. <?> 指定了没有限制的泛型类型

public class Demo {
    public static void main(String[] args) {
        //上届限定
        //不能将一个装着苹果的盘子，看做一个装着水果的盘子
        Plants<? extends Fruit> p = new Plants<Apple>();
        //下届限定
        Plants<? super Apple> p1 = new Plants<Fruit>();
    }
}
interface Fruit{}
class Apple implements Fruit{}
class Plants<T>{
    T data;
}

作用

1. 提高了代码复用率

2. 泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型）

注意

在编译之后程序会采取去泛型化的措施，也就是说Java中的泛型，只在编译阶段有效。

在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦除，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说泛型信息不会进入到运行时阶段。

总结

相信大家日常工作中肯定是经常用到泛型，尤其是集合的使用。有时候也会自定泛型来简化代码，一句话就是能用泛型就尽量用泛型。