Java泛型详解：泛型类、泛型方法使用

转自：https://www.cnblogs.com/jpfss/p/9928747.html

一、泛型类定义及使用

public class Point<T> {
    private T x;
    private T y;

    public T getX() {
        return x;
    }

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

    public T getY() {
        return y;
    }

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

使用：

        Point<Integer> point = new Point<>();
        point.setX(100);
        System.out.println(point.getX());

1）、定义泛型：Point<T>

Point<T>即在类名后面加一个尖括号，括号里是一个大写字母。这里写的是T，其实这个字母可以是任何大写字母

2）、类中使用泛型

这个T表示派生自Object类的任何类，比如String、Integer、Double等等。这里要注意的是，T一定是派生于Object类的。为方便起见，大家可以在这里把T当成String，即String在类中怎么用，那T在类中就可以怎么用！所以下面的：定义变量，作为返回值，作为参数传入的定义就很容易理解了

    private T x;

    public T getX() {
        return x;
    }

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

3）、使用泛型类

首先，是构造一个实例：

        Point<Integer> point = new Point<>();

这里与普通构造类实例的不同之点在于，普通类构造函数是这样的：Point point = new Point();

而泛型类的构造则需要在类名后添加上<Integer>，即一对尖括号，中间写上要传入的类型

因为我们构造时，是这样的：class Point<T>，所以在使用的时候也要在Point后加上类型来定义T代表的意义

然后在getVar()和setVar()时就没有什么特殊的了，直接调用即可

从上面的使用时，明显可以看出泛型的作用，在构造泛型类的实例的时候：尖括号中，你传进去的是什么，T就代表什么类型。这就是泛型的最大作用，我们只需要考虑逻辑实现，就能拿给各种类来用

4）、使用泛型实现的优势

相比使用Object的方式，有两个优点：

1）不用强制转换

        //使用Object作为返回值,要强制转换成指定类型  
        Float floatX = (Float) point.getX();

        //使用泛型时,不用强制转换,直接出来就是Integer
        System.out.println(point.getX());

2）在setVar()时如果传入类型不对，编译时会报错

二、多泛型变量定义及字母规范

1）、多泛型变量定义

public class MorePoint<T, U> {
    private T x;
    private T y;
    private U name;

    public T getX() {
        return x;
    }

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

    public T getY() {
        return y;
    }

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

    public U getName() {
        return name;
    }

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

使用：

        MorePoint<Integer, String> morePoint = new MorePoint<>();
        morePoint.setName("hello world");
        System.out.println(morePoint.getName());

2）、字母规范

在定义泛型类时，我们已经提到用于指定泛型的变量是一个大写字母

其实任意一个大写字母都可以。他们的意义是完全相同的，但为了提高可读性，大家还是用有意义的字母比较好，一般来讲，在不同的情境下使用的字母意义如下：

• E——Element，常用在Java Collection里，如：List<E>、Iterator<E>、Set<E>
• K、V——Key、Value，代表Map的键值对
• N——Number，数字
• T——Type，类型，如String，Integer等等

三、泛型接口定义及使用

//在接口上定义泛型
public interface Info<T> {

    //定义抽象方法,抽象方法的返回值就是泛型类型
    T getVar();

    void setVar(T t);
}

public class InfoImpl implements Info<String> {
    @Override
    public String getVar() {
        return null;
    }

    @Override
    public void setVar(String str) {

    }
}

四、泛型函数定义及使用

    //静态函数  
    public static <T> void staticMethod(T t) {

    }

    //普通函数  
    public <T> void otherMethod(T t) {

    }

使用方法：

        //静态方法
        StaticFans.staticMethod("hello world");
        StaticFans.<String>staticMethod("hello world");

        //常规方法
        StaticFans staticFans = new StaticFans();
        staticFans.otherMethod("hello world");
        staticFans.<String>otherMethod("hello world");

五、其它用法：Class<T>类传递及泛型数组

1）、使用Class<T>传递泛型类Class对象

    public static <T> List<T> parseArray(String response, Class<T> clazz) {
        return JSON.parseArray(response, clazz);
    }

2）、定义泛型数组

    //接收可变参数
    public static <T> T[] fun(T... arg) {
        //返回泛型数组
        return arg;
    }