泛型与反射

1、泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。参数化类型就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
1）泛型类定义及使用
//定义
class Point{// 此处可以随便写标识符号
private T x ;
private T y ;
public void setX(T x){//作为参数
this.x = x ;
}
public void setY(T y){
this.y = y ;
}
public T getX(){//作为返回值
return this.x ;
}
public T getY(){
return this.y ;
}
};
//IntegerPoint使用
Point p = new Point() ;
p.setX(new Integer(100)) ;
System.out.println(p.getX());

//FloatPoint使用
Point p = new Point() ;
p.setX(new Float(100.12f)) ;
System.out.println(p.getX());
2）关于泛型的使用实例
1，成功与否。对应属性success。
2，异常信息。对应属性ex。若是操作正常执行，则就不在意这个属性的值。
3，我们操作的最终目的对象。对应属性obj。
import lombok.Data;

@Data
public class MultiObject {

/**
 * 成功状态
 */
private boolean success;

/**
 * 异常
 */
private Exception ex;

/**
 * 数据
 */
private T obj;

public MultiObject() {
}
/**
 * 注意：当传入的泛型是Boolean时，就和第三个构造函数冲突了。
 */
public MultiObject(boolean success) {
	this.success = success;
}
	public MultiObject(Exception ex) {
	this.success = false;
	this.ex = ex;
}
	public MultiObject(T value) {
	this.success = true;
	this.obj = value;
}

}
/**
* 将Json字符串信息转换成对应的Java对象
* @param json json字符串对象
* @param c 对应的类型
*/
public static T parseJsonToObj(String json, Class c) {
try {
JSONObject jsonObject = JSONObject.parseObject(json);
return JSON.toJavaObject(jsonObject, c);
} catch (Exception e) {
LOG.error(e.getMessage());
}
return null;}

2、反射就是把java类中的各种成分映射成一个个的Java对象。例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。
1）得到某个对象的属性public Object getProperty(Object owner, String fieldName) throws Exception {
Class ownerClass = owner.getClass(); //得到该对象的Class

Field field = ownerClass.getField(fieldName);// 通过Class得到类声明的属性
Object property = field.get(owner); //通过对象得到该属性的实例

 return property;

}
2）得到某个类的静态属性
public Object getStaticProperty(String className, String fieldName)
throws Exception {
Class ownerClass = Class.forName(className); //首先得到这个类的Class。
Field field = ownerClass.getField(fieldName); //和上面一样，通过Class得到类声明的属性 Object property = field.get(ownerClass); // 因为该属性是静态的，所以直接从类的Class里取
return property;
}
3）执行某对象的方法
public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
Class ownerClass = owner.getClass();
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
}

 Method method = ownerClass.getMethod(methodName, argsClass);// 通过Method名和参数的Class数组得到要执行的Method。    

return method.invoke(owner, args);// 执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。
}
4）执行某个类的静态方法
public Object invokeStaticMethod(String className, String methodName,
Object[] args) throws Exception {
Class ownerClass = Class.forName(className);

  Class[] argsClass = new Class[args.length];

 for (int i = 0, j = args.length; i < j; i++) {
      argsClass[i] = args[i].getClass();
  } 
Method method = ownerClass.getMethod(methodName, argsClass);

return method.invoke(null, args);

}
5）新建实例
public Object newInstance(String className, Object[] args) throws Exception {
Class newoneClass = Class.forName(className);
Class[] argsClass = new Class[args.length]; //得到参数的Class数组
for (int i = 0, j = args.length; i < j; i++) {
argsClass[i] = args[i].getClass();
} Constructor cons = newoneClass.getConstructor(argsClass); //得到构造子
return cons.newInstance(args); //新建实例
}