反射

反射

 Class
         package com.hpu.lianxi;

public class ClassDemo {
         public static void main(String[] args) {
			Foo foo = new Foo();//Foo的实例对象
			/*
			 * 任何一个类都是Class的实例对象，这个实例对象有三种表示方式
			 * */
			//第一种表示方式，告诉我们任何一个类都有一个隐含的静态成员变量class
			Class c1=Foo.class;
			//第二种表达方式 已经知道该类的对象通过getClass方法
			Class c2 = foo.getClass();
			//一个类只可能是Class的一个实例对象
			System.out.println(c1 == c2);
			
			//第三种表达方式
			Class c3 =null;
			
			try {
				c3 = Class.forName("com.hpu.lianxi.Foo");
			} catch (ClassNotFoundException e){
				e.printStackTrace();
			}
			System.out.println(c2 == c3);
			
			try {
				Foo foo1 = (Foo) c1.newInstance();//需要有无参数的构造方法
			    foo1.print();
			} catch (InstantiationException e) {
				e.printStackTrace();
			} catch (IllegalAccessException e) {
				e.printStackTrace();
			}
		}
}

class Foo{
	void print(){
		System.out.println("foo");
	}
}

Class.forName("类的全称")
不仅表示了类的类类型，还代表了动态加载类
编译时刻加载类是静态加载类、运行时刻加载类是动态加载类
new创建对象，是静态加载类，在编译时刻就需要加载所有的可能使用到的类。
通过动态加载类可以解决该问题
基本的数据类型

 package com.hpu.lianxi;

public class ClassDemo1 {
      public static void main(String[] args) {
		Class c1 = int.class;//int的类类型
		Class c2 = String.class;//String的类类型
		Class c3 = double.class;
		Class c4 = float.class;
		Class c5 = void.class;
		Class c6 = Double.class;
		
		System.out.println(c1.getName());
		System.out.println(c2.getName());
		System.out.println(c2.getSimpleName());//不包含包名的类的名称
		System.out.println(c3.getName());
		System.out.println(c4.getName());
		System.out.println(c5.getName());
		System.out.println(c6.getName());
		
	}
}

package com.hpu.lianxi;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ClassUtil {
     /*
      * 本类的作用是打印类的信息、包括类的成员函数
      * 该对象所属类的信息
      * */
	public static void printClassMethodMessage(Object obj){
		//要获取类的信息，首先要获取类的类类型
		Class c = obj.getClass();
		//获取类的名称
		System.out.println("类的名称是： " + c.getName());
		/*Method类，方法对象
		 * 一个成员方法就是一个Method对象
		 * getMethods()方法获取的是所有的public的函数，包括父类继承而来的
		 * getDeclaredMethods()获取的是所有该类自己声明的方法
		 */
        Method[] ms = c.getMethods();
        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[] paraTypes = ms[i].getParameterTypes();
        	for (Class class1 : paraTypes) {
				System.out.print(class1.getName() + ",");
			}
        	System.out.println(")");
        }
	}
	/*
	 * 获取成员变量信息
	 */ 
	public static void printFieldMessage(Object obj){
		Class c = obj.getClass();
		/*成员变量也是对象
		 * 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(typeName + " " + fieldName);;
		}
	}
	/*打印对象的构造函数的信息
	 * 
	 */
	public static void printConMessage(Object obj){
		Class c= obj.getClass();
		/*
		 * 构造函数也是对象
		 * getConstructors获取所有的public的构造函数
		 * getDeclaredConstructors得到所有的构造函数
		 */
		Constructor[] cs = c.getDeclaredConstructors();
		for (Constructor constructor : cs) {
			System.out.print(constructor.getParameterTypes() + "(");
		   Class[] paramTypes = constructor.getParameterTypes();
		   for (Class class1 : paramTypes) {
			System.out.print(class1.getName() + ",");
		}
		   System.out.println(")");
		}
	}
}

方法的反射
   方法的名称和方法的参数列表才能唯一决定某个方法
   方法反射的操作
      method.invoke(对象，参数列表)

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MethodDemo {
     public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    	 //要获取print(int,int)方法
    	 //要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
		A a1 = new A();
		Class c = a1.getClass();
		/*获取方法 名称和参数列表来决定
		 * getMethod获取的是public的方法
		 * getDelcareMethod自己声明的方法
		 */
		try {
			Method m = c.getMethod("print",int.class,int.class);
		   Object o = m.invoke(a1,10,20);
		   System.out.println("==============");
		   Method m1 = c.getMethod("print", String.class,String.class);
		   o = m1.invoke(a1,"hello","WORLD");
		   System.out.println("=============");
		   Method m2 = c.getMethod("print");
		   m2.invoke(a1);
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}
class A{
	public void print(){
		System.out.println("hello world");
	}
	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来认识泛型的本质

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

public class MethodDemo1 {
    public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		ArrayList list = new ArrayList();
		ArrayList<String> list1 = new ArrayList<String>();
		list1.add("hello");
		Class c1 = list.getClass();
		Class c2 = list1.getClass();
		System.out.println(c1 == c2);
		//反射的操作都是编译之后的操作
	    try {
			Method m = c2.getMethod("add", Object.class);
			m.invoke(list1, 20);//绕过了编译操作就绕过了泛型
			System.out.println(list1.size());
			System.out.println(list1);
			
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	    
	}
}