泛型的使用（＜T＞）

文章目录

前言
一、泛型是什么？
二、泛型的使用
- 1.定义泛型类
- 2.泛型的常规用法
总结

前言

强制类型转换存在一定隐患，如数据丢失、内存溢出、运行时错误、程序逻辑错误等。所以提供了泛型机制，使程序员可以定义安全的数据类型进行操作。通俗的理解泛型，就是统一成员变量或者实例对象的数据类型，并且保障了其数据类型安全。

一、泛型是什么？

泛型是一种在编程语言中使用的概念，目的是让代码能够处理多种数据类型，而不仅仅是一种固定类型。通过使用泛型，可以编写更通用和灵活的代码，提高代码的可重用性和可读性。

在使用泛型时，可以定义一个或多个参数，这些参数可以代表不确定的数据类型。在代码实现中，可以使用这些参数表示各种不同的数据类型，从而实现相同的功能逻辑。

使用泛型可以避免在代码中重复编写相似的代码，同时还可以减少类型转换的错误和运行时错误。泛型的主要优势是在编译时进行类型检查，可以提前发现错误，而不是在运行时才发现。

二、泛型的使用

1.定义泛型类

泛型的语法机制如下：

泛型类名<T>

实操展示：

public class TestDemo<T> {  //定义泛型类
    private T testdemo; //定义泛型成员变量
    
    public void setT(T testdemo){   //设置set定值方法
        this.testdemo = testdemo;
    }

    public T getT(){    //设置get获值方法
        return testdemo;
    }

    //以上代码即，设置成员变量的泛型，使该泛型成员变量数据类型安全
    //以下为此泛型成员变量的使用，先创建实例，然后调用方法，设定或获得泛型成员变量的值
    public static void main(String[] args) {
        TestDemo<Integer> demo = new TestDemo<>();
        TestDemo<Double> demo2 = new TestDemo<>();

        demo.setT(1024);    //设定的Integer值为1024
        Integer integer = demo.getT();
        System.out.println(integer);

        demo2.setT(3.18);    //设定的Double值为3.18
        Double double1 = demo2.getT();
        System.out.println(double1);
        
    }
}

运行结果：

由图所示，定义泛型时，在泛型类中，创建私有泛型成员变量，通过创建set方法和get方法进行操作变量是常规的做法。

2.泛型类的常规用法

（1）定义泛型类时声明多个类型

在定义泛型类时，可以声明多个类型，这样实例化对象时，可以指定多个类型。具体语法如下：

泛型类名<T1,T2>

实操展示：

public class TestDemo<T,V> {  //定义泛型类
    private T testdemo; //定义泛型成员变量
    
    public void setT(T testdemo){   //设置set定值方法
        this.testdemo = testdemo;
    }

    public T getT(){    //设置get获值方法
        return testdemo;
    }

    private V testV;

    public void setV(V testV){
        this.testV=testV;
    }

    public V getV(){
        return testV;
    }

    public void set(V testV,T testT){
        this.testV = testV;
        this.testdemo = testT;
    }

    public void get(){
        System.out.println("两个值为："+testV+"和"+testdemo);
    }
    //以上代码即，设置了两个成员变量的泛型，使该泛型成员变量数据类型安全
    //以下为此泛型成员变量的使用，先创建实例，然后调用方法，设定或获得泛型成员变量的值
    public static void main(String[] args) {
        TestDemo<Integer,String> demo = new TestDemo<>();

        //泛型成员变量T
        demo.setT(12);
        Integer integer = demo.getT();
        System.out.println(integer);

        //泛型成员变量V
        demo.setV("这是一个字符串");
        String string = demo.getV();
        System.out.println(string);
        
        //设置获取两个泛型成员变量
        demo.set("字符串1", 10);
        demo.get();
    }
}

运行结果：

由上图所示，当定义了多个泛型<T>的泛型类，本质上我们可以在泛型类中定义多个泛型成员变量，可以进行使用。

（2）定义泛型类时声明数组类型

定义泛型类时，也可以声明数组类型。也算是避免了只定义一个泛型时，需要创建多个对象，重复实例化泛型类对象的冗杂。直接实例化一个泛型类对象，然后向数组中赋值即可。

实操展示：在项目中定义泛型类声明数组类型

public class TestDemo<T> {  //定义泛型类
    private T[] testdemo; //定义泛型成员变量(数组类型·)
    
    public void setT(T[] testdemo){   //设置set定值方法（数组类型）
        this.testdemo = testdemo;
    }

    public T[] getT(){    //设置get获值方法（数组类型）
        return testdemo;
    }

    public static void main(String[] args) {
        TestDemo<Integer> demo = new TestDemo<>();

        //定义泛型数组，成员变量
        Integer integer[] = {1024,512,256,128,64,32,16,8,4,2};  //创建对应类型的数组
        demo.setT(integer); //将该数组放入set方法中，设定值。
        System.out.println("该泛型类数组的值都有：");
        for(int i=0;i<integer.length;i++){
            System.out.println(demo.getT()[i]); //输出泛型数组中包含的各个值
        }

    }
}

运行结果：

如上代码所示，可以用泛型声明是数组的成员变量，但是不可以使用泛型类型建立数组的实例（使用new关键字的形式），那样的代码时错误的。

（3）集合类声明容器的元素

集合类如，ArrayList、HashMap、HashSet等集合类有事可以被泛型化的集合类，在我们学习它们的过程中也会看见。以下是这些集合类泛型的定义：

常用的被泛型化的集合类
集合类	泛型定义
ArrayList	ArrayList<E>
HashMap	HashMap<K,V>
HashSet	HashSet<E>
Vector	Vector<E>

如何使用泛型定义后的集合类请看下面的实操展示（HashMap为例）：

import java.util.HashMap;
import java.util.Map;    //导包
public class TestDemo{ 
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();    //使用泛型化集合
        
        for(int i=0;i<10;i++){    //定值
            map.put(i, "学员id:"+10+i);
        }

        for(int i=0;i<map.size();i++){    //取值
            System.out.println(map.get(i));
        }
    }
}

运行结果：