对java泛型的理解

　　正确的应用java泛型的特性可以更好的实现编程的开闭原则（对扩展开放，对修改关闭），这得益于java泛型提供的在程序运行时获取对象声明类型的特性。

 

　　静态语言的特性是在程序编译前进行声明，这样程序在编译期就能很方便的获取变量的类型。动态语言提供了程序在运行时获取对象声明类型的特性，具有更好的扩展性，java是一门动态语言。

 

　　一个对象可以被理解为一个变量的实例。一个对象能够被加载的前提是有确定的声明，同时只要获取到对象就可以获取到确定的声明类型。所以，泛型编程必须满足以下两点：

　　1，程序必须在运行期能够得到确定的声明。

　　2，获取对象之后才可以获取到对象的声明类型。

 

　　下面给出三种声明方式，以及相对应的运行阶段获取对象类型的方法。The Code Shows Everything, Let's go~

 

　　第一类：简单声明

　　

public class Bean<T> {

    T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
    
    
}

　　第二类：父类声明

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class ExtendGeneral<T> {  
    
    Class<T> t;
    
    public void aaa(){
        Type superClassGenricType = getSuperClassGenricType(getClass(), 0);
        System.out.println(getClass());
        System.out.println(t);
        t = (Class<T>) superClassGenricType;
        System.out.println(t);
        
    }
    
    
    public static Type getSuperClassGenricType(Class clazz, int index) {  
          
        //返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type。  
        Type genType = clazz.getGenericSuperclass();  
  
        //返回表示此类型实际类型参数的 Type 对象的数组。  
        Type[] params = ((ParameterizedType) genType).getActualTypeArguments();  
  
        return  params[index];
    }  
    
}

public class Test1 extends ExtendGeneral<String>{

}

　　第三类，接口声明

public interface InterGeneral<A, B> {

    <B> B aaa(A a);
}

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;

public class Test2 implements InterGeneral<String, HashMap>{

    @Override
    public HashMap aaa(String a) {
        Type[] genericSuperclass = getClass().getGenericInterfaces();
        ParameterizedType type = (ParameterizedType)genericSuperclass[0];
        Type[] actualTypeArguments = type.getActualTypeArguments();
        System.out.println(actualTypeArguments[0]);
        System.out.println(actualTypeArguments[1]);
        return null;
    }

}

　　main方法：

public class Main {
    public static void main(String[] args) {
        
        System.out.println("简单声明泛型：");
        Bean<String> b = new Bean<String>();
        b.setT("333");
        String t = b.getT();
        System.out.println(t);
        
        System.out.println("继承声明泛型：");
        Test1 t1 = new Test1();
        t1.aaa();
        
        System.out.println("接口声明泛型：");
        Test2 t2 = new Test2();
        t2.aaa("");
        
    }

}

　　输出结果：

　

简单声明泛型：
333
继承声明泛型：
class com.asiainfo.base.T.Test1
null
class java.lang.String
接口声明泛型：
class java.lang.String
class java.util.HashMap

　　Type类是一个接口，是所有Class的超类。