java高级——反射

反射概述
反射的使用
- 获取class对象的三种方式
- 反射获取类的构造器
- - 1. 获取类中所有的构造器
  - 2. 获取单个构造器
- 反射获取构造器的作用
- 反射获取成员变量
- 反射变量赋值、取值
- 获取类的成员方法
- 反射对象类方法执行
反射简易框架案例
- 案例需求
- 实现步骤
- 代码如下

反射概述

什么是反射
反射技术，指的是加载类的字节码到内存，并以编程的方法解刨出类中的各个成分（成员变量、方法、构造器等）。
反射的作用

基本作用：可以得到一个类的全部成分然后操作。
可以破坏封装性。
最重要的用途是：适合做Java的框架，基本上，主流的框架都会基于反射设计出一些通用的功能。

如：IDEA通过反射技术就可以获取到类中有哪些方法，并且把方法的名称以提示框的形式显示出来，所以你能看到这些提示了。

反射技术怎么用
获取类的信息、操作它们

反射第一步：加载类，获取类的字节码：Class对象
获取类的构造器：Constructor对象
获取类的成员变量：Field对象
获取类的成员方法：Method对象

反射的使用

反射的第一步：是将字节码加载到内存，我们需要获取到的字节码对象。

获取class对象的三种方式

Class c1= 类名.class
调用Class提供方法：public static Class forName(String package);
Object提供的方法：public Class getclass(); Class c3= 对象.getclass();

代码示例：
有一个Student类，获取Student类的字节码代码有三种写法。不管用哪一种方式，获取到的字节码对象其实是同一个。

public class Test1Class{
    public static void main(String[] args){
        Class c1 = Student.class;
        System.out.println(c1.getName()); //获取全类名 com.tx.www.Student
        System.out.println(c1.getSimpleName()); //获取简单类名 Student
        
        Class c2 = Class.forName("com.tx.www.Student");
        System.out.println(c1 == c2); //true
        
        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c2 == c3); //true
    }
}

反射获取类的构造器

获取构造器，需要用到Class类提供的几个方法，如下图所示：

假设现在有一个Cat类，里面有几个构造方法，代码如下

public class Cat{
    private String name;
    private int age;
    
    public Cat(){
        
    }
    
    private Cat(String name, int age){
        
    }
}

1. 获取类中所有的构造器

public class Test2Constructor{
    @Test
    public void testGetConstructors(){
        //1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        
        //2、获取类的全部构造器
        Constructor[] constructors = c.getDeclaredConstructors();
        //3、遍历数组中的每一个构造器对象。
        for(Constructor constructor: constructors){
            System.out.println(constructor.getName()+"---> 参数个数："+constructor.getParameterCount());
        }
    }
}

运行测试方法打印结果如下

2. 获取单个构造器

public class Test2Constructor {
    @Test
    public void testGetConstructor() throws NoSuchMethodException {
        //1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;

        //2、获取类public修饰的空参数构造器
        Constructor constructor1 = c.getConstructor();
        System.out.println(constructor1.getName()+"---> 参数个数："+constructor1.getParameterCount());

        //3、获取private修饰的有两个参数的构造器，第一个参数String类型，第二个参数int类型
        Constructor constructor2 = c.getDeclaredConstructor(String.class,int.class);

        System.out.println(constructor2.getName()+"---> 参数个数："+constructor2.getParameterCount());

    }
}

反射获取构造器的作用

构造器的作用：初始化对象并返回。
这里我们需要用到如下的两个方法，注意：这两个方法时属于Constructor的，需要用Constructor对象来调用。

如下图所示，constructor1和constructor2分别表示Cat类中的两个构造器。现在我要把这两个构造器执行起来
由于构造器是private修饰的，可以调用setAccessible(true) 表示禁止检查访问控制，然后再调用newInstance(实参列表) 就可以执行构造器，完成对象的初始化了。
代码如下

注意：这也体现了反射可以破坏java的封装性。

反射获取成员变量

Class提供了从类中获取成员变量的方法。

使用示例如下：
新建一个Cat对象类

public class Cat {
    public static int a;
    public static final String COUNTRY = "中国";
    private String name;
    private int age;
 
    public Cat(){
        System.out.println("无参数构造器执行了~~");
    }
 
    private Cat(String name, int age) {
        System.out.println("有参数构造器执行了~~");
        this.name = name;
        this.age = age;
    }
 
    private void run(){
        System.out.println("🐱跑的贼快~~");
    }
 
    public void eat(){
        System.out.println("🐱爱吃猫粮~");
    }
 
    private String eat(String name){
        return "🐱最爱吃:" + name;
    }
 
    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 "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试获取成员变量方法

public class Test3Field {
    @Test
    public void testGetFields() throws Exception {
        // 1、反射第一步：必须是先得到类的Class对象
        Class c = Cat.class;
        // 2、获取类的全部成员变量。
        Field[] fields = c.getDeclaredFields();
        // 3、遍历这个成员变量数组
        for (Field field : fields) {
            System.out.println(field.getName() +  "---> "+ field.getType());
        }
        // 4、定位某个成员变量
        Field fName = c.getDeclaredField("name");
        System.out.println(fName.getName() + "--->" + fName.getType());
 
        Field fAge = c.getDeclaredField("age");
        System.out.println(fAge.getName() + "--->" + fAge.getType());
 
        // 赋值
        Cat cat = new Cat();
        fName.setAccessible(true); // 禁止访问控制权限
        fName.set(cat, "卡菲猫");
        System.out.println(cat);
 
        // 取值
        String name = (String) fName.get(cat);
        System.out.println(name);
    }
}

运行完上面的代码之后，我们可以看到控制台上打印输出了，每一个成员变量的名称和它的类型。

反射变量赋值、取值

获取到成员变量的作用：依然是赋值、取值。
在Filed类中提供给给成员变量赋值和获取值的方法

注意：设置值、获取值的方法时Filed类的需要用Filed类的对象来调用，而且不管是设置值、还是获取值，都需要依赖于该变量所属的对象。
示例代码如下

执行结果如下：

获取类的成员方法

Class提供了从类中获取成员方法的APl。

示例代码如下：

public class Test3Method{
    public static void main(String[] args){
        //1、反射第一步：先获取到Class对象
        Class c = Cat.class;
        
        //2、获取类中的全部成员方法
        Method[] methods = c.getDeclaredMethods();
        
        //3、遍历这个数组中的每一个方法对象
        for(Method method : methods){
            System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType());
        }
    }
}

执行上面的代码，运行结果如下图所示：打印输出每一个成员方法的名称、参数格式、返回值类型

也能获取单个指定的成员方法，如下图所示

反射对象类方法执行

成员方法的作用：依然是执行

把run()方法和eat(String name)方法执行起来。（看分割线之下的代码）

public class Test3Method{
    public static void main(String[] args) throws Exception{
	   	//1、反射第一步：先获取到Class对象
	    Class c = Cat.class;
	
	    //2、获取类中的全部成员方法
	    Method[] methods = c.getDeclaredMethods();
	
	    //3、遍历这个数组中的每一个方法对象
	    for(Method method : methods){
	        System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType());
	    }
	
	    System.out.println("-----------------------");
	    //4、获取private修饰的run方法，得到Method对象
	    Method run = c.getDeclaredMethod("run");
	    //执行run方法,在执行前需要取消权限检查
	    Cat cat = new Cat();
	    run.setAccessible(true);
	    Object rs1 = run.invoke(cat);
	    System.out.println(rs1);// null
	
	    //5、获取private 修饰的eat(String name)方法，得到Method对象
	    Method eat = c.getDeclaredMethod("eat",String.class);
	    eat.setAccessible(true);
	    Object rs2 = eat.invoke(cat,"鱼儿");
	    System.out.println(rs2);//(>^ω^<)喵爱吃:鱼儿
	}
}

执行结果如下

-----------------------
空参数构造方法执行了
(>^ω^<)喵跑得贼快~~
null
(>^ω^<)喵爱吃:鱼儿

反射简易框架案例

案例需求

案例需求：对于任意一个对象，该框架都可以把对象的字段名和对应的值，保存到文件中去。

实现步骤

1.先写好两个类，一个Student类和Teacher类
2.写一个ObjectFrame类代表框本架
	在ObjectFrame类中定义一个saveObject(Object obj)方法，用于将任意对象存到文件中去
	参数：Object obj: 就表示要存入文件中的对象
3.编写方法内部的代码，往文件中存储对象的属性名和属性值
	(1)每收到一个对象后，使用反射获取该对象的Class对象，然后获取全部的成员变量。
	(2)遍历成员变量，然后提取成员变量在该对象中的具体值。
	(3)把成员变量名、和其值，写出到文件中去即可。

代码如下

ObjectFrame表示自己设计的框架

public class ObjectFrame{
    public static void saveObject(Object obj) throws Exception{
        PrintStream ps =
                new PrintStream(new FileOutputStream("src\\data.txt",true));//字节打印流
        //1)每收到一个对象后，使用反射获取该对象的Class对象，然后获取全部的成员变量。
        //2)遍历成员变量，然后提取成员变量在该对象中的具体值。
        Class c = obj.getClass(); //获取字节码
        ps.println("---------"+c.getSimpleName()+"---------");

        Field[] fields = c.getDeclaredFields(); //获取所有成员变量
        //3)把变量名和变量值写到文件中去
        for(Field field : fields){
            String name = field.getName();
            field.setAccessible(true);//禁止访问检查
            String value = field.get(obj)+"";
            ps.println(name +  "=" + value);
        }
        ps.close();
    }
}

使用自己设计的框架，往文件中写入Student对象的信息和Teacher对象的信息。
先准备好Student类和Teacher类

public class Student{
    private String name;
    private int age;
    private char sex;
    private double height;
    private String hobby;
}


public class Teacher{
    private String name;
    private double salary;
}

在测试中类创建一个Student对象，创建一个Teacher对象，用ObjectFrame的方法把这两个对象所有的属性名和属性值写到文件中去。

public class Test5Frame{
    @Test
    public void save() throws Exception{
        Student s1 = new Student("吴彦祖",45, '男', 185.3, "篮球，冰球，阅读");
        Teacher s2 = new Teacher("播妞",999.9);

        ObjectFrame.saveObject(s1);
        ObjectFrame.saveObject(s2);
    }
}