泛型入门篇

鹿小伟

已于 2022-11-12 17:42:27 修改

阅读量137

点赞数 1

分类专栏：数据结构文章标签： java

于 2022-11-11 01:06:10 首次发布

本文链接：https://blog.csdn.net/weixin_48584088/article/details/127795916

版权

数据结构专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.什么是泛型

泛型：JDK1.5引入的特性，适用于很多类型。

2.引出泛型

Java强类型语言。定义一个变量时，必须定义其类型。

eg：

定义一个坐标类Point{                             坐标的x和y可能有以下三种数据类型
      x;                                        x = 10，y =20;//int
      y;                                        x = "东经108度",y = "北纬39度" //String                                                 
}                                               x = 10.3,y = 30.2; //double

Object是Java中最高参数统一化，能接收所有的引用类型；有了包装类的自动拆箱之后，Object还能接受基本类型数值(自动拆箱)。--->Object可以接万物~

public class Pointer {
    private Object x;
    private Object y;
    
    public Object getX() {
        return x;
    }
    public void setX(Object x) {
        this.x = x;
    }
    public Object getY() {
        return y;
    }
    public void setY(Object y) {
        this.y = y;
    } 

    // 程序此时的要求是x和y在同一数据中是相同的类型
    public static void main(String[] args) {
        // 此时X和y都由用户进行输入
        // 第一组坐标类使用int来描述
        Pointer p1 = new Pointer();
        p1.setX(10);
        p1.setY(20);
        System.out.println("x = " + p1.getX() + ",y = " + p1.getY());
        // 第二组坐标类使用字符串来描述
        Pointer p2 = new Pointer();
        p2.setX("东经108度");
        p2.setY("北纬18度");
        System.out.println("x = " + p2.getX() + ",y = " + p2.getY());
    }
}

Object虽然可以接受所有类型，但是Object转为其他类型时都需要进行强制类型转换~ ***调用getX和getY方法时，需要根据具体的类型，将Object强转为具体的子类(隐藏的风险，这个风险是发生在运行阶段)

此时需要有一种新的机制，可以在定义类时，成员变量可以接收多种类型，但是在具体产生对象时明确类型，当有不同类型设置时，编译阶段就能发现错误。

JDK1.5引入时的泛型机制。所谓的泛型，就是我们在定义类或方法时，没有明确参数的类型，而是在使用该类时，明确类型。不需要进行类型强转，编译阶段就会在语法阶段检查类型是否匹配机制。类型的编译阶段守门员，不会让类型不匹配的问题进入到运行阶段！

3.泛型类的使用

3.1 语法

语法：类名称 <类型参数>{
   类型参数 成员变量名称;
}

类型参数用大写的英文字母来代替。

根据泛型类，来产生泛型对象！

泛型在定义时，可以不明确成员变量的类型，但是在产生对象时，必须明确类型。

Point<Integer> p = new Point<>();
泛型类<明确类型> 引用名称 = new 泛型类名称<>():
此时产生的是Integer类型的Point对象，所以X和y就会被定义为整型

3.2泛型类使用多个类型参数

假设x和y为不同类型时，可以使用多个类型参数~~~

泛型类名称<类型参数1,类型参数2,...>{
       类型参数1,变量x;
       类型参数2,变量y;
       // ...依此类推
}
public class newPoint<T,E>{
    pricate T x;
    private E y;
}

eg：产生newPoint对象，x和y就可以为不同的类型(也可以为相同类型)

public class NewPoint<T,E> {
    private T x;
    private E y;

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public E getY() {
        return y;
    }

    public void setY(E y) {
        this.y = y;
    }

    public static void main(String[] args) {
        // JDK中的泛型类，以Map集合为例
        Map<Integer,String> map = new HashMap<>();

        // 相同类型
        NewPoint<Integer,Integer> p = new NewPoint<>();
        p.setX(10);
        p.setY(20);
        // 不同类型
        NewPoint<Integer,String> p = new NewPoint<>();
        p.setX(10);
        p.setY("东经10度");
    }
}

总结：一般使用多个大写的字母来定义类型参数

T =》一般指代任何类

E =》一般代表元素Element和T意义差不多，也有使用E来指代异常的意思

身份证号，姓名： K和V一般搭配使用，描述一个键值对的对象，

K =》 key的意思，不重复的键值

V =》value的意思，可以重复