public class ClassDemo1 {
	
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
		//Foo的实例对象如何表示
		Foo foo1=new Foo();//foo1就表示出来了
		//Foo这个类 也是一个实例对象，Class类的实例对象如何表示
		//任何一个类都是Class类的实例对象，这个实例对象有3中表示方式
		
		/*第一种表示方式--》实际在告诉我们任何一个类都有一个隐含的静态成员变量*/
		Class c1=Foo.class;
		
		/*第二种表达方式：已知该类的对象，通过getClass方法*/
		Class c2=foo1.getClass();
		
		/*官网：c1/c2表示了Foo类的类类型（class type）
		 * 类也是对象，是class类的实例对象
		 * 这个对象我们成为该类的类类型
		 * */
		
		/*不管c1 or c2都代表了Foo类的类类型，一个类只可能是Class类的一个对象*/
		System.out.println(c1==c2);//true
		
		//第三种表达方式
		Class c3=null;
		c3=Class.forName("ShuiTian.NaiLuo.Reflect.Foo");
		System.out.println(c3);
		
		/*我们完全可以通过类的类类型创建该类的对象
		 * 通过c1 or c2 or c3创建父的实例
		 * 
		 * */
		Foo foo=(Foo)c1.newInstance();//使用newInstance需要有无参数的构造方法		
	}
}

class Foo{}

public class DynamicLoadClass {

	public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
		String animalName="Cat";
		Animal animal = null;
		switch (animalName){
		case "Cat":
			animal=(Animal)Class.forName("ShuiTian.NaiLuo.Reflect.Cat").newInstance();
			break;
		case "Dog":
			animal=(Animal)Class.forName("ShuiTian.NaiLuo.Reflect.Dog").newInstance();
			break;
		}
		System.out.println(animal);
		System.out.println(animal.getClass().getSimpleName());
	}
}

interface Animal{}
class Cat implements Animal{}
class Dog implements Animal{}

/*
	 * 打印类的信息，包括类的成员函数，类的成员变量 参数是一个对象，该对象的所属信息
	 */
	public static void printClassMethodMessage(Object obj) {
		// 要获取类的信息，首先要获取类的类类型 class type
		Class c = obj.getClass();// 传递的是哪个子类的对象
		// 获取类的名称
		System.out.println(c.getName());
		/*
		 * Method类是方法对象 一个成员方法就是一个Method对象 getMethods获取的是所有的public函数，包括从父类继承而来的
		 * c.getDeclaredMethods()获取的是所有该类声明的方法，不问访问权限
		 */
		Method[] ms = c.getMethods();  //获取类的方法数组
		for (Method method : ms) { //对类的方法数组进行循环，在循环中获取函数返回值信息及参数信息，也可以对方法进行动态调用
			// 得到方法的返回值类型的类类型
			Class returnType = method.getReturnType();
			System.out.print(returnType.getName() + "(");
			// 得到方法的名称
			System.out.print(method.getName());
			// 获取方法的参数类型--->得到的是参数列表的类型的类类型
			Class[] paramTypes = method.getParameterTypes();
			for (Class c1 : paramTypes) {
				System.out.print(c1.getName() + ",");
			}
			System.out.println(")");
		}

		printFieldMessage(obj);

	}

/*获取类的field信息*/
	public static void printFieldMessage(Object obj) {
		Class c=obj.getClass();
		/*
		 * 成员变量也是对象 java.lang.reflect.field Field类封装了关于成员变量的操作
		 * getFields方法获取的是所有public成员变量的信息 getDeclaredFields获取的是该类自己声明的成员
		 */
		Field[] fs = c.getDeclaredFields();
		for (Field field : fs) {
			/* 得到成员变量的类类类型 */
			Class fieldType = field.getType();
			String typeName = fieldType.getName();

			/* 得到成员变量的名称 */
			String fieldName = field.getName();
			System.out.println(fieldType + "," + fieldName);
		}
	}

/*打印对象的构造函数的信息*/
	public static void printConMessage(Object obj){
		Class c=obj.getClass();
		/*
		 * java.lang.constructors封装了构造函数的信息
		 * getConstructors()获取了所有的public的构造函数的信息
		 * getDeclaredConstructors:得到了自己声明的构造函数
		 * */
		Constructor[] cs =c.getDeclaredConstructors(); //获取构造函数数组
		for(Constructor con :cs ){  //分别对各个构造函数进行遍历
			System.out.print(con.getName()+"(");
			//获取构造函数的参数列表----得到的是参数列表的类类型
			Class[] paramTypes=con.getParameterTypes();  //得到构造函数的参数列表
			for(Class param:paramTypes){
				System.out.print(param.getName()+",");
			}
			System.out.println(")");
		}
	}

/*
 * 测试方法的反射
 * 
 * */
public class MethodDemo1 {
	public static void main(String[] args) throws InstantiationException,
			IllegalAccessException, ClassNotFoundException,
			NoSuchMethodException, SecurityException, IllegalArgumentException,
			InvocationTargetException {

		// 获取print（int,int）方法
		Class a = Class.forName("ShuiTian.NaiLuo.Reflect.A");
		/*
		 * 获取方法名称，参数列表。。。 getMethod:获取的是public的方法 getDeclaredMethod:获得的是自己声明的方法
		 */
		Method m = a.getMethod("print", new Class[] { int.class, int.class });
		/*
		 * 方法的反射操作 使用m对象来进行方法的调用 方法返回值问题 1，无返回值返回null 2，有返回值，返回具体值
		 */
		m.invoke(a.newInstance(), 10, 10);
		// m.invoke(a,10,10);
		System.out.println("==========分割线============");
		Method m2 = a.getMethod("print", String.class, String.class);
		m2.invoke(a.newInstance(), "lhc", "水田");
	}
}

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