通过java语言中的反射机制可以操作字节码文件（可以读和修改字节码文件。）
通过反射机制可以操作代码片段。（class文件。）
java.lang.reflect.*;
| 类 | 含义 |
|---|---|
| java.lang.class | 代表整个字节码。代表一个类型，代表整个类。 |
| java.lang.reflect.method | 代表字节码中的方法字节码。代表类中的方法。 |
| java.lang.reflect.constructor | 代表字节码中的构造方法字节码。代表类中的构造方法。 |
| java.lang.reflect.field | 代表字节码中的属性字节码。代表类中的成员变量（静态变量 实例变量）。 |
注：必须先获得class才能获取method、constructor、field。
eg.
java.lang.class:
public class user{
// field
int no;
// constructor
public user(){
}
public user(int no){
this.no = no;
}
// method
public void setno(int no){
this.no = no;
}
public int getno(){
return no;
}
}
要操作一个类的字节码，需要首先获取到这个类的字节码，怎么获取java.lang.class实例？
| 方式 | 备注 |
|---|---|
| class.forname(“完整类名带包名”) | 静态方法 |
| 对象.getclass() | |
| 任何类型.class |
注：以上三种方式返回值都是class类型。
对象.newinstance()
注：newinstance()方法内部实际上调用了无参数构造方法，必须保证无参构造存在才可以。
否则会抛出java.lang.instantiationexception异常。
eg.
class reflecttest02{
public static void main(string[] args) throws classnotfoundexception, instantiationexception, illegalaccessexception {
// 下面这段代码是以反射机制的方式创建对象。
// 通过反射机制，获取class，通过class来实例化对象
class c = class.forname("javase.reflectbean.user");
// newinstance() 这个方法会调用user这个类的无参数构造方法，完成对象的创建。
// 重点是：newinstance()调用的是无参构造，必须保证无参构造是存在的！
object obj = c.newinstance();
system.out.println(obj);
}
}
如果你只是希望一个类的静态代码块执行，其它代码一律不执行，可以使用：
class.forname("完整类名");
这个方法的执行会导致类加载，类加载时，静态代码块执行。
7.1、class类方法
| 方法名 | 备注 |
|---|---|
| public t newinstance() | 创建对象 |
| public string getname() | 返回完整类名带包名 |
| public string getsimplename() | 返回类名 |
| public field[] getfields() | 返回类中public修饰的属性 |
| public field[] getdeclaredfields() | 返回类中所有的属性 |
| public field getdeclaredfield(string name) | 根据属性名name获取指定的属性 |
| public native int getmodifiers() | 获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号【一般配合modifier类的tostring(int x)方法使用】 |
| public method[] getdeclaredmethods() | 返回类中所有的实例方法 |
| public method getdeclaredmethod(string name, class… parametertypes) | 根据方法名name和方法形参获取指定方法 |
| public constructor[] getdeclaredconstructors() | 返回类中所有的构造方法 |
| public constructor getdeclaredconstructor(class… parametertypes) | 根据方法形参获取指定的构造方法 |
| ---- | ---- |
| public native class getsuperclass() | 返回调用类的父类 |
| public class[] getinterfaces() | 返回调用类实现的接口集合 |
7.2、field类方法
| 方法名 | 备注 |
|---|---|
| public string getname() | 返回属性名 |
| public int getmodifiers() | 获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号【一般配合modifier类的tostring(int x)方法使用】 |
| public class gettype() | 以class类型，返回属性类型【一般配合class类的getsimplename()方法使用】 |
| public void set(object obj, object value) | 设置属性值 |
| public object get(object obj) | 读取属性值 |
eg.反编译一个类的属性field
//通过反射机制，反编译一个类的属性field（了解一下）
class reflecttest06{
public static void main(string[] args) throws classnotfoundexception {
stringbuilder s = new stringbuilder();
class studentclass = class.forname("javase.reflectbean.student");
s.append(modifier.tostring(studentclass.getmodifiers()) " class " studentclass.getsimplename() " {\n");// class类的getname方法
//获取所有的属性
field[] fields = studentclass.getdeclaredfields();
for (field f : fields){
s.append("\t");
// 获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号
// 用modifier类的tostring转换成字符串
s.append(modifier.tostring(f.getmodifiers()));
if (f.getmodifiers() != 0) s.append(" ");
s.append(f.gettype().getsimplename());// 获取属性的类型
s.append(" ");
s.append(f.getname());// 获取属性的名字
s.append(";\n");
}
s.append("}");
system.out.println(s);
}
}
7.2.1、给属性赋值三要素
eg. 给s对象的no属性赋值1111
- 要素1：对象 s
- 要素2：no 属性
- 要素3：1111 值
7.2.2、读属性值两个要素
eg. 获取s对象的no属性的值
- 要素1：对象 s
- 要素2：no属性
注： field类中set()、get()使用注意事项：
属性.set(对象, 值);
属性.get(对象);
eg.通过反射机制访问一个java对象的属性
/*
必须掌握：
怎么通过反射机制访问一个java对象的属性？
给属性赋值set
获取属性的值get
*/
class reflecttest07{
public static void main(string[] args) throws classnotfoundexception, instantiationexception, illegalaccessexception, nosuchfieldexception {
//不使用反射机制给属性赋值
student student = new student();
/**给属性赋值三要素：给s对象的no属性赋值1111
* 要素1：对象s
* 要素2：no属性
* 要素3：1111
*/
student.no = 1111;
/**读属性值两个要素：获取s对象的no属性的值。
* 要素1：对象s
* 要素2：no属性
*/
system.out.println(student.no);
//使用反射机制给属性赋值
class studentclass = class.forname("javase.reflectbean.student");
object obj = studentclass.newinstance();// obj就是student对象。（底层调用无参数构造方法）
// 获取no属性（根据属性的名称来获取field）
field nofield = studentclass.getdeclaredfield("no");
// 给obj对象(student对象)的no属性赋值
/*
虽然使用了反射机制，但是三要素还是缺一不可：
要素1：obj对象
要素2：no属性
要素3：22222值
注意：反射机制让代码复杂了，但是为了一个“灵活”，这也是值得的。
*/
nofield.set(obj, 22222);
// 读取属性的值
// 两个要素：获取obj对象的no属性的值。
system.out.println(nofield.get(obj));
}
7.2.3、set()可以访问私有属性嘛？
不可以，需要打破封装，才可以。
fidle方法：
| 方法 | 备注 |
|---|---|
| public void setaccessible(boolean flag) | 默认false，设置为true为打破封装 |
eg.
// 可以访问私有的属性吗？
field namefield = studentclass.getdeclaredfield("name");
// 打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会！！！）
// 这样设置完之后，在外部也是可以访问private的。
namefield.setaccessible(true);
// 给name属性赋值
namefield.set(obj, "xiaowu");
// 获取name属性的值
system.out.println(namefield.get(obj));
8.1、method类方法
| 方法名 | 备注 |
|---|---|
| public string getname() | 返回方法名 |
| public int getmodifiers() | 获取方法的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号【一般配合modifier类的tostring(int x)方法使用】 |
| public class getreturntype() | 以class类型，返回方法类型【一般配合class类的getsimplename()方法使用】 |
| public class[] getparametertypes() | 返回方法的修饰符列表（一个方法的参数可能会有多个。）【结果集一般配合class类的getsimplename()方法使用】 |
| public object invoke(object obj, object… args) | 调用方法 |
eg.反编译一个类的方法method
/*
了解一下，不需要掌握（反编译一个类的方法。）
*/
class reflecttest09{
public static void main(string[] args) throws classnotfoundexception {
stringbuilder s = new stringbuilder();
class userserviceclass = class.forname("java.lang.string");
s.append(modifier.tostring(userserviceclass.getmodifiers()));
s.append(" class ");
s.append(userserviceclass.getsimplename());
s.append(" {\n");
// 获取所有的method（包括私有的！）
method[] methods = userserviceclass.getdeclaredmethods();
for (method m : methods){
s.append("\t");
// 获取修饰符列表
s.append(modifier.tostring(m.getmodifiers()));
s.append(" ");
// 获取方法的返回值类型
s.append(m.getreturntype().getsimplename());
s.append(" ");
// 获取方法名
s.append(m.getname());
s.append("(");
// 方法的修饰符列表（一个方法的参数可能会有多个。）
class[] parametertypes = m.getparametertypes();
for (int i = 0; i < parametertypes.length; i ){
s.append(parametertypes[i].getsimplename());
if (i != parametertypes.length - 1) s.append(", ");
}
s.append(") {}\n");
}
s.append("}");
system.out.println(s);
}
}
8.1.1、调用方法四要素
eg. 调用对象userservice的login方法
- 要素1：对象 userservice
- 要素2：login 方法名
- 要素3：实参列表
- 要素4：返回值
注： method类中invoke()使用注意事项：
方法.invoke(对象, 实参);
eg.通过反射机制调用一个对象的方法
/*
重点：必须掌握，通过反射机制怎么调用一个对象的方法？
五颗星*****
反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中，
将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，
但是java代码不需要做任何改动。这就是反射机制的魅力。
*/
class reflecttest10{
public static void main(string[] args) throws exception {
// 不使用反射机制，怎么调用方法
// 创建对象
userservice userservice = new userservice();
// 调用方法
/*
要素分析：
要素1：对象userservice
要素2：login方法名
要素3：实参列表
要素4：返回值
*/
system.out.println(userservice.login("admin", "123") ? "登入成功！" : "登入失败！");
//使用反射机制调用方法
class userserviceclass = class.forname("javase.reflectbean.userservice");
// 创建对象
object obj = userserviceclass.newinstance();
// 获取method
method loginmethod = userserviceclass.getdeclaredmethod("login", string.class, string.class);
// method loginmethod = userserviceclass.getdeclaredmethod("login");//注：没有形参就不传
// 调用方法
// 调用方法有几个要素？ 也需要4要素。
// 反射机制中最最最最最重要的一个方法，必须记住。
/*
四要素：
loginmethod方法
obj对象
"admin","123" 实参
retvalue 返回值
*/
object resvalues = loginmethod.invoke(obj, "admin", "123");//注：方法返回值是void 结果是null
system.out.println(resvalues);
}
}
9.1constructor类方法
| 方法名 | 备注 |
|---|---|
| public string getname() | 返回构造方法名 |
| public int getmodifiers() | 获取构造方法的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号【一般配合modifier类的tostring(int x)方法使用】 |
| public class[] getparametertypes() | 返回构造方法的修饰符列表（一个方法的参数可能会有多个。）【结果集一般配合class类的getsimplename()方法使用】 |
| public t newinstance(object … initargs) | 创建对象【参数为创建对象的数据】 |
eg.反编译一个类的构造方法constructor
/*
反编译一个类的constructor构造方法。
*/
class reflecttest11{
public static void main(string[] args) throws classnotfoundexception {
stringbuilder s = new stringbuilder();
class vipclass = class.forname("javase.reflectbean.vip");
//public class userservice {
s.append(modifier.tostring(vipclass.getmodifiers()));
s.append(" class ");
s.append(vipclass.getsimplename());
s.append("{\n");
constructor[] constructors = vipclass.getdeclaredconstructors();
for (constructor c : constructors){
//public vip(int no, string name, string birth, boolean sex) {
s.append("\t");
s.append(modifier.tostring(c.getmodifiers()));
s.append(" ");
// s.append(c.getname());//包名 类名
s.append(vipclass.getsimplename());//类名
s.append("(");
class[] parametertypes = c.getparametertypes();
for (int i = 0; i < parametertypes.length; i ){
s.append(parametertypes[i].getsimplename());
if (i != parametertypes.length - 1 ) s.append(", ");
}
s.append("){}\n");
}
s.append("}");
system.out.println(s);
}
}
9.1.1、反射机制创建对象两步骤
- 先获取到这个有参数的构造方法【用classgetdeclaredconstructor()方法获取】
- 调用构造方法new对象【用constructor类的newinstance()方法new对象】
eg.通过反射机制调用构造方法实例化java对象
/*
比上一个例子(reflecttest11)重要一些！！！
通过反射机制调用构造方法实例化java对象。（这个不是重点）
*/
class reflecttest12{
public static void main(string[] args) throws exception {
//不适用反射创建对象
vip vip1 = new vip();
vip vip2 = new vip(123, "zhangsan", "2001-10-19", false);
//使用反射机制创建对象（以前）
class vipclass = class.forname("javase.reflectbean.vip");
// 调用无参数构造方法
object obj1 = vipclass.newinstance();//class类的newinstance方法
system.out.println(obj1);
//使用反射机制创建对象（现在）
// 调用有参数的构造方法怎么办？
// 第一步：先获取到这个有参数的构造方法
constructor c1 = vipclass.getdeclaredconstructor(int.class, string.class, string.class, boolean.class);
// 第二步：调用构造方法new对象
object obj2 = c1.newinstance(321, "lsi", "1999-10-11", true);//constructor类的newinstance方法
system.out.println(obj2);
// 获取无参数构造方法
constructor c2 = vipclass.getdeclaredconstructor();
object obj3 = c2.newinstance();
system.out.println(obj3);
}
}
注： 如果需要调用无参构造方法，getdeclaredconstructor()方法形参为空即可【和class类的newinstance()方法一样的效果】！
两个方法【class类中的】
- public native class getsuperclass()
- public class[] getinterfaces()
/*
重点：给你一个类，怎么获取这个类的父类，已经实现了哪些接口？
*/
class reflecttest13{
public static void main(string[] args) throws exception{
// string举例
class vipclass = class.forname("java.lang.string");
// 获取string的父类
class superclass = vipclass.getsuperclass();
// 获取string类实现的所有接口（一个类可以实现多个接口。）
class[] interfaces = vipclass.getinterfaces();
system.out.println(superclass.getname());
for (class i : interfaces) {
system.out.println(i.getname());
}
}
}
- 属性最重要的是名字
- 实例方法最重要的是名字和形参列表
- 构造方法最重要的是形参列表
package javase;
import javase.reflectbean.student;
import javase.reflectbean.userservice;
import javase.reflectbean.vip;
import java.io.*;
import java.lang.reflect.constructor;
import java.lang.reflect.field;
import java.lang.reflect.method;
import java.lang.reflect.modifier;
import java.util.date;
import java.util.properties;
import java.util.resourcebundle;
/*
要操作一个类的字节码，需要首先获取到这个类的字节码，怎么获取java.lang.class实例？
三种方式
第一种：class c = class.forname("完整类名带包名");
第二种：class c = 对象.getclass();
第三种：class c = 任何类型.class;
*/
class reflecttest01 {
public static void main(string[] args) throws classnotfoundexception{
/*
第一种方式：class.forname()
1、静态方法
2、方法的参数是一个字符串。
3、字符串需要的是一个完整类名。
4、完整类名必须带有包名。java.lang包也不能省略。
*/
class c1 = class.forname("java.lang.string"); // c1代表string.class文件，或者说c1代表string类型。
class c2 = class.forname("java.lang.integer"); // c2代表integer类型
class c3 = class.forname("java.util.date"); // c3代表date类型
// 第二种方式：java中任何一个对象都有一个方法：getclass()
string a = "abc";
class c4 = a.getclass(); // c4代表string.class字节码文件；c4代表string类型。
system.out.println(c4 == c1);//true（==判断的是对象的内存地址。）
date time = new date();
class c5 = time.getclass();
system.out.println(c5 == c3);//true(c5和c3两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件。)
// 第三种方式：java语言中任何一种类型，包括基本数据类型，它都有.class属性。
class i = integer.class; //i代表integer类型
class d = date.class; // d代表date类型
class f = float.class; //f代表float类型
system.out.println(i == c2);//true
}
}
/*
获取到class，能干什么？
通过class的newinstance()方法来实例化对象。
注意：newinstance()方法内部实际上调用了无参数构造方法，必须保证无参构造存在才可以。
*/
class reflecttest02{
public static void main(string[] args) throws classnotfoundexception, instantiationexception, illegalaccessexception {
// 下面这段代码是以反射机制的方式创建对象。
// 通过反射机制，获取class，通过class来实例化对象
class c = class.forname("javase.reflectbean.user");
// newinstance() 这个方法会调用user这个类的无参数构造方法，完成对象的创建。
// 重点是：newinstance()调用的是无参构造，必须保证无参构造是存在的！
object obj = c.newinstance();
system.out.println(obj);
}
}
/*
验证反射机制的灵活性。
java代码写一遍，再不改变java源代码的基础之上，可以做到不同对象的实例化。
非常之灵活。（符合ocp开闭原则：对扩展开放，对修改关闭。）
*/
class reflecttest03{
public static void main(string[] args) throws exception{
// 以下代码是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建出不同的实例对象。
// 通过io流读取reflectclassinfo.properties文件
filereader reader = new filereader("practice/reflectclassinfo1.properties");
// 创建属性类对象map
properties pro = new properties();// key value都是string
//加载
pro.load(reader);
reader.close();
// 通过key获取value
string classname = pro.getproperty("classname");
// 通过反射机制实例化对象
class c = class.forname(classname);
object obj = c.newinstance();
system.out.println(obj);
}
}
/*
研究一下：class.forname()发生了什么？
记住，重点：
如果你只是希望一个类的静态代码块执行，其它代码一律不执行，
你可以使用：
class.forname("完整类名");
这个方法的执行会导致类加载，类加载时，静态代码块执行。
提示：
后面jdbc技术的时候我们还需要。
*/
class reflecttest04{
public static void main(string[] args) throws classnotfoundexception {
// class.forname()这个方法的执行会导致：类加载。
class.forname("javase.myclass");
}
}
class myclass{
static {
system.out.println("myclass中的静态代码块执行了！");
}
}
/*
研究一下文件路径的问题。
怎么获取一个文件的绝对路径。以下讲解的这种方式是通用的。但前提是：文件需要在类路径下。才能用这种方式。
*/
class aboutpath{
public static void main(string[] args) throws filenotfoundexception {
// 这种方式的路径缺点是：移植性差，在idea中默认的当前路径是project的根。
// 这个代码假设离开了idea，换到了其它位置，可能当前路径就不是project的根了，这时这个路径就无效了。
file reader = new file("practice/src/reflectclassinfo2.properties");
system.out.println(reader.exists() " " reader.getpath());
// 接下来说一种比较通用的一种路径。即使代码换位置了，这样编写仍然是通用的。
// 注意：使用以下通用方式的前提是：这个文件必须在类路径下。
// 什么类路径下？方式在src下的都是类路径下。【记住它】
// src是类的根路径。
/*
解释：
thread.currentthread() 当前线程对象
getcontextclassloader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
getresource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
*/
string path = thread.currentthread().getcontextclassloader().getresource("reflectclassinfo2.properties").getpath();
// 采用以上的代码可以拿到一个文件的绝对路径。
// /d:/996-codesection/001-idea/0.javase/testproject/out/production/practice/reflectclassinfo2.properties
system.out.println(path);
string path2 = thread.currentthread().getcontextclassloader().getresource("javase/reflectbean/db.properties").getpath();
// /d:/996-codesection/001-idea/0.javase/testproject/out/production/practice/javase/reflectbean/db.properties
system.out.println(path2);
}
}
class iopropertiestest{
public static void main(string[] args) throws ioexception {
//以前
/*string path = thread.currentthread().getcontextclassloader().getresource("reflectclassinfo2.properties").getpath();
filereader reader = new filereader(path);*/
//现在
// 直接以流的形式返回。
inputstream reader = thread.currentthread().getcontextclassloader().getresourceasstream("reflectclassinfo2.properties");
properties pro = new properties();
pro.load(reader);
reader.close();
// 通过key获取value
string classname = pro.getproperty("classname");
system.out.println(classname);// java.util.date
}
}
/*
java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下。
*/
class resourcebundletest{
public static void main(string[] args) {
// 资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
// 并且在写路径的时候，路径后面的扩展名不能写。
// resourcebundle bundle = resourcebundle.getbundle("reflectclassinfo2");
resourcebundle bundle = resourcebundle.getbundle("javase/reflectbean/db");
string classname = bundle.getstring("classname");
system.out.println(classname);
}
}
/*
反射student类当中所有的field（了解一下）
*/
class reflecttest05{
public static void main(string[] args) throws exception {
class studentclass = class.forname("javase.reflectbean.student");
string classname = studentclass.getname();// class类的getname方法
system.out.println("完整类名： " classname);
string simplename = studentclass.getsimplename();// class类的getname方法
system.out.println("简类名： " simplename);
//获取public修饰的属性
field[] fields1 = studentclass.getfields();
system.out.println(fields1.length);// 2
system.out.println(fields1[0].getname() " " fields1[1].getname()); //field类中的getname犯法
system.out.println("----------------------");
//获取所有的属性
field[] fields2 = studentclass.getdeclaredfields();
system.out.println(fields2.length);
for (field f : fields2){
system.out.println(f.getname());
}
system.out.println("----------------------");
//获取属性的修饰符列表
for (field f : fields2){
// 获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号
// 用modifier类的tostring转换成字符串
system.out.println(modifier.tostring(f.getmodifiers()));
system.out.println(f.gettype().getsimplename());// 获取属性的类型
system.out.println(f.getname());// 获取属性的名字
}
}
}
//通过反射机制，反编译一个类的属性field（了解一下）
class reflecttest06{
public static void main(string[] args) throws classnotfoundexception {
stringbuilder s = new stringbuilder();
class studentclass = class.forname("javase.reflectbean.student");
s.append(modifier.tostring(studentclass.getmodifiers()) " class " studentclass.getsimplename() " {\n");// class类的getname方法
//获取所有的属性
field[] fields = studentclass.getdeclaredfields();
for (field f : fields){
s.append("\t");
// 获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号
// 用modifier类的tostring转换成字符串
s.append(modifier.tostring(f.getmodifiers()));
if (f.getmodifiers() != 0) s.append(" ");
s.append(f.gettype().getsimplename());// 获取属性的类型
s.append(" ");
s.append(f.getname());// 获取属性的名字
s.append(";\n");
}
s.append("}");
system.out.println(s);
}
}
/*
必须掌握：
怎么通过反射机制访问一个java对象的属性？
给属性赋值set
获取属性的值get
*/
class reflecttest07{
public static void main(string[] args) throws exception {
//不使用反射机制给属性赋值
student student = new student();
/**给属性赋值三要素：给s对象的no属性赋值1111
* 要素1：对象s
* 要素2：no属性
* 要素3：1111
*/
student.no = 1111;
/**读属性值两个要素：获取s对象的no属性的值。
* 要素1：对象s
* 要素2：no属性
*/
system.out.println(student.no);
//使用反射机制给属性赋值
class studentclass = class.forname("javase.reflectbean.student");
object obj = studentclass.newinstance();// obj就是student对象。（底层调用无参数构造方法）
// 获取no属性（根据属性的名称来获取field）
field nofield = studentclass.getdeclaredfield("no");
// 给obj对象(student对象)的no属性赋值
/*
虽然使用了反射机制，但是三要素还是缺一不可：
要素1：obj对象
要素2：no属性
要素3：22222值
注意：反射机制让代码复杂了，但是为了一个“灵活”，这也是值得的。
*/
nofield.set(obj, 22222);
// 读取属性的值
// 两个要素：获取obj对象的no属性的值。
system.out.println(nofield.get(obj));
// 可以访问私有的属性吗？
field namefield = studentclass.getdeclaredfield("name");
// 打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会！！！）
// 这样设置完之后，在外部也是可以访问private的。
namefield.setaccessible(true);
// 给name属性赋值
namefield.set(obj, "xiaowu");
// 获取name属性的值
system.out.println(namefield.get(obj));
}
}
/*
作为了解内容（不需要掌握）：
反射method
*/
class reflecttest08{
public static void main(string[] args) throws classnotfoundexception {
class userserviceclass = class.forname("javase.reflectbean.userservice");
// 获取所有的method（包括私有的！）
method[] methods = userserviceclass.getdeclaredmethods();
for (method m : methods){
// 获取修饰符列表
system.out.println(modifier.tostring(m.getmodifiers()));
// 获取方法的返回值类型
system.out.println(m.getreturntype().getsimplename());
// 获取方法名
system.out.println(m.getname());
// 方法的修饰符列表（一个方法的参数可能会有多个。）
class[] parametertypes = m.getparametertypes();
for (class pts : parametertypes){
system.out.println(pts.getsimplename());
}
system.out.println("------------------------");
}
}
}
/*
了解一下，不需要掌握（反编译一个类的方法。）
*/
class reflecttest09{
public static void main(string[] args) throws classnotfoundexception {
stringbuilder s = new stringbuilder();
class userserviceclass = class.forname("java.lang.string");
s.append(modifier.tostring(userserviceclass.getmodifiers()));
s.append(" class ");
s.append(userserviceclass.getsimplename());
s.append(" {\n");
// 获取所有的method（包括私有的！）
method[] methods = userserviceclass.getdeclaredmethods();
for (method m : methods){
s.append("\t");
// 获取修饰符列表
s.append(modifier.tostring(m.getmodifiers()));
s.append(" ");
// 获取方法的返回值类型
s.append(m.getreturntype().getsimplename());
s.append(" ");
// 获取方法名
s.append(m.getname());
s.append("(");
// 方法的修饰符列表（一个方法的参数可能会有多个。）
class[] parametertypes = m.getparametertypes();
for (int i = 0; i < parametertypes.length; i ){
s.append(parametertypes[i].getsimplename());
if (i != parametertypes.length - 1) s.append(", ");
}
s.append(") {}\n");
}
s.append("}");
system.out.println(s);
}
}
/*
重点：必须掌握，通过反射机制怎么调用一个对象的方法？
五颗星*****
反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中，
将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，
但是java代码不需要做任何改动。这就是反射机制的魅力。
*/
class reflecttest10{
public static void main(string[] args) throws exception {
// 不使用反射机制，怎么调用方法
// 创建对象
userservice userservice = new userservice();
// 调用方法
/*
要素分析：
要素1：对象userservice
要素2：login方法名
要素3：实参列表
要素4：返回值
*/
system.out.println(userservice.login("admin", "123") ? "登入成功！" : "登入失败！");
//使用反射机制调用方法
class userserviceclass = class.forname("javase.reflectbean.userservice");
// 创建对象
object obj = userserviceclass.newinstance();
// 获取method
method loginmethod = userserviceclass.getdeclaredmethod("login", string.class, string.class);
// method loginmethod = userserviceclass.getdeclaredmethod("login");//注：没有形参就不传
// 调用方法
// 调用方法有几个要素？ 也需要4要素。
// 反射机制中最最最最最重要的一个方法，必须记住。
/*
四要素：
loginmethod方法
obj对象
"admin","123" 实参
retvalue 返回值
*/
object resvalues = loginmethod.invoke(obj, "admin", "123");//注：方法返回值是void 结果是null
system.out.println(resvalues);
}
}
/*
反编译一个类的constructor构造方法。
*/
class reflecttest11{
public static void main(string[] args) throws classnotfoundexception {
stringbuilder s = new stringbuilder();
class vipclass = class.forname("javase.reflectbean.vip");
//public class userservice {
s.append(modifier.tostring(vipclass.getmodifiers()));
s.append(" class ");
s.append(vipclass.getsimplename());
s.append("{\n");
constructor[] constructors = vipclass.getdeclaredconstructors();
for (constructor c : constructors){
//public vip(int no, string name, string birth, boolean sex) {
s.append("\t");
s.append(modifier.tostring(c.getmodifiers()));
s.append(" ");
// s.append(c.getname());//包名 类名
s.append(vipclass.getsimplename());//类名
s.append("(");
class[] parametertypes = c.getparametertypes();
for (int i = 0; i < parametertypes.length; i ){
s.append(parametertypes[i].getsimplename());
if (i != parametertypes.length - 1 ) s.append(", ");
}
s.append("){}\n");
}
s.append("}");
system.out.println(s);
}
}
/*
比上一个例子(reflecttest11)重要一些！！！
通过反射机制调用构造方法实例化java对象。（这个不是重点）
*/
class reflecttest12{
public static void main(string[] args) throws exception {
//不适用反射创建对象
vip vip1 = new vip();
vip vip2 = new vip(123, "zhangsan", "2001-10-19", false);
//使用反射机制创建对象（以前）
class vipclass = class.forname("javase.reflectbean.vip");
// 调用无参数构造方法
object obj1 = vipclass.newinstance();//class类的newinstance方法
system.out.println(obj1);
//使用反射机制创建对象（现在）
// 调用有参数的构造方法怎么办？
// 第一步：先获取到这个有参数的构造方法
constructor c1 = vipclass.getdeclaredconstructor(int.class, string.class, string.class, boolean.class);
// 第二步：调用构造方法new对象
object obj2 = c1.newinstance(321, "lsi", "1999-10-11", true);//constructor类的newinstance方法
system.out.println(obj2);
// 获取无参数构造方法
constructor c2 = vipclass.getdeclaredconstructor();
object obj3 = c2.newinstance();
system.out.println(obj3);
}
}
/*
重点：给你一个类，怎么获取这个类的父类，已经实现了哪些接口？
*/
class reflecttest13{
public static void main(string[] args) throws exception{
// string举例
class vipclass = class.forname("java.lang.string");
// 获取string的父类
class superclass = vipclass.getsuperclass();
// 获取string类实现的所有接口（一个类可以实现多个接口。）
class[] interfaces = vipclass.getinterfaces();
system.out.println(superclass.getname());
for (class i : interfaces) {
system.out.println(i.getname());
}
}
}