反射（java)

一、junit单元测试框架

1、单元测试

就是针对最小的功能单元（方法），编写测试代码对其进行正确性测试。

之前的是如何进行单元测试的？有啥问题？

1、只能在ma方法编写测试代码，去调用其他方法进行测试。

2、无法实现自动化测试，一个方法测试失败，可能影响其他方法的测试。

3、无法的到测试报告，需要程序员自己去观察测试是否成功

public class Test
public static void main(String[]
//查向所有
R
1添加学生
addStudent（）；
11修改学生
updateStudent();
11删除学生
deleteStudent(）;
酒试删除学生
private staticvoid deleteStudent(）{...}
11测试修改学生
private static void updateStudent(){...}
1测试添加学生的方法
private static void addStudent(）{...}
11查询所有的学生生数据
private static void findAliStudent(){...}

Junit单元测试框架

可以用来对方法进行测试，它是第三方公司开源出来的（很多开发工具已经集成了Junit框架，比如IDEA）

优点：
1、可以灵活的编写测试代码，可以针对某个方法执行测试，也支持一键完成对全部方法的自动化测试，且各自独立。
2、不需要程序员去分析测试的结果，会自动生成测试报告出来。

需求:

某个系统，有多个业务方法，请使用junit单元测试框架，编写测试代码，完成对这些方法的正确性测试。

步骤：

1、将junit框架的jar包导入到项目中（注意：IDEA集成了junit框架，不需要我们自己手动导入）

2、为了需要测试的业务类，定义对应的测试类，并为每个业务方法编写对应的测试方法（必须：公共、无参、无返回值）

3、测试方法必须声明@Test注解，然后在测试方法中，编写代码调用被测试的业务方法进行测试

4、开始测试：选中测试方法，右键"Junit运行"如果测试通过则是绿色；如果测试失败，则是红色

例子：

package Demo01;

public class StringUtil {
    public static int getMaxIndex(String data) {
        if (data == null) {
            return -1;
        }
        return data.length();
    }


    //求字符串最大索引
    public static void printNumber(String name) {
        if (name == null) {
            System.out.println(0);
            return;
        }
        System.out.println("名字的长度是：" + name.length());
    }
}

package Demo01;


import org.junit.Assert;
import org.junit.Test;

public class StringUitlTest {

    //测试方法
    @Test
    public void testPrintNumbers() {
        StringUtil.printNumber("admin");
        StringUtil.printNumber(null);
    }

    //测试方法
    @Test
    public void testGetMaxIndex() {
        int index1 = StringUtil.getMaxIndex(null);
        System.out.println(index1);

        int index2 = StringUtil.getMaxIndex("admin");
        System.out.println(index2);

        //断言机制：程序员可以通过预测业务方法的结果
        Assert.assertEquals("方法内部有bug", 4, index2);
    }


}

断言机制：程序员可以通过预测业务方法的结果

运行结果：

修改正确的字符串返回值

运行结果正确：

Junit单元测试框架的常用用注解（unit4.xxxx版本）

注解	说明
@Test	测试类中的方法必须用它修饰才能成为测试方法，才能启动执行
@Before	用来修饰一个实例方法，该方法法会在每一个测试方法执行之前行一次。
@After	用来修饰一个静态方法，该方法会在所有测试方法之前只执行一次
@BeforeClass	用来修饰一分静态方法，该方法会在所有测试方法之前只执行一次
@AfterClass	用来修饰一分静态方法，该方法会在所有测试方法之后只执行一次

在测试方法执行前执行的方法，常用于：初始化资源。

在测试方法执行完后再执行的方法，常用于：释放资源。

package Demo01;

public class StringUtil {
    public static int getMaxIndex(String data) {
        if (data == null) {
            return -1;
        }
        return data.length()-1;
    }


    //求字符串最大索引
    public static void printNumber(String name) {
        if (name == null) {
            System.out.println(0);
            return;
        }
        System.out.println("名字的长度是：" + name.length());
    }
}

package Demo01;

import org.junit.*;

import java.net.Socket;

public class StringUitlTest {

    @Before
    public void test1() {
        System.out.println("--->test1 Before 执行了-----");

    }

    @BeforeClass
    public static void test11() {
        System.out.println("--->testBeforeClass 执行了-----");
    }

    @After
    public void test2() {
        System.out.println("--->test2 After 执行了-----");
    }

    @AfterClass
    public static void test22() {
        System.out.println("--->testAfterClass 执行了-----");
    }


    //测试方法
    @Test
    public void testPrintNumbers() {
        StringUtil.printNumber("admin");
        StringUtil.printNumber(null);
    }

    //测试方法
    @Test
    public void testGetMaxIndex() {
        int index1 = StringUtil.getMaxIndex(null);
        System.out.println(index1);

        int index2 = StringUtil.getMaxIndex("admin");
        System.out.println(index2);

        //断言机制：程序员可以通过预测业务方法的结果
        Assert.assertEquals("方法内部有bug", 4, index2);
    }
}

运行结果：

二、反射

1、认识反射，获取类

反射(Reflection)

反射：加载类，并允许以编程的方式解刨类中的各种成分（成员变量、方法、构造器等）。

反射学什么？

1、反射第一步：加载类，获取类的字节码：Class对象

2、获取类等构造器：Constructor对象

3、获取类的成员变量：Field对象

4、获取类的成员方法：Method对象

获取Class对象的三种方式

Class c1=类名.class

调用Class提供方法：public static Class forName(String package);

Object提供的方法：public Class getClass();；Class c3=对象.getClass()

package Demo02;

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;
    }
}

package Demo02;

public class Test1Class {
    public static void main(String[] args) throws Exception {
        Class c1 = Student.class;
        System.out.println(c1.getName());//全类名
        System.out.println(c1.getSimpleName());//简名：Student

        Class c2 = Class.forName("Demo02.Student");
        System.out.println(c1 == c2);

        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c3 == c2);
    }
}

2、获取类的构造器

Class提供了从类中获取构造器的方法

方法	说明
Constructor<?>[] getConstructors()	获取全部构造器（只能修改public修饰的）
Constructor<?>[] getDeclaredconstructors()	获取全部构造器（只要存在就能拿到）
Constructor<T> getConstructor(Class<?>...parameterTypes)	获取某个构造器（只能获取public修饰的）
Constructor<T> getDeclaredconstructor(Class<?>...parameterTypes)	获取某个构造器（只要存在就能拿到）

例子1：

package Demo02;

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

    public Cat() {
    }

    public Cat(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;
    }
}

package Demo02;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class Test2Constructor {
    @Test
    public void testGetConstructor() throws Exception {
        //1.反射第一步：必须得到这个类的Class对象
        Class c = Cat.class;
        //2.获取类的全部构造器
        Constructor[] constructors = c.getConstructors();
        for (Constructor constructor : constructors) {

            System.out.println(constructor.getName() + "--->"+constructor.getParameterCount());

        }
    }

}

例子2:修改Cat中的无参构造器为private

package Demo02;

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

    private Cat() {
    }

    public Cat(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;
    }
}

package Demo02;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class Test2Constructor {
    @Test
    public void testGetConstructor() throws Exception {
        //1.反射第一步：必须得到这个类的Class对象
        Class c = Cat.class;
        //2.获取类的全部构造器
//        Constructor[] constructors = c.getConstructors();

        Constructor[] constructors = c.getDeclaredConstructors();

        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "--->"+constructor.getParameterCount());
        }
    }

}

例子3:

package Demo02;

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

    public Cat() {
    }

    public Cat(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;
    }
}

package Demo02;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class Test2Constructor {
    @Test
    public void testGetConstructors() throws Exception {
        //1.反射第一步：必须得到这个类的Class对象
        Class c = Cat.class;
        //2.获取类的全部构造器
//        Constructor[] constructors = c.getConstructors();

        Constructor[] constructors = c.getDeclaredConstructors();

        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "--->" +
                    constructor.getParameterCount());
        }
    }

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

        //2.获取类的全部构造器
        Constructor constructor1 = c.getConstructor();
        System.out.println(constructor1.getName() + "--->" +
                constructor1.getParameterCount());

        //3.获取指定参数列表的构造器
        Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(constructor2.getName() + "--->" +
                constructor2.getParameterCount());
    }
}

获取类构造器的作用：依然是初始化对象返回

Constructor提供的方法	说明
T newInstance(object...initargs)	调用此构造器对象表示的构造器，并传入参数，完成对象的初始化并返回
public voidsetAccessible(boolean flag)	设置true，表示禁止检查访问控制（暴力反射）

例子：

package Demo02;

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

    private Cat() {
        System.out.println("无参构造器～");
    }

    public Cat(String name, int age) {
        System.out.println("有参构造器～");
        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 "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package Demo02;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Test2Constructor {
    @Test
    public void testGetConstructors() throws Exception {
        //1.反射第一步：必须得到这个类的Class对象
        Class c = Cat.class;
        //2.获取类的全部构造器
//        Constructor[] constructors = c.getConstructors();

        Constructor[] constructors = c.getDeclaredConstructors();

        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "--->" +
                    constructor.getParameterCount());
        }
    }

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

        //2.获取类的全部构造器
        Constructor constructor1 = c.getDeclaredConstructor();
        System.out.println(constructor1.getName() + "--->" +
                constructor1.getParameterCount());

//        constructor1.setAccessible(true);//禁止检查访问权限
        Cat cat = (Cat) constructor1.newInstance();
        System.out.println(cat);


        //3.获取指定参数列表的构造器
        Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class);
        System.out.println(constructor2.getName() + "--->" +
                constructor2.getParameterCount());
    }
}

运行结果：

原因分析：

Cat中的无参构造器的权限修饰符是private，需要禁止检查访问权限才可以正确运行。

3、获取类的成员变量

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

方法	说明
public Field[] fetFields()	获取类的全部成员变量（只能获取public修饰的）
public Field[] getDeclaredFields()	获取类的全部员变量（只要存在就能拿到）
public Field getField(String name)	获取类的某个成员变量（只能获取public修饰的）
public Fieldd getDeclaredField(String name)	获取类的某个成员变量（只要存在就能拿到）

例子：

package Demo02;

public class Cat {
    public static int a;
    public static final String COUNTRY = "中国";
    private String name;
    private int age;

    private Cat() {
        System.out.println("无参构造器～");
    }

    public Cat(String name, int age) {
        System.out.println("有参构造器～");
        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 "Cat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package Demo02;

import org.junit.Test;

import java.lang.reflect.Field;

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());
    }
}

获取成员变量的作用：依然是赋值、取值

方法	说明
void set(Object obj, object value):	赋值
object get(object obj)	取值
public voidsetAccessible(boolean flag)	设置为true，表示禁止检查访问控制（暴力反射

package Demo02;

import org.junit.Test;

import java.lang.reflect.Field;

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);
    }
}

4、获取类的成员方法

方法	说明
Method[] getMethods()	获取类的全部成员方法（只能获取public修饰的）
Method[] getDeclaredMethods()	获取类的全部成员方法（只要存在就能拿到）
Method getMethod(String name, Class<?>... parameterTypes)	获取类的成员方法（只能获取public修饰的）
MethodetDeclaredMethod(String name, Class<?>...parameterTypes)	获取类的某个成员方法（只要存在就能拿到）

例子1:

package Demo02;

import org.junit.Test;

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

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

        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName() + "--->" +
                               method.getParameterCount() + "--->" +
                               method.getReturnType());
        }
    }
}

package Demo02;

public class Cat {
    public static int a;
    public static final String COUNTRY = "中国";
    private String name;
    private int age;

    public Cat() {
        System.out.println("无参构造器～");
    }

    public Cat(String name, int age) {
        System.out.println("有参构造器～");
        this.name = name;
        this.age = age;
    }

    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 +
                '}';
    }
}

例子2:

package Demo02;

public class Cat {
    public static int a;
    public static final String COUNTRY = "中国";
    private String name;
    private int age;

    public Cat() {
        System.out.println("无参构造器～");
    }

    public Cat(String name, int age) {
        System.out.println("有参构造器～");
        this.name = name;
        this.age = age;
    }

    public 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 +
                '}';
    }
}

package Demo02;

import org.junit.Test;

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

public class Test3Method {
    @Test
    public void testGetMethods() 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());
        }
        //4、获取某个方法对象
        Method run = c.getDeclaredMethod("run");
        System.out.println(run.getName() + "--->" +
                run.getParameterCount() + "--->" +
                run.getReturnType());

        Method eat = c.getDeclaredMethod("eat", String.class);
        System.out.println(eat.getName() + "--->" +
                eat.getParameterCount() + "--->" +
                eat.getReturnType());
    }
}

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

Method提供的方法	说明
public Object invoke(object obj，object...args)	触发某个对象的该方法执行。
public voidsetAccessible(boolean flag)	设置为true，表示禁止检查访问控制（暴力反射）

例子：

package Demo02;

public class Cat {
    public static int a;
    public static final String COUNTRY = "中国";
    private String name;
    private int age;

    public Cat() {
        System.out.println("无参构造器～");
    }

    public Cat(String name, int age) {
        System.out.println("有参构造器～");
        this.name = name;
        this.age = age;
    }

    public 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 +
                '}';
    }
}

package Demo02;

import org.junit.Test;

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

public class Test3Method {
    @Test
    public void testGetMethods() 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());
        }
        //4、获取某个方法对象
        Method run = c.getDeclaredMethod("run");
        System.out.println(run.getName() + "--->" +
                run.getParameterCount() + "--->" +
                run.getReturnType());

        Method eat = c.getDeclaredMethod("eat", String.class);
        System.out.println(eat.getName() + "--->" +
                eat.getParameterCount() + "--->" +
                eat.getReturnType());

        Cat cat = new Cat();
        run.setAccessible(true);
        Object rs = run.invoke(cat);// 调用无参数的run方法，用cat对象触发实现的
        System.out.println(rs);
    }
}

例子：

package Demo02;

public class Cat {
    public static int a;
    public static final String COUNTRY = "中国";
    private String name;
    private int age;

    public Cat() {
        System.out.println("无参构造器～");
    }

    public Cat(String name, int age) {
        System.out.println("有参构造器～");
        this.name = name;
        this.age = age;
    }

    public 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 +
                '}';
    }
}

package Demo02;

import org.junit.Test;

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

public class Test3Method {
    @Test
    public void testGetMethods() 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());
        }
        //4、获取某个方法对象
        Method run = c.getDeclaredMethod("run");
        System.out.println(run.getName() + "--->" +
                run.getParameterCount() + "--->" +
                run.getReturnType());

        Method eat = c.getDeclaredMethod("eat", String.class);
        System.out.println(eat.getName() + "--->" +
                eat.getParameterCount() + "--->" +
                eat.getReturnType());

        Cat cat = new Cat();
        run.setAccessible(true);
        Object rs1 = run.invoke(cat);// 调用无参数的run方法，用cat对象触发实现的
        System.out.println(rs1);

        eat.setAccessible(true);
        String rs2 = (String) eat.invoke(cat, "鱼");
        System.out.println(rs2);

    }
}

5、反射的应用场景

反射的作用？

基本作用：可以的到一个类的全部成分然后操作。

可以破坏封装性。

最重要的用途是：适合做Java的框架，基本上，主流的框架都会基于反射设计出一些通用的功能

使用反射做一个简易版的框架

需求：

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

实现步骤：

1、定义一个方法，可以接收任意对象。

2、每收到一个对象后，使用反射获取该对象的Class对象，然后获取全部的成员变量。

3、遍历成员变量，然后提取成员变量在该对象中的具体值。

4、把成员变量名、和其值，写出到文件中去即可。

例子：

package Demo02;

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

    public Student() {
    }

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

    public Student(String name, int age, char sex, double height, String hobby) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.height = height;
        this.hobby = hobby;
    }

    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;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

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

package Demo02;

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

    public Teacher() {
    }

    public Teacher(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;
    }
}

package Demo02;

import org.junit.Test;

public class Test5Frame {
    @Test
    public void save() throws Exception {
        Student s1 = new Student("张三", 45, '男', 60, "打篮球");
        Teacher t1 = new Teacher("波妞", 99);

        //需求，把任意的对象的字段名和其对应的值等信息，保存到文件中去
        ObjectFrame.saveObject(s1);
        ObjectFrame.saveObject(t1);
    }
}

package Demo02;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;
import java.util.Objects;

public class ObjectFrame {
    //目标：保存任意字段和其数据到文件中
    public static void saveObject(Object obj) throws Exception {
        PrintStream ps = new PrintStream(new FileOutputStream("/Users/harry/JavaStudy/untitled/src/data.txt", true));

        // obj是任意对象，到底有多少个字段要保存
        Class c = obj.getClass();
        String cName = c.getSimpleName();
        ps.println("-----" + cName + "-----");

        // 1、从这个类中提取他的全部成员变量
        Field[] fields = c.getDeclaredFields();

        // 2、遍历每个成员变量
        for (Field field : fields) {

            // 3、获取到这个成员变量的值
            String name = field.getName();

            // 4、拿到这个成员变量在对象中的数据
            field.setAccessible(true);
            String value = field.get(obj) + "";
            ps.println(name + "=" + value);
        }
        ps.close();
    }
}

运行结果：