java 反射

1.什么是反射？

1.反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法。
2.反射可以在一个类运行的时候获取类的信息的机制，可以获取在编译期不可能获得的类的信息。
3.对于任意一个对象，都能调用它的任意一个方法和属性。
4.因为类的信息是保存在Class对象中的，而这个Class对象是在程序运行时被类加载器（ClassLoader）动态加载的。
5.当类加载器装载运行了类后，动态获取Class对象的信息以及动态操作Class对象的属性和方法的功能称为Java语音的反射机制

2.获取Class对象的三种方法
（1）Object类的getClass()方法
（2）类的静态属性
（3）Class类的静态方法

package FansheDemo;

public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
    //获取Class对象
    //方式一Object类的getClass()方法
    Student stu = new Student();
    Class clazz1 = stu.getClass();
    //方式二类的静态属性
   Class clazz2 = Student.class;
    //方式三Class类的静态方法
    Class clazz3 =Class.forName("FansheDemo.Student");

    System.out.println(clazz1==clazz2);//true
    System.out.println(clazz2==clazz3);//true


}
}

3.反射方式获取构造方法并使用

（1）.生成学生类对象

package FansheDemo2;

public class Student {
//公共无参构造
public Student() {
}

//公共带参构造
public Student(String name){
    System.out.println("你录入的name值是："+name);
}

//私有的带参构造
private Student(int age){
    System.out.println("你录入的age的值为："+age);
}
}

（2）.测试类

package FansheDemo2;

import java.lang.reflect.Constructor;

public class Reflect {
public static void main(String[] args)throws Exception {
    //通过反射的方式创建
    //1.获取Student类的字节码文件对象
    Class clazz = Class.forName("FansheDemo2.Student");
    //2.根据上一步获取的字节码文件对象，获取指定的构造对象
    //2.1 获取公共无参构造
    Constructor con1 = clazz.getEnclosingConstructor();
    System.out.println(con1);
    //2.2获取公共带参构造
    Constructor con2 = clazz.getConstructor(String.class);
    System.out.println(con2);
    //2.3获取私有的带参构造(注意与有参稍有不同)
    Constructor con3 = clazz.getDeclaredConstructor(int.class);
    System.out.println(con3);
    //2.4获取Student类的全部公共构造
    Constructor[] con = clazz.getConstructors();
    //遍历数组
    for (Constructor c : con) {
        System.out.println(c);
    }
    //3.获取构造器的名字，查看为那个类的构造
    String name = con2.getName();
    System.out.println(name);
    //根据构造器的对象和参数，创建对应的Student对象
    Student stu =(Student) con2.newInstance("张三");
    System.out.println(stu);
}
}

4.通过反射方式获取成员方法并使用

（1)学生类

package FansheDemo3;

public class Student {
//公共空参方法
public void show1(){
    System.out.println("我是公共的空参方法");

}
//公共的带参方法
public void show2(int a){
    System.out.println("我是公共的带参方法，传入的值为："+a);
}
//私有的带参方法
private int show3(int a, int b){
    System.out.println("我是私有的带参方法");
    return a+b;
}
 }

（2）测试类

package FansheDemo3;

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

public class Test {
public static void main(String[] args) throws Exception {
    //需求:通过反射获取Student类中的方法并调用
    //1.获取Student类的字节文件对象
    Class clazz = Class.forName("FansheDemo3.Student");
    //2.获取该类的构造器对象，创建Student类的对象
  Constructor con = clazz.getConstructor();
  Student stu= (Student)con.newInstance();//向下转型
    //3.获取该类的成员方法对象，然后调用方法
    //3.1调用公共的空参方法
    Method method1 = clazz.getMethod("show1");
    System.out.println(method1);
    System.out.println(method1.getName());
    method1.invoke(stu);
    System.out.println("--------------------");
    //3.2调用公共的带参方法
    Method method2 = clazz.getMethod("show2", int.class);
    method2.invoke(stu,100);
    System.out.println("--------------------");
    //3.3调用私有的带参构造
   Method method3= clazz.getDeclaredMethod("show3", int.class, int.class);
   //开启暴力放射，忽略私有
    method3.setAccessible(true);
    int sum=(int)method3.invoke(stu,2,5);
    System.out.println("你录入的两个数值之和为："+sum);
    System.out.println("--------------------");
    //3.4获取Student类的所有的成员方法
    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        System.out.println(method);
    }


}
 }

4.1使用案例:通过反射获取类的Setter方法，使用该方法为属性赋值
(1)标准的学生类

package FansheDemo4;

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

public Student() {
}

public Student(String name, int age) {
    this.name = name;
    this.age = age;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

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

（2）测试类

package FansheDemo4;

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

public class Test {
public static void main(String[] args) throws Exception{
    //通过反射获取类的Setter方法，使用该方法为属性赋值
    //1.获取Student类的字节文件对象
    Class clazz = Class.forName("FansheDemo4.Student");
    //2.获取该类的构造器对象，创建Student类的对象
        Constructor con = clazz.getConstructor();
        Student stu = (Student)con.newInstance();
    //3.获取指定的setName,给Student对象设置值
    Method method1 = clazz.getMethod("setName", String.class);
    method1.invoke(stu,"唐三");
    System.out.println(stu);
    Method method2 = clazz.getMethod("setAge", int.class);
    method2.invoke(stu,5);
    System.out.println(stu);

}
}

5.反射的方法获取成员变量并使用

（1）学生类

 package FansheDemo5;

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

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

（2）测试类

package FansheDemo5;

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

public class Test {
public static void main(String[] args) throws Exception {
    //1.获取Student类的字节文件对象
    Class clazz = Class.forName("FansheDemo5.Student");
    //2.通过获取到的字节对象获取构造器对象，创建Student对象
   Constructor con = clazz.getConstructor();
   Student stu=(Student) con.newInstance();
   //3.设置学生对象的属性;
    //设置名字;
    Field field1 = clazz.getField("name");
    field1.set(stu,"唐三");
    //设置年级
    Field field2 = clazz.getDeclaredField("age");
    field2.setAccessible(true);
    field2.set(stu,55);

    System.out.println(stu);

}
 }