day44-反射03

Java反射03

3.通过反射获取类的结构信息

3.1java.lang.Class类

getName:获取全类名
getSimpleName:获取简单类名
getFields:获取所有public修饰的属性，包含本类以及父类的
getDeclaredFields:获取本类中所有属性
getMethods:获取所有public修饰的方法，包含本类以及父类的
getDeclaredMethods:获取本类中所有方法
getConstructors:获取本类中所有public修饰的构造器
getDeclaredConstructors:获取本类中所有构造器
getPackage:以Package形式返回包信息
getSuperClass:以Class形式返回父类信息
getInterfaces:以Class形式返回接口信息
getAnnotations:以Annotation形式返回注解信息

例子1：

 package li.reflection;
 
import org.junit.jupiter.api.Test;
 
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
 
//演示如何通过反射获取类的结构信息
public class ReflectionUtils {
    public static void main(String[] args) {
    }
 
    //第一组方法 API
    @Test
    public void api_01() throws ClassNotFoundException {
        //得到Class对象
        Class personCls = Class.forName("li.reflection.Person");
 
        //1. getName:获取全类名
        System.out.println(personCls.getName());//li.reflection.Person
 
        //2. getSimpleName:获取简单类名
        System.out.println(personCls.getSimpleName());//Person
 
        //3. getFields:获取所有public修饰的属性，包含本类以及父类的
        Field[] fields = personCls.getFields();
        for (Field field : fields) {//增强for
            System.out.println("本类以及父类的属性=" + field.getName());
            //本类以及父类的属性=name
            //本类以及父类的属性=hobby
 
        }
 
        //4. getDeclaredFields:获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有属性=" + declaredField.getName());
        }
 
        //5. getMethods:获取所有public修饰的方法，包含本类以及父类的
        //这里的父类包括的不只是直接父类，包括object的共有方法也会获取
        Method[] methods = personCls.getMethods();
        for (Method method : methods) {
            System.out.println("获取包含本类以及父类的所有public修饰的方法=" + method.getName());
        }
 
        //6. getDeclaredMethods:获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("获取本类中所有方法" + declaredMethod.getName());
        }
 
        //7. getConstructors:获取本类中所有public修饰的构造器
        Constructor[] constructors = personCls.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("本类的public构造器=" + constructor.getName());
 
        }
 
        //8. getDeclaredConstructors:获取本类中所有构造器
        Constructor[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println("获取本类中所有构造器=" + declaredConstructor.getName());//这里只是输出名字
        }
 
        //9. getPackage:以Package形式返回包信息
        System.out.println(personCls.getPackage());//package li.reflection
 
        //10. getSuperClass:以Class形式返回父类信息
        Class superclass = personCls.getSuperclass();
        System.out.println("父类的Class对象=" + superclass);//class li.reflection.A
 
        //11. getInterfaces:以Class形式返回接口信息
        Class[] interfaces = personCls.getInterfaces();
        for (Class anInterface : interfaces) {
            System.out.println("接口信息" + anInterface);
            //接口信息interface li.reflection.IA
            //接口信息interface li.reflection.IB
        }
 
        //12. getAnnotations:以Annotation形式返回注解信息
        Annotation[] annotations = personCls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息" +annotation);//注解信息@java.lang.Deprecated()
        }
    }
}
 
class A {
    public String hobby;
 
    public void hi() {
    }
 
    public A() {
    }
 
}
 
interface IA {
}
 
interface IB {
}
 
@Deprecated
class Person extends A implements IA, IB {
    //属性
    public String name;
    protected int age;
    String job;
    private double sal;
 
    public Person() {
    }
 
    public Person(String name) {
        this.name = name;
    }
 
    //私有
    private Person(String name, int age) {
    }
 
    //方法
    public void m1() {
    }
 
    protected void m2() {
    }
 
    void m3() {
    }
 
    private void m4() {
    }
 
}

3.2java.lang.reflect.Field类

getModifiers：以int形式返回修饰符

[说明：默认修饰符default是0，public 是1 ，private是2，protected是4，static是8，final是16]

如果有叠加的修饰符，如 public static ...，那么返回的int值就是相加的结果，public(1)+static(8)=9
getType：以Class形式返回类型，即返回该属性对应的类的Class对象
getName：返回属性名

3.3java.lang.reflect.Method类

getModifiers：以int形式返回修饰符

[说明：默认修饰符default是0，public 是1 ，private是2，protected是4，static是8，final是16]

如果有叠加的修饰符，如 public static ...，那么返回的int值就是相加的结果，public(1)+static(8)=9
getReturnType：以Class形式获取返回值的类型的Class对象
getName：返回方法名
getParameteTypes：以Class[]返回参数类型数组

3.4java.lang.reflect.Constructor类

getModifiers：以int形式返回修饰符
getName：返回构造器名（全类名）
getParameteTypes：以Class[]返回参数类型数组

例子2：使用Field类、Method类、Constructor类

 package li.reflection;
 
import org.junit.jupiter.api.Test;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
 
//演示如何通过反射获取类的结构信息
public class ReflectionUtils {
    public static void main(String[] args) {
    }
 
    //第二组方法 API
    @Test
    public void api_02() throws ClassNotFoundException {
        //得到Class对象
        Class personCls = Class.forName("li.reflection.Person");
 
        //getDeclaredFields：获取本类中所有属性
        //[说明：默认修饰符default是0，public 是1 ，private是2，protected是4，static是8，final是16]
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有属性=" + declaredField.getName()
                    + " 该属性的修饰符值=" + declaredField.getModifiers()
                    + " 该属性的类型=" + declaredField.getType());
        }
 
        //getDeclaredMethods：获取本类中所有方法
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中的所有方法=" + declaredMethod.getName()
                    + " 该方法的访问修饰符=" + declaredMethod.getModifiers()
                    + " 该方法返回类型=" + declaredMethod.getReturnType());
 
            //输出当前这个方法的形参数组情况
            Class[] parameterTypes = declaredMethod.getParameterTypes();
            for (Class parameterType : parameterTypes) {
                System.out.println("该方法的形参类型=" + parameterType);
            }
        }
 
        //getDeclaredConstructors:获取本类中所有构造器
        Constructor[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println("=================");
            System.out.println("本类中所有构造器=" + declaredConstructor);
            Class[] parameterTypes = declaredConstructor.getParameterTypes();
            for (Class parameterType : parameterTypes) {
                System.out.println("该构造器的形参类型=" + parameterType);
            }
        }
    }
}
 
class A {
    public String hobby;
 
    public void hi() {
    }
 
    public A() {
    }
 
}
 
interface IA {
}
 
interface IB {
}
 
@Deprecated
class Person extends A implements IA, IB {
    //属性
    public String name;
    protected static int age;
    String job;
    private double sal;
 
    public Person() {
    }
 
    public Person(String name) {
        this.name = name;
    }
 
    //私有
    private Person(String name, int age) {
    }
 
    //方法
    public void m1(String name, int age, double sal) {
    }
 
    protected String m2() {
        return null;
    }
 
    void m3() {
    }
 
    private void m4() {
    }
}

4.通过反射创建对象

方式一：调用类中的public修饰的无参构造器
方式二：调用类中的指定构造器
Class类的相关方法
- newInstance：调用类中的无参构造器，获取对应类的对象
- getConstructor（Class...clazz）：根据参数列表，获取对应的public构造器对象
- getDecalaredConstructor（Class...clazz）：根据参数列表，获取对应的所有构造器对象
Constructor类相关方法
- setAccessible：暴破
- newInstance（Object...obj）:调用构造器

例子：

 package li.reflection;
 
import java.lang.reflect.Constructor;
 
//演示通过反射机制创建实例
public class ReflectCreatInstance {
    public static void main(String[] args) throws Exception {
        //1.先获取到User类的Class对象
        Class userClass = Class.forName("li.reflection.User");
 
        //2.通过public的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
 
        //3.通过public的有参构造器创建实例
        /**
         *  此时的 constructor 对象 就是
         *   public User(String name) {//public有参构造器
         *      this.name = name;
         *     }
         */
        //3.1先得到对应的构造器
        Constructor constructor = userClass.getConstructor(String.class);
        //3.2再去创建实例，并传入实参
        Object bob = constructor.newInstance("bob");
        System.out.println(bob);
 
        //4.通过非public的有参构造器创建实例
 
        //4.1得到private的构造器对象
        Constructor declaredConstructor =
                userClass.getDeclaredConstructor(int.class, String.class);
        //4.2创建实例
        //暴破（暴力破解），使用反射可以访问 私有的构造器/私有的属性/私有的方法
        declaredConstructor.setAccessible(true);
        Object user2 = declaredConstructor.newInstance(99, "张三丰");
        System.out.println(user2);
    }
}
 
class User {//User类
    private int age = 10;
    private String name = "jack";
 
    public User() {//public无参构造器
    }
 
    public User(String name) {//public有参构造器
        this.name = name;
    }
 
    private User(int age, String name) {//private有参构造器
        this.age = age;
        this.name = name;
    }
 
    @Override
    public String toString() {
        return "User [age=" + age + ", name=" + name + "]";
    }
}

5.通过反射访问类中的成员

访问属性
1. 根据属性名获取Field对象
  
  Field f = class对象.getDeclaredField(属性名);
2. 爆破：f.setAccessible(true);//f是Field
3. 访问
  
  f.set(o,值)；//o表示对象
  
  syso(f.get(o)); //o表示对象
4. 注意：如果是静态属性，则set和get中的参数o，可以写为null

例子：

 package li.reflection;
 
import java.lang.reflect.Field;
 
//演示反射操作属性Field
public class ReflectAccessProperty {
    public static void main(String[] args) throws Exception {
        //1.得到Student类对应的Class对象
        Class stuClass = Class.forName("li.reflection.Student");
        
        //2.创建对象
        Object o = stuClass.newInstance();//o的运行类型就是Student
        System.out.println(o.getClass());//Student
 
        //3.使用反射得到age属性对象（公有）
        Field age = stuClass.getField("age");
        age.set(o,88);//通过反射来操作属性
        System.out.println(o);//Student [age=88, name = null]
        //或者
        System.out.println(age.get(o));//返回age属性的值 88
 
        //4.使用反射操作name属性（私有静态的属性）
        Field name = stuClass.getDeclaredField("name");
        //因为name是私有的属性，需要对 name进行爆破
        name.setAccessible(true);
        name.set(o,"jack");//也可以写name.set(null,"jack");因为name是静态属性，与类有关，与对象无关
        System.out.println(o);
        System.out.println(name.get(o));//jack
    }
}
 
class Student {
    public int age;
    private static String name;
 
    public Student() {
    }
 
    @Override
    public String toString() {
        return "Student [age=" + age + ", name = " + name + "]";
    }
}

访问方法
1. 根据方法名和参数列表获取Method方法对象：
  
  Method m = 类的Class对象.getDeclaredMethod(方法名，XX.class);//得到本类的所有方法
  
  XX.class指方法的参数对应的class
2. 获取对象：Object o = 类的Class对象.newInstance();
3. 爆破：m.setAccessible(true);
4. 访问：Object returnValue = m.invoke(o,实参列表)；
5. 注意：如果过是静态方法，则invoke的参数o可以写为null

例子：

 package li.reflection;
 
import java.lang.reflect.Method;
 
//演示通过反射操作方法
public class ReflectAccessMethod {
    public static void main(String[] args) throws Exception {
        //1.得到Boss类对应的Class对象
        Class bossCls = Class.forName("li.reflection.Boss");
 
        //2.创建对象
        Object o = bossCls.newInstance();
 
        //3.调用普通的public的hi方法
        //3.1得到hi方法对应的方法对象
        Method hi = bossCls.getMethod("hi", String.class);
        //3.2调用
        hi.invoke(o, "孙悟空");
 
        //4.调用private static 方法
        //注意点：1.private：要使用爆破；2.static：在invoke时的参数可以写null
        //4.1得到 say 方法对象
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        //4.2爆破
        say.setAccessible(true);
        //4.3invoke的null
        System.out.println(say.invoke(o, 100, "张三", '男'));
        System.out.println(say.invoke(null, 999, "李四", '女'));//因为是静态的方法，所以o可以写为null
 
        //5.在反射中，如果方法有返回值，统一返回Object,但其运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 300, "jack", '男');
        System.out.println("reVal的运行类型=" + reVal.getClass());//String
 
    }
}
 
class Boss {
    public int age;
    private static String name;
 
    public Boss() {
    }
 
    private static String say(int n, String s, char c) {//静态方法
        return n + " " + s + " " + c;
    }
 
    public void hi(String s) {//普通的public方法
        System.out.println("hi " + s);
    }
}

6.本章作业

6.1练习1：通过反射修改私有成员变量

定义privateTest类，有私有属性name，并且属性值为"hellokitty"
提供getName的公有方法
创建PrivateTest的类，利用Class类的到私有属性name，修改其属性值，并调用getName()的方法打印name属性值

 package li.reflection.homework;
 
import java.lang.reflect.Field;
import java.lang.reflect.Method;
 
public class homework01 {
    public static void main(String[] args) throws Exception {
        //1.得到PrivateTest对应的Class对象
        Class privateTestCls = Class.forName("li.reflection.homework.PrivateTest");
        //2.创建对象
        Object o = privateTestCls.newInstance();
        //3.得到name属性对象
        Field name = privateTestCls.getDeclaredField("name");
        //4.爆破
        name.setAccessible(true);
        name.set(o,"天龙八部");
        //5.得到getName方法的对象
        Method method = privateTestCls.getMethod("getName");
        //6.因为getName是public方法，直接调用即可
        Object invoke = method.invoke(o);
        System.out.println("name属性的值="+invoke);
    }
}
class PrivateTest{
    private String name = "HelloKitty";
    public String getName(){
        return name;
    }
}

6.2练习：利用反射和File完成以下功能

利用Class类的forName方法得到File类的class对象
在控制台打印File类的所有构造器
通过newInstance方法创建File对象，并创建d:\mynew.txt文件

提示：创建文件的正确写法如下：

File file = new File("d:\mynew.txt");

file.creatNewFile();

 package li.reflection.homework;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
 
public class homework02 {
    public static void main(String[] args) throws Exception {
        //得到File类对应的class类对象
        Class fileCls = Class.forName("java.io.File");
        //得到所有的构造器
        Constructor[] declaredConstructors = fileCls.getDeclaredConstructors();
        System.out.println("=====File的所有构造器=====");
        //遍历输出构造器
        for (Constructor declaredConstructor : declaredConstructors) {
            System.out.println(declaredConstructor);
        }
        //指定得到 public java.io.File(java.lang.String)
        Constructor constructor = fileCls.getConstructor(String.class);
        //创建File类对象
        Object file = constructor.newInstance("d:\\mynew.txt");
        //获取createNewFile方法的对象
        Method createNewFile = fileCls.getDeclaredMethod("createNewFile");
        //调用
        createNewFile.invoke(file);
    }
}

相关阅读:
【RocketMQ系列十】RocketMQ的核心概念说明
 nodejs+vue+elementui个人图书分享共享网站
 JavaScript之函数相关知识
 【Docker】（1）了解docker的基础命令、概念（底层隔离机制），云服务
 python flask 接入 sentry
DPDK原理探索: igb_uio
如何用Jmeter编写脚本压测？
不同访问修饰符的访问数据权限的区别
 nvm安装及使用，nodejs版本切换使用
 Python飞机大战小游戏
原文地址：https://www.cnblogs.com/liyuelian/p/16743198.html

	package li.reflection;

	import org.junit.jupiter.api.Test;

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

	//演示如何通过反射获取类的结构信息
	public class ReflectionUtils {
	public static void main(String[] args) {
	}

	//第一组方法 API
	@Test
	public void api_01() throws ClassNotFoundException {
	//得到Class对象
	Class personCls = Class.forName("li.reflection.Person");

	//1. getName:获取全类名
	System.out.println(personCls.getName());//li.reflection.Person

	//2. getSimpleName:获取简单类名
	System.out.println(personCls.getSimpleName());//Person

	//3. getFields:获取所有public修饰的属性，包含本类以及父类的
	Field[] fields = personCls.getFields();
	for (Field field : fields) {//增强for
	System.out.println("本类以及父类的属性=" + field.getName());
	//本类以及父类的属性=name
	//本类以及父类的属性=hobby

	}

	//4. getDeclaredFields:获取本类中所有属性
	Field[] declaredFields = personCls.getDeclaredFields();
	for (Field declaredField : declaredFields) {
	System.out.println("本类中所有属性=" + declaredField.getName());
	}

	//5. getMethods:获取所有public修饰的方法，包含本类以及父类的
	//这里的父类包括的不只是直接父类，包括object的共有方法也会获取
	Method[] methods = personCls.getMethods();
	for (Method method : methods) {
	System.out.println("获取包含本类以及父类的所有public修饰的方法=" + method.getName());
	}

	//6. getDeclaredMethods:获取本类中所有方法
	Method[] declaredMethods = personCls.getDeclaredMethods();
	for (Method declaredMethod : declaredMethods) {
	System.out.println("获取本类中所有方法" + declaredMethod.getName());
	}

	//7. getConstructors:获取本类中所有public修饰的构造器
	Constructor[] constructors = personCls.getConstructors();
	for (Constructor constructor : constructors) {
	System.out.println("本类的public构造器=" + constructor.getName());

	}

	//8. getDeclaredConstructors:获取本类中所有构造器
	Constructor[] declaredConstructors = personCls.getDeclaredConstructors();
	for (Constructor declaredConstructor : declaredConstructors) {
	System.out.println("获取本类中所有构造器=" + declaredConstructor.getName());//这里只是输出名字
	}

	//9. getPackage:以Package形式返回包信息
	System.out.println(personCls.getPackage());//package li.reflection

	//10. getSuperClass:以Class形式返回父类信息
	Class superclass = personCls.getSuperclass();
	System.out.println("父类的Class对象=" + superclass);//class li.reflection.A

	//11. getInterfaces:以Class形式返回接口信息
	Class[] interfaces = personCls.getInterfaces();
	for (Class anInterface : interfaces) {
	System.out.println("接口信息" + anInterface);
	//接口信息interface li.reflection.IA
	//接口信息interface li.reflection.IB
	}

	//12. getAnnotations:以Annotation形式返回注解信息
	Annotation[] annotations = personCls.getAnnotations();
	for (Annotation annotation : annotations) {
	System.out.println("注解信息" +annotation);//注解信息@java.lang.Deprecated()
	}
	}
	}

	class A {
	public String hobby;

	public void hi() {
	}

	public A() {
	}

	}

	interface IA {
	}

	interface IB {
	}

	@Deprecated
	class Person extends A implements IA, IB {
	//属性
	public String name;
	protected int age;
	String job;
	private double sal;

	public Person() {
	}

	public Person(String name) {
	this.name = name;
	}

	//私有
	private Person(String name, int age) {
	}

	//方法
	public void m1() {
	}

	protected void m2() {
	}

	void m3() {
	}

	private void m4() {
	}

	}

	package li.reflection;

	import java.lang.reflect.Constructor;

	//演示通过反射机制创建实例
	public class ReflectCreatInstance {
	public static void main(String[] args) throws Exception {
	//1.先获取到User类的Class对象
	Class userClass = Class.forName("li.reflection.User");

	//2.通过public的无参构造器创建实例
	Object o = userClass.newInstance();
	System.out.println(o);

	//3.通过public的有参构造器创建实例
	/**
	* 此时的 constructor 对象就是
	* public User(String name) {//public有参构造器
	* this.name = name;
	* }
	*/
	//3.1先得到对应的构造器
	Constructor constructor = userClass.getConstructor(String.class);
	//3.2再去创建实例，并传入实参
	Object bob = constructor.newInstance("bob");
	System.out.println(bob);

	//4.通过非public的有参构造器创建实例

	//4.1得到private的构造器对象
	Constructor declaredConstructor =
	userClass.getDeclaredConstructor(int.class, String.class);
	//4.2创建实例
	//暴破（暴力破解），使用反射可以访问私有的构造器/私有的属性/私有的方法
	declaredConstructor.setAccessible(true);
	Object user2 = declaredConstructor.newInstance(99, "张三丰");
	System.out.println(user2);
	}
	}

	class User {//User类
	private int age = 10;
	private String name = "jack";

	public User() {//public无参构造器
	}

	public User(String name) {//public有参构造器
	this.name = name;
	}

	private User(int age, String name) {//private有参构造器
	this.age = age;
	this.name = name;
	}

	@Override
	public String toString() {
	return "User [age=" + age + ", name=" + name + "]";
	}
	}

	package li.reflection;

	import java.lang.reflect.Field;

	//演示反射操作属性Field
	public class ReflectAccessProperty {
	public static void main(String[] args) throws Exception {
	//1.得到Student类对应的Class对象
	Class stuClass = Class.forName("li.reflection.Student");

	//2.创建对象
	Object o = stuClass.newInstance();//o的运行类型就是Student
	System.out.println(o.getClass());//Student

	//3.使用反射得到age属性对象（公有）
	Field age = stuClass.getField("age");
	age.set(o,88);//通过反射来操作属性
	System.out.println(o);//Student [age=88, name = null]
	//或者
	System.out.println(age.get(o));//返回age属性的值 88

	//4.使用反射操作name属性（私有静态的属性）
	Field name = stuClass.getDeclaredField("name");
	//因为name是私有的属性，需要对 name进行爆破
	name.setAccessible(true);
	name.set(o,"jack");//也可以写name.set(null,"jack");因为name是静态属性，与类有关，与对象无关
	System.out.println(o);
	System.out.println(name.get(o));//jack
	}
	}

	class Student {
	public int age;
	private static String name;

	public Student() {
	}

	@Override
	public String toString() {
	return "Student [age=" + age + ", name = " + name + "]";
	}
	}

	package li.reflection;

	import java.lang.reflect.Method;

	//演示通过反射操作方法
	public class ReflectAccessMethod {
	public static void main(String[] args) throws Exception {
	//1.得到Boss类对应的Class对象
	Class bossCls = Class.forName("li.reflection.Boss");

	//2.创建对象
	Object o = bossCls.newInstance();

	//3.调用普通的public的hi方法
	//3.1得到hi方法对应的方法对象
	Method hi = bossCls.getMethod("hi", String.class);
	//3.2调用
	hi.invoke(o, "孙悟空");

	//4.调用private static 方法
	//注意点：1.private：要使用爆破；2.static：在invoke时的参数可以写null
	//4.1得到 say 方法对象
	Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
	//4.2爆破
	say.setAccessible(true);
	//4.3invoke的null
	System.out.println(say.invoke(o, 100, "张三", '男'));
	System.out.println(say.invoke(null, 999, "李四", '女'));//因为是静态的方法，所以o可以写为null

	//5.在反射中，如果方法有返回值，统一返回Object,但其运行类型和方法定义的返回类型一致
	Object reVal = say.invoke(null, 300, "jack", '男');
	System.out.println("reVal的运行类型=" + reVal.getClass());//String

	}
	}

	class Boss {
	public int age;
	private static String name;

	public Boss() {
	}

	private static String say(int n, String s, char c) {//静态方法
	return n + " " + s + " " + c;
	}

	public void hi(String s) {//普通的public方法
	System.out.println("hi " + s);
	}
	}

	package li.reflection.homework;

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

	public class homework01 {
	public static void main(String[] args) throws Exception {
	//1.得到PrivateTest对应的Class对象
	Class privateTestCls = Class.forName("li.reflection.homework.PrivateTest");
	//2.创建对象
	Object o = privateTestCls.newInstance();
	//3.得到name属性对象
	Field name = privateTestCls.getDeclaredField("name");
	//4.爆破
	name.setAccessible(true);
	name.set(o,"天龙八部");
	//5.得到getName方法的对象
	Method method = privateTestCls.getMethod("getName");
	//6.因为getName是public方法，直接调用即可
	Object invoke = method.invoke(o);
	System.out.println("name属性的值="+invoke);
	}
	}
	class PrivateTest{
	private String name = "HelloKitty";
	public String getName(){
	return name;
	}
	}