java 反射的基础学习

1.Class类
1) 在面向对象的世界里，万事万物皆对象
  java语言中，静态的成员，普通数据类型不是对象
   类是对象，是java.lang.Class类的实例对象


2)任何一个类都是Class的实例对象，这个实例对象有三种表示方法
Class c1 = Foo.class;
Class c2 = foo1.getClass();
Class c3 = Class.forName("反射.Foo");//类的动态加载

我们完全可以通过类的类类型创建该类的对象实例--->通过c1 or c2 or c3创建Foo的实例
Foo foo = (Foo) c1.newInstance();// 需要有无参数的构造方法

动态加载类
3) Class.forName("类的全称")
不仅表示了类的类类型，还代表了动态加载列
要区分编译、运行
编译时刻加载类是静态加载类，运行时刻加载类是动态加载类

new 创建对象是静态加载类，在编译时刻就需要加载所有的可能使用到的类
通过动态加载类可以解决静态加载类的弊端
Class.forName()是动态加载的,一个工具的类，尽可能使用动态加载(Office)

4) 基本的数据类型
void关键字 都存在类类型，如 int.class

5) Class类的基本API操作

public class ClassUtil {
	/**
	 * 获取成员方法 public
	 * @param obj
	 */
	public static void printClassMessage(Object obj) {
		// 要获取类的信息 首先要获取类的类类型
		Class class1 = obj.getClass();
		System.out.println("类的名称" + class1.getName());
		// Method类，方法对象，一个成员方法就是一个Method对象
		Method[] ms = class1.getMethods();// 获取所有的public的方法,包括父类继承而来的
		// class1.getDeclaredMethods();// 获取所有自己声明的方法，不问访问权限，不包括父类继承而来的
		for (int i = 0; i < ms.length; i++) {
			Class returnType = ms[i].getReturnType();// 得到方法的返回值类型的类类型
			System.out.print(returnType.getName() + " ");
			System.out.print(ms[i].getName() + "(");// 得到方法的名称
			// 获取参数类型
			Class[] paramTypes = ms[i].getParameterTypes();// 得到的是参数列表的类型的类类型
			for (Class class2 : paramTypes) {
				System.out.print(class2.getName() + ",");
			}
			System.out.println(")");
		}
	}

	/**
	 * 打印对象的成员变量方法
	 * @param obj
	 */
	public static void printFieldMessage(Object obj) {
		Class<?> class1 = obj.getClass();
		/**
		 * 成员变量也是对象 java.lang.reflect.Field Field类封装了关于成员变量的操作
		 * getFields()方法获取的是所有的public的成员变量的信息 getDeclaredFields获取的该类自己生命的成员变量的信息
		 */
		// Field[] fs=class1.getFields();
		Field[] fields = class1.getDeclaredFields();
		for (Field f : fields) {
			// 得到成员变量的类型的类类型
			Class<?> type = f.getType();
			// 得到成员变量的名称
			String name = f.getName();
			// 得到成员变量类类型的名称
			String typeName = type.getName();
			System.out.println(typeName + " " + name);
		}
	}

	/**
	 * 打印对象的构造函数信息
	 * @param obj
	 */
	public static void printConMessage(Object obj) {
		Class<?> class1 = obj.getClass();
		/**
		 * 构造方法也是对象 java.lang.Constructor中封装了构造方法的信息
		 * getConstructors获取所有的public的构造方法 getDeclaredConstructors得到所有的构造方法
		 */
		// Constructor<?>[] constructors = class1.getConstructors();
		Constructor<?>[] declaredConstructors = class1.getDeclaredConstructors();
		for (Constructor<?> c : declaredConstructors) {
			System.out.print(c.getName() + "(");
			Class<?>[] parameterTypes = c.getParameterTypes();
			for (Class<?> class2 : parameterTypes) {
				System.out.print(class2.getName() + ",");
			}
			System.out.println(")");
		}

	}
}

public class MethodDemo1 {
	public static void main(String[] args) {
		// 要获取print(int,int)方法 1.要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
		Class<?> class1 = A.class;
		// 2.获取方法'名称和参数列表来决定
		// getMethod获取的是public的方法
		// getDeclaredMethod自己声明的方法
		try {
			Method method = class1.getMethod("print", int.class, int.class);
			// 方法的反射操作是用method来进行调用

			// 方法如果没有方绘制返回null，有放回值返回具体的返回值
			Object invoke = method.invoke(new A(), 10, 20);
			System.out.println("==============");
			Method method2 = class1.getMethod("print", String.class, String.class);
			Object invoke2 = method2.invoke(new A(), "hello", "world");
			System.out.println("==============");
			Method method3 = class1.getMethod("print");
			method3.invoke(new A());

		} catch (Exception e) {
		}
	}
}

class A {
	public void print() {
		System.out.println("helloworld");
	}

	public void print(int a, int b) {
		System.out.println(a + b);
	}

	public void print(String a, String b) {
		System.out.println(a.toUpperCase() + "," + b.toLowerCase());
	}
}

通过Class Method来认识泛型的本质

public static void main(String[] args) {
		ArrayList list = new ArrayList();

		ArrayList<String> list2 = new ArrayList<String>();
		list2.add("adsf");
		Class class1 = list.getClass();
		Class class2 = list2.getClass();
		System.out.println(class1 == class2);
		// 反射的操作都是编译之后的操作
		/*
		 * c1==c2结果返回true,说明编译之后集合的泛型是去泛型化的 Java中集合的泛型，是防止错误输入的，志在编译阶段有效，
		 * 绕过编译就无效了 验证：我们可以通过方法的反射来操作，绕过编译
		 */
		try {
			Method method = class1.getMethod("add", Object.class);
			method.invoke(list2, 100);// 绕过编译操作就扫过泛型
			System.out.println(list2.size());
		} catch (Exception e) {
		}
	}