java反射机制

java反射：

---

java反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法。

对于任意一个对象，都能够调用它的任意一个方法和属性

这种动态获取信息以及动态调用对象的方法的功能称为java语言的反射机制。

动态获取类中的信息，就是java反射。

如何获取字节码文件对象呢？

---

方法一：

通过Object类中的getClass方法的

想要用这种方式，必须明确具体的类，并创建对象。

方法二：

任何数据类型都具备一个静态的属性，class来获取其对应的class对象

相对简单，但是还是要明确用到类中的静态成员。

方法三：

只要通过给定的类的字符串名称就可以获取该类，更为扩展。

可是用Class类中方法完成

该方法就是forName

代码如下：

Person 类：

package com.heima.bean;

public class Person {
 
	private int age;
	private String name;
	
	public Person(String name,int age) {
		super();
		this.age = age;
		this.name = name;
		
		System.out.println("Person param run"+this.name+":"+this.age);
	}

	public Person() {
		super();
		
		System.out.println("Person run");

	}
	
	public void run(){
		System.out.println(name+"-----show run----"+age);
	}
	
	public void method(){
		System.out.println("method run ");
	}
	
	public void paramMethod(String str,int num){
		System.out.println("paramMethod run ..."+str+":"+num);
	}
	
	public void staticMethod(){
		System.out.println("staticMethod run ");
	}
}

package com.heima.reflect;
import com.heima.bean.Person;
public class ReflectDemo {

	/*java反射机制是在运行状态中，对于任意一个类（class文件），都能够知道这个类的所有属性和方法。
	对于任意一个对象，都能够调用它的任意一个方法和属性
	这种动态获取信息以及动态调用对象的方法的功能称为java语言的反射机制。
		
	动态获取类中的信息，就是java反射。
	可以理解为对类的剖析
	
	要想要对字节码文件进行剖析，必须要有字节码文件对象
	如何获取字节码文件对象呢？
	方法一：
	通过Object类中的getClass方法的
            想要用这种方式，必须明确具体的类，并创建对象。
    
           方法二：
           任何数据类型都具备一个静态的属性，class来获取其对应的class对象
           相对简单，但是还是要明确用到类中的静态成员。
 
          方法三：
          只要通过给定的类的字符串名称就可以获取该类，更为扩展。
          可是用Class类中方法完成
         该方法就是forName
    
	*/
	public static void main(String[] args) throws ClassNotFoundException {
		
		//getClassObject_1(); 
		//getClassObject_2();
		getClassObject_3();
	}
	
	/*方法三：
	    只要通过给定的类的字符串名称就可以获取该类，更为扩展。
	    可是用Class类中方法完成
	   该方法就是forName*/
	public static void getClassObject_3() throws ClassNotFoundException {
			
		String className = "com.heima.bean.Person";
		Class clazz = Class.forName(className);
		
		System.out.println(clazz);
		
	}

	/* 方法二：
                      任何数据类型都具备一个静态的属性，class来获取其对应的class对象*/
	 public static void getClassObject_2() {
    	  
    	  Class clazz = Person.class;
    	  Class clazz1 = Person.class;
    	  
  		  System.out.println(clazz==clazz1);	
	}

	/*方法一：
	            通过Object类中的getClass方法的*/
	public static void getClassObject_1(){
		
		Person p = new Person();
		Class clazz = p.getClass();
		
		Person p1 = new Person();
		Class clazz1 = p.getClass();
		
		System.out.println(clazz==clazz1);
	}
}

反射机制（获取Class中的构造函数）：

package com.heima.reflect;

import java.lang.reflect.Constructor;

public class ReflectDemo2 {

	public static void main(String[] args) throws Exception {
		//creatNewObject();
		creatNewObject_2();
	}

	public static void creatNewObject_2() throws Exception {
		
		com.heima.bean.Person  p = new com.heima.bean.Person("小强",39);
		
		/**
		 * 当获取指定名称对应类中的所体现的对象时，
		 * 而该对象初始化不使用空参数构造该怎么办呢？
		 * 既然是通过指定的构造函数进行对象的初始化，
		 * 所以应该先获取到该构造函数。通过字节码文件对象即可完成。
		 * 该方法是：getConstructors(paramterTypes)

		 */
		String name = "com.heima.bean.Person";
		// 寻找该名称类文件，并加载进内存，并产生class对象
		Class clazz = Class.forName(name);
		//获取到了指定的构造函数对象
		Constructor constructor =clazz.getConstructor(String.class,int.class);
		//通过该构造器对象的newInstance方法进行对象的初始化
		Object obj = constructor.newInstance("小明",38);
		
	}

	public static void creatNewObject() throws Exception{
		//早期：new时候，先根据被new的类的名称找寻该类的字节码文件，并加载进内存
		//并创建该字节码文件对象，并接着创建该字节文件的对应的Person对象。
		//com.heima.bean.Person  p = new com.heima.bean.Person();
		
		//现在：
		String name = "com.heima.bean.Person";
		//寻找该名称类文件，并加载进内存，并产生class对象
		Class clazz = Class.forName(name);
		//如何产生该类的对象呢/
		Object obj = clazz.newInstance();				
	}
}

反射机制（获取Class中的字段）：

---

package com.heima.reflect;
import java.lang.reflect.Field;
public class ReflectDemo3 {
	public static void main(String[] args) throws Exception {
		getFieldDemo();
	}	
	/**
	 * 获取字节码文件中的字段
	 */
	public static void getFieldDemo() throws Exception{
		
		//寻找该名称类文件，并加载进内存，并产生class对象
		Class clazz = Class.forName("com.heima.bean.Person");	
		//Field filed = clazz.getField("age");//只能获取共有的
		Field filed = clazz.getDeclaredField("age");//只能获取本类，但包含私有	

		//对私有字段的访问取消权限检查，暴力访问
		filed.setAccessible(true);

		Object obj = clazz.newInstance();
		filed.set(obj, 89);
		Object o = filed.get(obj);
		System.out.println(o);
	}
}

反射机制（获取Class中的字段方法）：

---

package com.heima.reflect;

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

public class ReflectDemo4 {

	public static void main(String[] args) throws Exception {
		//getMethodDemo();
		//getMethodDemo_2();
		getMethodDemo_3();
	}
	
	/**
	 * 有参方法
	 * 
	 */
	public static void getMethodDemo_3() throws Exception {
		
		Class clazz = Class.forName("com.heima.bean.Person");
		Method method = clazz.getMethod("paramMethod", String.class,int.class);
		Object obj = clazz.newInstance();
		method.invoke(obj, "小强",89);
		
	}

	/**
	 * 无参方法
	 */
	public static void getMethodDemo_2() throws Exception {
		
		Class clazz = Class.forName("com.heima.bean.Person");
		Method method = clazz.getMethod("show", null);
		Constructor constructor = clazz.getConstructor(String.class,int.class);
		Object obj = constructor.newInstance("小明",89);
		method.invoke(obj, null);
	}

	/**
	 * 获取字节码文件中的字段
	 */
	public static void getMethodDemo() throws Exception{
		
		//寻找该名称类文件，并加载进内存，并产生class对象
		Class clazz = Class.forName("com.heima.bean.Person");
		
		Method[] methods =clazz.getMethods();//获取的都是共有的方法
		methods = clazz.getDeclaredMethods();//只获取本类中所有方法，包含私有
		for (Method method : methods) {
			System.out.println(method);
		}
	}
}