Java 泛型

1.概念

泛型在java中有很重要的地位，有广泛的应用，那么什么是泛型，简单理解为一种不确定的类型或者说参数化类型，将类型由原来的类型参数化，比如定义一个变量的时候指定String a，那么现在这个类型String也作为参数，然后在使用的时候传入具体的参数；

2.泛型的使用

泛型有三种使用方式，分别是泛型类，泛型接口和泛型方法。

1>泛型类

 泛型类用于类的定义，最常见的就是容器类，可以包含不同的对象，如List,Set,Map。基本语法格式：

class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  }
}

例如：

public class Generic<T> {
    private T key;

    public T getKey() {
        return key;
    }

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

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

注意，泛型的类型参数只能是类类型，不能是简单类型，这样的都是不可以的

另外，对应泛型类的时候不一定要传入实参，

Generic<Integer> genericInteger = new Generic<Integer>(123456);
        Generic genericString = new Generic("ssss");

这两种方式都是可以的，区别是：如果传入实参会进行限制，不传入实参那么里面放任何类型都是可以的；举个例子

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);

for(int i = 0; i< arrayList.size();i++){
    String item = (String)arrayList.get(i);
    Log.d("泛型测试","item = " + item);
}

这种情况就会报错，就是因为定义的时候没有限制泛型类型，然后再取出来的时候使用类型转换，导致报错，正确的做法是，在定义的时候就限制类型；

List<String> arrayList = new ArrayList<String>();
...
//arrayList.add(100); 在编译阶段，编译器就会报错

如果不需要做类型的转换，那么就不需要定义实际的类型，比如

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

2>泛型接口

泛型接口和泛型类的定义一样

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

当定义实现泛型的接口的类时，有两种情况，一种是传入实参，一种是不传入实参

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：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> {

3>通配符

先举个例子

package com.example.springbootDemo.service.arrayT;

public class ResultTest {
    public void showKeyValue1(Generic<Number> obj){
        System.out.println(obj.getKey());
    }


    public static void main(String[] args) {
        Generic<Integer> gInteger = new Generic<Integer>(123);
        Generic<Number> gNumber = new Generic<Number>(456);
        ResultTest resultTest = new ResultTest();
        resultTest.showKeyValue1(gNumber);
        resultTest.showKeyValue1(gInteger);
    }
}

这种情况，编译器就会报错的，提示类型不对；

那么这种情况怎么办那，总不能再定义一个方法?

public void showKeyValue1(Generic<Integer> obj){
        System.out.println(obj.getKey());
    }

这样也太low了吧，于是引入了通配符的概念"？",这样就可以了，如下所示

 public void showKeyValue1(Generic<?> obj){
        System.out.println(obj.getKey());
    }

这里的？代替了具体的类型实参，此处的？是实参，可以把？看成一种类型，是所有类型的父类；可以解决当类型不确定时的情况；如果想限制showKeyValue1的泛型是Number类型的，可以使用extends

 public void showKeyValue1(Generic<? extends Number> obj){
        System.out.println(obj.getKey());
    }

标识出入的类型，只能是Number的子类

4>泛型方法

先通过一些列子来了解下什么才是泛型方法

//这个类是个泛型类，在上面已经介绍过
   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做形参和返回值类型时，编译器会无法识别。正确的是在返回的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) {
    }}

另外，泛型方法在泛型类中的使用要注意一些情况，通过代码演示下：

package com.example.springbootDemo.service.arrayT;

public class GenericFruit {
    public 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());
        }
    }
}

然后通过main方法进行测试

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

5>.泛型方法和可变参数

通过一个简单例子了解下

public <T> void printMsg( T... args){
    for(T t : args){
        Log.d("泛型测试","t is " + t);
    }
}
printMsg("111",222,"aaaa","2323.4",55.55);

6>静态方法与泛型

静态方法是无法访问类上定义的泛型，如果静态方法操作的引用数据类型不确定的时候，必须将泛型定义在该方法上

public class StaticGenerator<T> {
    ....
    ....
    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }
}