泛型详解(未完待续)

最新推荐文章于 2024-06-11 08:40:59 发布

湛蓝蜗牛

最新推荐文章于 2024-06-11 08:40:59 发布

阅读量537

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/MichaelSuns/article/details/106634954

版权

Java 专栏收录该内容

26 篇文章 1 订阅

订阅专栏

1.前言
本文旨在介绍泛型这一概念，力图在现有知识水平基础上对泛型的概念、原理以及使用有一个完整全面准确深刻的理解。但因本人水平有限，不足之处敬请指正，万分感谢。如果觉得本文对您有所帮助或启发，还望不吝三连（点赞收藏转发）。另外需要申明一点，本文力图让读者能看懂理解泛型的概念及用法，绝对干货，但请务必耐心看完。
2.什么是泛型？
关于泛型这一概念，网上不乏技术大牛各种深度剖析的文章博客，本文力图在前辈经验的基础上对泛型有一个深入浅出的解释，能让大多数人理解透彻。
在进入讲解之前我们先看一下泛型这一概念涵盖的主要内容：图片来源（https://www.jianshu.com/p/986f732ed2f1）
Java泛型详解
OK，下面进入正题。何为泛型？
其实泛型的概念到处都是而且用的大都是这一个解释：

泛型，即参数化类型。就是将类型由原来的具体的String或者Integer等加以参数化，类似于方法中的形参和实参。泛型在声明时（类也好，方法也好，接口也罢，原理都是通的），小括号内定义一个形参（这时候的形参不需要给指定数据类型，因为它本身就是一个待传的数据类型变量），当我们具体使用时，传入一个实参，只不过这里传入的实参跟我们一般意义上的实参有一定区别。这里的“实参”指的是String、Integer等数据类型。

举个例子：public class Generator{}//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型

一些常用的泛型类型变量：
	E：元素（Element），多用于java集合框架
	K：关键字（Key）
	N：数字（Number）
	T：类型（Type）
	V：值（Value）

以上面这个泛型类为例，我们在用的时候直接使用这个类进行实例化，将尖括号中的T替换成你想用的数据类型即可。接下来就可以根据该类中的getset方法来处理对应的属性值了。本质上来说，当我们给泛型类传入了一个数据类型参数之后，它的用法跟我们以往Student等实体类的用法是一样的。

下面是广泛流传的版本（本质上一样的，可选择好理解的来看）。

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？
顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，
操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

**2、**为什么使用泛型？（泛型的存在意义）
代码复用 类型安全
关键是类型的参数化，就是可以把类型向方法的参数那样传递。
泛型使编译器可以在编译期间对类型进行检查以提高类型安全，减少运行时由于对象类型不匹配引发的异常。
简单来说就是：

1,适用于多种数据类型执行相同的代码（代码复用）
2, 泛型中的类型在使用时指定，不需要强制类型转换（类型安全，编译器会检查类型

还是举一个栗子，众所周知，数组在存放数据之前要先指定数据类型，而ArrayList、HashMap、TreeSet等容器类可以存入任何类型的对象并且还能对对象进行get、set、sort之类的操作，这种情况下势必要明确究竟存入的是何种类型对象。考虑到程序员可能放入任何类型，所以在这些容器设计之初设计成的是存放Object类型对象，因为Java中Object是根类。

public class ListContainer {

private Object obj;

public Object getObj() {

return obj;

}

public void setObj(Object obj) {

this.obj = obj;

}

}

以上，根据多态，容器可以存放任何类型的对象，但是取出的时候要进行强制类型转换，转换成实际对应的类型。但这样会造成很多类型不安全问题，因为编译器无法辅助进行类型检查，类型转换问题只能有程序员自己掌控，记住每种对象对应的是什么类型，当对象类型过多时，就容易造成类型转换错误，导致代码在运行时易于出现ClassCastException异常。

当使用了泛型：

public class ListContainer<T> {

private T t;

public T getObj() {

return t;

}

public void setObj(T t) {

this.t= t;

}

}

T就是类型参数，由程序员在开发过程中用到时再确定。
如：

ListContainer<Dog> myCon=new ListContainer<Dog>();

此时编译器就能知道，ListContainer容器是存放Dog类型对象的，并能进行类型检查。此时如果再往myCon中存其它数据类型就会提示类型错误。如此一来，程序员不用再自己去记忆不同对象的对应数据类型，也不必担心出现类型转换异常的问题。
3、泛型的使用
3.1 泛型类

public class Generic<T> {

    private T key;//key的类型为T，由外部指定

    public Generator(T key) {//构造方法，key的类型为T，由外部指定
        this.key = key;
    }

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }
}

泛型类的使用：
使用前传参，确定数据类型：

//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
Generic<Integer> genericInteger = new Generic<Integer>(123456);

//传入的实参类型需与泛型的类型参数类型相同，即为String.
Generic<String> genericString = new Generic<String>("key_vlaue");
Log.d("泛型测试","key is " + genericInteger.getKey());
Log.d("泛型测试","key is " + genericString.getKey());

使用前不传参，灵活数据类型：

Generic generic = new Generic("111111");
Generic generic1 = new Generic(4444);
Generic generic2 = new Generic(55.55);
Generic generic3 = new Generic(false);

Log.d("泛型测试","key is " + generic.getKey());
Log.d("泛型测试","key is " + generic1.getKey());
Log.d("泛型测试","key is " + generic2.getKey());
Log.d("泛型测试","key is " + generic3.getKey());

注：泛型类的参数只能是类类型，不能是简单数据类型。如可以使Integer、Short等，但不能是int、short等；不能对确切的泛型类型使用instanceof操作。如：if(genericInteger instanceof Generic<Integer>){} 这种写法是错误的

3.2 泛型接口

//定义一个泛型接口
public interface Generator<T> {
    public T test();//随便定义一个抽象方法,没有也无所谓
}

泛型接口的使用
接口实现类两种使用方式：
一、未传入泛型实参

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class FruitGenerator<T> implements Generator<T>{
 * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

二、传入泛型实参

/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
 */
public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

3.3 泛型方法

总的来说泛型方法有两种情况：
一种是在普通类中生命的泛型方法，另一种是在泛型类中生命的泛型方法，需要特别注意的是，在泛型类中有一种方法虽然与泛型方法类似，但本质上有很大区别，具体代码实例如下：

public class GenericTest {
   //这个类是个泛型类，在上面已经介绍过
   public class Generic<T>{     
        private T key;

        public Generic(T key) {
            this.key = key;
        }

        //我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。
        //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
        //所以在这个方法中才可以继续使用 T 这个泛型。
        public T getKey(){
            return key;
        }

        /**
         * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
         * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
        public E setKey(E key){
             this.key = keu
        }
        */
    }

    /** 
     * 这才是一个真正的泛型方法。
     * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
     * 这个T可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个 
     *    如：public <T,K> K showKeyName(Generic<T> container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    }

    //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。
    public void showKeyValue1(Generic<Number> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }

    //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符?
    //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类
    public void showKeyValue2(Generic<?> obj){
        Log.d("泛型测试","key value is " + obj.getKey());
    }

     /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
    public <T> T showKeyName(Generic<E> container){
        ...
    }  
    */

    /**
     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
    public void showkey(T genericObj){

    }
    */

    public static void main(String[] args) {


    }
}

下面是泛型类中使用泛型方法的正确用法：

public class GenericFruit {
    class Fruit{
        @Override
        public String toString() {
            return "fruit";
        }
    }

    class Apple extends Fruit{
        @Override
        public String toString() {
            return "apple";
        }
    }

    class Person{
        @Override
        public String toString() {
            return "Person";
        }
    }

    class GenerateTest<T>{
        public void show_1(T t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        public <E> void show_3(E t){
            System.out.println(t.toString());
        }

        //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
        public <T> void show_2(T t){
            System.out.println(t.toString());
        }
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();

        GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
        //apple是Fruit的子类，所以这里可以
        generateTest.show_1(apple);
        //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        //generateTest.show_1(person);

        //使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);

        //使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

静态方法与泛型：

public class StaticGenerator<T> {
    ....
    ....
    /**
     *静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：
     *静态方法无法访问类上定义的泛型；
     *如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。
	 *即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。
	 
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}

小结：
使用泛型方法主要需注意这样几个点：
（1）泛型方法要是用的泛型必须在方法声明的同时进行声明，即：

 public  <T> void show(T t){}

否则，形参中的泛型不能使用，或者该方法不能被作为泛型方法调用；
（2）在泛型类中声明方法时可以直接使用泛型类所声明的泛型，但此时生命的方法不是泛型方法，换句话说，它的入参类型要跟随泛型类的泛型实参来决定。
（3）如果要在一个静态方法中使用泛型，那么该静态方法必须被声明为静态泛型方法，普通静态方法不能访问类上定义的泛型。换言之，如果静态方法操作的引用数据类型不确定时，必须姜范兴定义在方法上。

4、泛型通配符（针对泛型类）

public class Test {
    public  void showKeyValueNum(Generator1<Number> num){
        System.out.println("Number泛型测试:key为："+num.getKey());
    }

    public  void showKeyValueInt(Generator1<Integer> in){
        System.out.println("Integer泛型测试:key为："+in.getKey());
    }

    public static void main(String[] args) {
        Generator1<Integer> in = new Generator1<Integer>(123);
        Generator1<Number> num = new Generator1<Number>(456);

        Test test = new Test();
        test.showKeyValueInt(in);
        test.showKeyValueNum(num);
        test.showKeyValueNum(in);//该行报错
    }
}

类型不匹配
为解决以上问题又符合Java的多态理论，引入了类型通配符。在这个问题中他可以在逻辑上可以表示同时是Generic 和Generic父类的引用类型。
故此，将方法修改为：

 public void showKeyValueParent(Generator1<?> parent){
        System.out.println("通配符泛型测试：key为"+parent.getKey());
    }

以上方法中的问号“?”，就是泛型通配符

需要注意的是：泛型通配符的问号代表的是类型实参，而不是类型形参！这里的？和Integer、String、Number一样，都是一种实际类型，可以把“?” 看成所有类型的父类。当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

通配符小结：
（1）<? extends Parent> 指定了泛型类型的上届
（2）<? super Child> 指定了泛型类型的下届
（3）<?> 指定了没有限制的泛型类型

5、限定泛型类型变量——泛型上下边界

在使用泛型时，我们会有这种需求：需要指定泛型的类型范围。有界类型就是在类型参数部分指定extends或super关键字，这里的extends也含有implements的功能，分别用上限或下限来限制类型范围，从而限制泛型的类型边界。例如：

<T extends Animal>//限定T是Animal的子类

<T super Dog >//限定T是Dog的超类

上下边界就是类型实参只允许传入某种类型的父类或子类。为泛型添加上边界，也就是传入的类型实参必须是指定类型的子类型。
（1）对类的限定：public class TypeLimitForClass<T extends List & Serializable>{}
（2）对方法的限定：public static<T extends Comparable>T getMin(T a, T b) {}

6、使用泛型时的注意事项
（1）不能实例化泛型类
（2）静态变量或方法不能引用泛型类型变量，但是静态泛型方法是可以的
（3）基本类型无法作为泛型类型
（4）无法使用instanceof关键字或==判断泛型类的类型
（5）泛型类的原生类型与所传递的泛型无关，无论传递什么类型，原生类是一样的
（6）泛型数组可以声明但无法实例化
（7）泛型类不能继承Exception或者Throwable
（8）不能捕获泛型类型限定的异常但可以将泛型限定的异常抛出

7、泛型类型的继承规则

（1）对于泛型参数有上下界限定的泛型类之间是没有继承关系的；
（2）泛型类可以继承其他泛型类，泛型类的继承关系在使用过程中同样受到泛型类型的影响。

8、获取泛型的参数类型

Type是什么？
这里的Type指java.lang.reflect.Type, 是Java中所有类型的公共高级接口, 代表了Java中的所有类型. Type体系中类型的包括：数组类型(GenericArrayType)、参数化类型(ParameterizedType)、类型变量(TypeVariable)、通配符类型(WildcardType)、原始类型(Class)、基本类型(Class), 以上这些类型都实现Type接口.

参数化类型,就是我们平常所用到的泛型List、Map；数组类型,并不是我们工作中所使用的数组String[] 、byte[]，而是带有泛型的数组，即T[] ；通配符类型, 指的是<?>, <?extends T>等等原始类型,不仅仅包含我们平常所指的类，还包括枚举、数组、注解等；基本类型, 也就是我们所说的java的基本类型，即int,float,double等