1、反射介绍
reflection(反射) 是 java 程序开发语言的特征之一，它允许运行中的 java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，但反射能直接操作类私有属性。反射可以在运行时获取一个类的所有信息，（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。
要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是class类中的方法。所以先要获取到每一个字节码文件对应的class类型的对象。
反射就是把java类中的各种成分映射成一个个的java对象。
例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把一个个组成部分映射成一个个对象。（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
加载的时候：class对象的由来是将 .class 文件读入内存，并为之创建一个class对象。
class类
class 类的实例表示正在运行的 java 应用程序中的类和接口。也就是jvm中有n多的实例每个类都有该class对象。（包括基本数据类型）
class 没有公共构造方法。class 对象是在加载类时由 java 虚拟机以及通过调用类加载器中的defineclass 方法自动构造的。也就是这不需要我们自己去处理创建，jvm已经帮我们创建好了。
我们知道spring框架可以帮我们创建和管理对象。需要对象时，我们无需自己手动new对象，直接从spring提供的容器中的beans获取即可。beans底层其实就是一个map
bean
1、java面向对象，对象有方法和属性，那么就需要对象实例来调用方法和属性（即实例化）；
2、凡是有方法或属性的类都需要实例化，这样才能具象化去使用这些方法和属性；
3、规律：凡是子类及带有方法或属性的类都要加上注册bean到spring ioc的注解；（@component , @repository , @ controller , @service , @configration）
4、把bean理解为类的代理或代言人（实际上确实是通过反射、代理来实现的），这样它就能代表类拥有该拥有的东西了
5、在spring中，你标识一个@符号，那么spring就会来看看，并且从这里拿到一个bean（注册）或者给出一个bean（使用）
2.1 获取类对应的字节码的对象（三种）
① 调用某个类的对象的getclass()方法，即：对象.getclass()；
person p = new person();
class clazz = p.getclass();注意：此处使用的是object类中的getclass()方法，因为所有类都继承object类，所以调用object类中的getclass()方法来获取。
② 调用类的class属性类获取该类对应的class对象，即：类名.class
class clazz = person.class;③ 使用class类中的forname()静态方法（最安全，性能最好）即：class.forname(“类的全路径”)
class clazz = class.forname("类的全路径");注意：在运行期间，一个类，只有一个class对象产生。
三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。
2.2 常用方法
当我们获得了想要操作的类的class对象后，可以通过class类中的方法获取和查看该类中的方法和属性。
//获取包名、类名
clazz.getpackage().getname()//包名
clazz.getsimplename()//类名
clazz.getname()//完整类名
//获取成员变量定义信息
getfields()//获取所有公开的成员变量,包括继承变量
getdeclaredfields()//获取本类定义的成员变量,包括私有,但不包括继承的变量
getfield(变量名)
getdeclaredfield(变量名)
//获取构造方法定义信息
getconstructor(参数类型列表)//获取公开的构造方法
getconstructors()//获取所有的公开的构造方法
getdeclaredconstructors()//获取所有的构造方法,包括私有
getdeclaredconstructor(int.class,string.class)
//获取方法定义信息
getmethods()//获取所有可见的方法,包括继承的方法
getmethod(方法名,参数类型列表)
getdeclaredmethods()//获取本类定义的的方法,包括私有,不包括继承的方法
getdeclaredmethod(方法名,int.class,string.class)
//反射新建实例
clazz.newinstance();//执行无参构造创建对象
clazz.newinstance(222,"韦小宝");//执行有参构造创建对象
clazz.getconstructor(int.class,string.class)//获取构造方法
//反射调用成员变量
clazz.getdeclaredfield(变量名);//获取变量
clazz.setaccessible(true);//使私有成员允许访问
f.set(实例,值);//为指定实例的变量赋值,静态变量,第一参数给null
f.get(实例);//访问指定实例变量的值,静态变量,第一参数给null
//反射调用成员方法
method m = clazz.getdeclaredmethod(方法名,参数类型列表);
m.setaccessible(true);//使私有方法允许被调用
m.invoke(实例,参数数据);//让指定实例来执行该方法3.1 测试物料类
创建包: com.reflection
创建类: student.java*
package com.review;
/*本类用于复习反射的物料类*/
public class student {
//1.定义成员变量
private string name;
public int age;
//2.给被封装属性提供get与set方法
public string getname() {
return name;
}
public void setname(string name) {
this.name = name;
}
//3.生成本类的无参构造与全参构造
public student(){}
public student(string name, int age) {
this.name = name;
this.age = age;
}
//4.提供本类的普通方法
public void play(){
system.out.println("不玩游戏，学java！");
}
public void sunday(int n){
system.out.println("卷起来，没有假！");
}
//5.为了查看学生对象的具体属性与属性值，重写tostring()
@override
public string tostring() {
return "student{"
"name='" name '\''
", age=" age
'}';
}
}3.2 获取类对象
由于经常使用的是第三种方法，所以以下使用第三种。
创建包: com.reflection
创建类: testreflect.java
/*本类用于反射的测试*/
public class testreflect {
//1.可以创建程序的入口函数main()--此处不用
//2.通过单元测试方法，获取目标类student对应的字节码对象
@test
public void getclazz() throws classnotfoundexception {
//练习获取字节码对象的3种方式
class clazz1 = class.forname("com.review.student");
class clazz2 = student.class;
class clazz3 = new student().getclass();
//打印的是student类对应的字节码对象
system.out.println(clazz1);//class com.reflection.student
//获取student类对应的字节码对象clazz1的名字
system.out.println(clazz1.getname());//com.reflection.student
//通过student类对应的字节码对象，获取student类的类名
system.out.println(clazz1.getsimplename());
//通过student类对应的字节码对象，获取student类对应的包对象
system.out.println(clazz1.getpackage());
//通过student类对应的字节码对象，先获取student类对应的包对象，再获取这个包对象的名字
system.out.println(clazz1.getpackage().getname());
}
}3.3 获取成员变量
/**本类用来测试反射*/
public class testreflect {
//3.通过单元测试方法练习引用类型数组的定义与遍历
@test
public void getstu() {
//1.创建student类的3个对象
student s1 = new student("张三", 3);
student s2 = new student("李四", 4);
student s3 = new student("王五", 5);
//2.创建数组将刚刚的3个对象存入数组中
student[] s = {s1, s2, s3};
//3.直接打印数组，查看数组中的元素
system.out.println(arrays.tostring(s));
//4.遍历学生数组，拿到每一个学生对象，做进一步的操作
for (student stu : s) {
//system.out.println(stu);
stu.play();//通过遍历到的对象，执行play()
system.out.println(stu.age);//通过遍历到的对象，打印age属性
}
}
//4.通过单元测试方法，获取student类中的成员变量
@test
public void getfie() throws classnotfoundexception {
//1.获取student类对应的字节码对象
class clazz = class.forname("com.review.student");
//2.通过student类对应的字节码对象获取student类中的成员变量们
field[] fs = clazz.getfields();
//3.遍历数组，获取student类中的每个成员变量的具体信息
/*注意！目前成员变量的修饰符必须是public的才能获取到*/
for(field f : fs){
system.out.println(f.getname());//通过本轮循环到的字段对象获取字段名
system.out.println(f.gettype());//通过本轮循环到的字段对象获取字段的类型
}
}
}3.4 通过字节码对象获取类的成员方法
/**本类用来测试反射*/
public class testreflect {
//5.通过单元测试方法，获取student类中的成员方法
@test
public void getfunction() {
//1.获取student类对应的字节码对象
class clazz = class.forname("com.review.student");
//2.通过student类对应的字节码对象获取student类中的成员方法们
method[] ms = clazz.getmethods();
//3.通过高效for循环遍历数组，拿到每一个方法对象
for (method m : ms) {
system.out.println(m);//直接打印遍历到的方法对象
system.out.println(m.getname());//通过方法对象获取方法名
class[] pt = m.getparametertypes();//通过方法对象获取方法所有参数的数组
system.out.println(arrays.tostring(pt));//打印方法参数的数组
}
}
}3.5 通过字节码对象获取类的构造方法
/**本类用来测试反射*/
public class testreflect {
//6.通过单元测试方法，获取student类中的构造方法
@test
public void getcons() {
//1.获取字节码对象
class clazz = class.forname("com.review.student");
//2.通过字节码对象获取目标类student的构造方法们
constructor[] cs = clazz.getconstructors();
//3.通过高效for循环遍历数组
for(constructor c : cs){
system.out.println(c.getname());//打印本轮遍历到的构造方法的名字
class[] pt = c.getparametertypes();//通过本轮遍历到的构造函数对象获取构造函数的参数类型
system.out.println(arrays.tostring(pt));//打印参数类型
}
}
}/**本类用来测试反射*/
public class testreflect {
//7.通过单元测试方法，创建student目标类的对象
@test
public void getobject() throws exception {
//1.获取字节码对象
class clazz = class.forname("com.review.student");
//2.通过反射技术创建目标类的对象,注意抛出异常
/*反射创建对象方案1：
使用 目标类 的 无参构造 创建对象
*/
object o = clazz.newinstance();
system.out.println(o);//这一步已经获取到了对象student{name='null', age=0}
/*反射创建对象方案2：
使用 目标类 的 全参构造 创建对象
* 思路：
* 1.先获取指定的构造函数对象,注意需要指定构造函数的参数，传入的是.class字节码对象
* 2.通过刚刚获取到的构造函数对象创建student目标类的对象，并且给对象的属性赋值
* */
//3.获取目标类中指定的全参构造
constructor c = clazz.getconstructor(string.class, int.class);
//system.out.println(c);
//4.通过获取到的构造函数：创建对象 给对象的属性赋值
object o2 = c.newinstance("赵六", 6);
system.out.println(o2);
}
}