JavaCore-反射

Class类
Java语言中，两个东西不是面向对象的，一个是静态的东西，一个基本数据类型

类也是对象，类是java.lang.class 类的实例，比如：A类是java.lang.class 类的实例对象
Class类型（类的类型）是只有虚拟机才可以创建。

Class c1 = Foo.class;
Class c2 = foo1.getClass();
Class c3 = Class.forName("com.imooc.reflect.Foo");

c1=c2=c3 return true;

Foo foo = (Foo)c1.newInstance();// 利用Reflect创建对象，需要强制类型转换

利用reflect来分析类的能力

获取类的类型：

Class.getName()：以String的形式，返回Class对象的“实体”名称；

Class.getSimpleName()：获取源代码中给出的“底层类”简称

public class Main {
	
	private static final String TAG1 = Main.class.getName();
	private static final String TAG2 = Main.class.getSimpleName();
	
	public static void main(String[] args) {
		System.out.println("getName ----- " + TAG1 + "\n" + "getSimpleName ----- " + TAG2);
	}
}

结果如下：
在这里插入图片描述

java.lang.reflect包中有三个类，Field，Method，Constructor 分别表示了，获取域，方法，构造器的能力。
这三个类都有一个getModifiers方法，返回一个整形数值。

public class ClassUtil {

	public static void printClassMethodMessage(Object obj){

		Class c = obj.getClass();

		System.out.println("obj类名称"+c.getName());

		Method[] ms = c.getMethods();//c.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 class1 : paramTypes) {
				System.out.print(class1.getName()+",");
			}
			System.out.println(")");
		}
	}

	public static void printFieldMessage(Object obj) {
		Class c = obj.getClass();

		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);
			System.out.println(typeName+" "+"Value"++field.get(obj));//获取field的value值
		}
	}


	public static void printConMessage(Object obj){
		Class c = obj.getClass();

		//Constructor[] cs = c.getConstructors();
		Constructor[] cs = c.getDeclaredConstructors();
		for (Constructor constructor : cs) {
			System.out.print(constructor.getName()+"(");

			Class[] paramTypes = constructor.getParameterTypes();
			for (Class class1 : paramTypes) {
				System.out.print(class1.getName()+",");
			}
			System.out.println(")");
		}
	}
}

私有成员变量，在类的外面获取此类的私有成员变量value时，要设置可见性

public class Main {  
  
    public static void main(String[] args) throws Exception {  
        Class clazz = Class.forName("com.test.accessible.AccessibleTest");  
        AccessibleTest at = new AccessibleTest();  
        at.setId(1);  
        at.setName("AT");  
        for (Field f : clazz.getDeclaredFields()) {  
            f.setAccessible(true);//AccessibleTest类中的成员变量为private,故必须进行此操作  
            System.out.println(f.get(at));//获取当前对象中当前Field的value  
        }  
  
    }  
  
}

不然：

java.lang.IllegalAccessException:  
Class com.test.accessible.Main   
can not access   
a member of class com.test.accessible.AccessibleTest  
with modifiers "private"

调用任意方法：

public class MethodDemo1 {
	public static void main(String[] args) {

		A a1 = new A();
		Class c = a1.getClass();

	    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 (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
     
	}
}

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

public static Object getValueByPropertyName(Object obj, String propertyName) { // propertyName是方法的名称

		String getMethodName = "get"
				+ propertyName.substring(0, 1).toUpperCase()
				+ propertyName.substring(1);

		Class c = obj.getClass();
		try {

			Method m= c.getMethod(getMethodName);

			Object value = m.invoke(obj);
			return value;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

Java的泛型是编译时有效的，防止错误输入的，只有在编译阶段有效，绕过编译阶段就无效了，可以通过反射操作，绕过编译。

public class MethodDemo4 {
	public static void main(String[] args) {
		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);
			/*for (String string : list1) {
				System.out.println(string);
			}*/不能进行编译，因为里面的值不全是String
		} catch (Exception e) {
		  e.printStackTrace();
		}
	}

}

猜你喜欢