泛型在类中的使用

---

前言

泛型的学习

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、泛型是什么？

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

二、泛型的使用

1.泛型类

代码如下（示例）：

public class DemoT<T> {
    private T data;

    public T getData(){
        return data;
    }

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

案例

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public A getData() {
        return data;
    }

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

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

2.泛型接口

代码如下（示例）：

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;
    }
}

3.泛型方法

代码如下（示例）：

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);
    }
}

4.泛型限制类型

在使用泛型时，可以指定泛型的限定区域
-例如：必须是某某类的子类或 某某接口的实现类，格式：

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

5.泛型中的通配符 ？

类型通配符时使用 ? 代替方法具体的类型实参

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