java泛型学习总结

泛型的本质是参数化类型，即所操作的数据类型被指定为一个参数。这种类型参数可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

在没有泛型的情况下，通过对类型Object的引用来实现参数的转换，这种转换是需要显式地强制类型转换，对于强制类型转换错误的情况，编译器可能不提示错误，而在运行时候却又通不过，这是一个安全隐患。可能给我们的开发带来了麻烦，难以找到运行时错误，增加不必要的精力开支，所以一般提倡使用泛型来实现参数化类型。

使用泛型的好处

1. 类型安全。泛型的主要目的就是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型 限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设只能我们自己记或者代码注释；

2. 消除强制类型转换。泛型一个附带好处是，消除代码中许多强制类型的转换。减少代码出错率，更好阅读；

3. 潜在的性能收益。可以带来更好的优化可能。在泛型的初始实现中，编译器强制类型转换（没有泛型的话，程序员会指定这些强制类型转换，）插入生成的字节码中。但是更多类型信息可用于编译器这一事实，为以后的JVM可以带来更好的优化。由于泛型的实现方式，支持泛型几乎不需要JVM或类文件更改，所有工作都在编译器中完成，编译器生成的类没有泛型（和强制类型转换），只是来确保数据类型安全；

泛型的使用：

1.泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。
定义一个简单的泛型类如下：

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generics<T>{
      
  //key这个成员变量的类型为T,T的类型由外部指定  
  private T key;

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

  public T getKey(){
      //泛型方法getKey的返回值类型为T，T的类型由外部指定
      return key;
  }
}

注意：
泛型的类型参数只能是类类型（包括自定义类），不能是简单类型！
泛型的类型参数只能是类类型（包括自定义类），不能是简单类型！
泛型的类型参数只能是类类型（包括自定义类），不能是简单类型！
传入的实参类型需与泛型的类型参数类型相同，即为Integer.

public static void main(String args[]) {
     
	//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
	//传入的实参类型需与泛型的类型参数类型相同，即为Integer.
	Generics<Integer> genericInteger = new Generics<Integer>(123456);

	//传入的实参类型需与泛型的类型参数类型相同，即为String.
	Generics<String> genericString = new Generics<String>("key_vlaue");
	System.out.println("key is " + genericInteger.getKey());
	System.out.println("key is " + genericString.getKey());

  }

运行结果如下：

key is 123456
key is key_vlaue

定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
我们来看下面的例子：

 public static void main(String args[]) {
     

	Generics generic = new Generics("111111");
	Generics generic1 = new Generics(4444);
	Generics generic2 = new Generics(55.55);
	Generics generic3 = new Generics(false);
	System.out.println("key is " + generic.getKey());
	System.out.println("key is " + generic1.getKey());
	System.out.println("key is " + generic2.getKey());
	System.out.println("key is " + generic3.getKey());

  }

运行结果如下：

key is 111111
key is 4444
key is 55.55
key is false

还有一点就是不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错
例如下面的操作是非法的：

	Generics generic = new Generics("111111");
	if(generic instanceof Generics<String>) {
     
		System.out.println("sss");
	}

但是用通配符就可以，例如下面的操作是和法的：

Generics generic = new Generics("111111");
	if(generic instanceof Generics<?>) {
     
		System.out.println("sss");
	}

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传入无数个实参，形成无数种类型的Generator接口。
在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型, 即：Generator，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.泛型方法：

在java中,泛型类的定义非常简单，但是泛型方法就比较复杂了。
尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，有的甚至泛型类中也包含着泛型方法，这样在初学者中非常容易将泛型方法理解错了。
泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
     
        T instance = tClass.newInstance();
        return instance;
}

泛型方法的基本介绍

• @param tClass 传入的泛型实参
• @return T 返回值为T类型
• 说明：

1. public 与 返回值中间非常重要，可以理解为声明此方法为泛型方法。
2. 只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
3. 表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
4. 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

我们来看一些例子，加强对泛型方法的理解：

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可以出现在这个泛型方法的任意位置.
     * 泛型的数量也可以为任意多个 
     *    如：public  K showKeyName(Generic container){
     *        ...
     *        }
     */
    public <T> T showKeyName(Generic<T> container){
     
        System.out.println("container key :" + container.getKey());
        //当然这个例子举的不太合适，只是为了说明泛型方法的特性。
        T test = container.getKey();
        return test;
    }
     /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
    public  T showKeyName(Generic container){
        ...
    }  
    */
 public <T> T showKeyName(Generic<E> container){
     
        ...
    }  
   /*
     * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' "
     * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。
     * 所以这也不是一个正确的泛型方法声明。
     * */
    public void showkey(T genericObj){
     

    }
    

   
}

类中的泛型方法：当然这并不是泛型方法的全部，泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的，当泛型方法出现在泛型类中时，我们再通过一个例子看一下

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相同，也可以不同。
        //由于泛型方法在声明的时候会声明泛型，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
        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);
    }
}

4.泛型的上下边界：

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

我们来看一个例子:为泛型添加上边界，即传入的类型实参必须是指定类型的子类型

public void showKeyValue1(Generic<? extends Number> obj){
     
    Log.d("泛型测试","key value is " + obj.getKey());
}

Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

//这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
//showKeyValue1(generic1); 
showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);

再来一个泛型方法的例子：

public <T extends Number> T showKeyName(Generic<T> container){
     
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的上添加上下边界，即在泛型声明的时候添加
public T showKeyName(Generic container)，编译器会报错："Unexpected bound"

参考链接