java-反射

Class clz = Class.forName("java.lang.String");

Class clz = String.class;

String str = new String("Hello");
Class clz = str.getClass();

public static void main(String[] args) throws Exception {
	//1. 获取接口的字节码对象的两种方式
		Class list1 = Class.forName("java.util.List");
		Class list2 = List.class;
		System.out.println(list1 == list2);  //true
		
		
	//2. 获取数组的字节码对象的两种方式
		int[] a = {1,5,8};
		Class a1 = int[].class;
		Class a2 = a.getClass();
		System.out.println(a1 == a2);        //true
		
		int[] b = {};
		Class b1 = b.getClass();
		System.out.println(a1 == b1);		//true
		
		String[] s = {};
		Class s1 = s.getClass();
		String[][] ss = {};
		Class s2 = ss.getClass();
		System.out.println(s1 == s2);		//false
//		综上：具有相同元素类型  和  维数的数组都共享该 Class 对象；
		
		
	//3. 获取基本数据类型、包装类型 的字节码对象的几种方式
		Class int1 = int.class;
		Class int2 = Integer.TYPE;
		//获取 包装类型  的字节码对象的三种方式
		Class intc1 = Class.forName("java.lang.Integer");
		Class intc2 = Integer.class;
		Class intc3 = new Integer(10).getClass();
		
/*	注意点：	Integer 是 Object Type 对象类型， int 是 Primitive Type 原始类型
			Integer 有成员变量，有成员方法，int 无成员变量，无成员方法
			Integer.class 与 int.class 不同
			Integer.TYPE 与 int.class 相同
*/
		System.out.println(int1 == int2);   //true
		System.out.println(intc1 == int2); 	//false
		System.out.println(intc1 == intc3);  //true
		
	 
/*	4. void 和基本数据类型只能通过类型名称获取该字节码对象
		 还可以通过其对应的包装类的TYPE属性获取其字节码对象。
		 * eg 获取int的字节码对象
		 * 		int.class或者 Integer.TYPE
		 * 	  获取void的字节码对象
		 * 		void .class 或者 Void.TYPE
		 * 
	其中： Void类是一个不可实例化的占位符类，它持有对标识Java关键字void的Class对象的引用。
		 并且本身的构造函数为private，即该类是不可以实例化的
	底层代码：	
		public final class Void {
		    public static final Class<Void> TYPE = (Class<Void>) Class.getPrimitiveClass("void");
		    private Void() {}
		}
*/		
		 Class v1 = void.class;
		 Class v2 = Void.TYPE;
		 
		 Class vc1 = Void.class;
		 Class vc2 = Class.forName("java.lang.Void");
		 
		 System.out.println(v1 == v2);    //true
		 System.out.println(v1 == vc2);   //false
	}

package com.ganshao.Test2;
import java.lang.reflect.Constructor;

//Person 类
class Person {
	private String name;
	public Person(String name) {
		this.name = name;
	}
	private Person() {}
}
//Student 类
class Student {
	public Student(String name) {}
}
public class Test1 {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
		Class c1 = Class.forName("com.ganshao.Test2.Person");//获取Person类的字节码对象
		/*
		 * public Constructor<T> getConstructor(Class<?>... parameterTypes)
		 * 返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
		 * */
		Constructor pc1= c1.getConstructor(String.class);		//不可以去获取私有化的构造方法
		Constructor con1 = c1.getDeclaredConstructor();			//可以去获取私有化的无参构造方法
		System.out.println(pc1);    //public com.ganshao.Test2.Person(java.lang.String)
		System.out.println(con1);   //private com.ganshao.Test2.Person()
		
		System.out.println("---");
	//获取一个类中所有非私有化的构造方法
		Constructor[] cons = c1.getConstructors();
		for (Constructor constructor : cons) {
			System.out.println(constructor);
		}
		System.out.println("---");
		
	//获取一个类中所有的构造方法（跟权限无关）
		Constructor[] cons1 = c1.getDeclaredConstructors();   //注意末尾加了   "s"
		for (Constructor constructor : cons1) {
			System.out.println(constructor);
		}
		System.out.println("---");
		
		Constructor s1 = Student.class.getDeclaredConstructor();
		System.out.println(s1);     //报错：NoSuchMethodException，因为没有私有的构造方法
	}
}

//Student 类
class Student {
	private String name;
	
	public Student(String name) {this.name = name;}
	private Student() {}
	
	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}
}
public class Test1 {
	public static void main(String[] args) throws Exception {	
	//2. 字节码对象.newInstance()
//		Class c = Student.class;
//		Student s = (Student)(c.newInstance());
//		System.out.println(s);   // 此时 如果 Student()构造方法 访问权限设置为 private 会报错。
		
	//3. 通过Constructor方法获得
		Class c = Student.class;
		Constructor constructor = c.getDeclaredConstructor();
		constructor.setAccessible(true);     //让方法的private修饰符在这一次创建对象时失效
		Student s2 =(Student)(constructor.newInstance());
		System.out.println(s2);            //Student [name=null]
		
		Constructor constructor1 = c.getConstructor(String.class);
		Student s3 =(Student)(constructor1.newInstance("张三"));
		System.out.println(s3);          //Student [name=张三]
	}
}

Class clz = Apple.class;
Field[] fields = clz.getFields();
for (Field field : fields) {
    System.out.println(field.getName());
}

输出结果是：

price

Class clz = Apple.class;
Field[] fields = clz.getDeclaredFields();
for (Field field : fields) {
    System.out.println(field.getName());
}

输出结果是：

name
price

package 通过反射执行方法;
import java.lang.reflect.Method;

class Pig{
	private void t1(){
		System.out.println("t1方法执行了");
	}
	public int t2(int i){
		return i;
	}
	public static void t3(){
		System.out.println("t3 方法执行了 ");
	}
}
public class Test1 {
	public static void main(String[] args) throws Exception {
		/*通过反射执行方法
		Object invoke(Object obj, Object... args)   
		返回值类型Object   参数：该方法所属的对象，  [...]多个实际参数*/
		
		Class pigClass = Pig.class;                      //获得字节码对象
		Method m = pigClass.getMethod("t2", int.class);  //获取方法对象
		System.out.println(m);           //public int 通过反射执行方法.Pig.t2(int)
		Object obj = m.invoke(new Pig(),100);            //通过方法的对象.invoke() 去执行方法
		System.out.println(obj);          //100
	}
}