Junit单元测试、反射

Junit单元测试：

测试分类：

1. 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。功能测试。
2. 白盒测试：需要写代码的。关注程序具体的执行流程。
3. 灰盒测试：既有一些功能使用黑盒测试又有一些功能白盒测试。

Junit使用：白盒测试

1. 定义一个测试类(测试用例)

   测试类名：被测试的类名Test CalculatorTest

   包名：xxx.xxx.xx.test com.xxx.test

2. 定义测试方法：可以独立运行

   方法名：test测试的方法名 testAdd()

   返回值：void

   参数列表：空参

3. 给方法加@Test

4. 导入junit依赖环境(在包下创建lib文件夹，导入所需要的包，右键Add as Library...)

• 判定结果：
  • 红色：失败
  • 绿色：成功
  • 一般我们会使用断言操作来处理结果
    • Assert.assertEquals(期望的结果，运算的结果);

@Before：修饰的方法会在测试方法之前被自动执行

@After：修饰的方法会在测试方法执行之后自动被执行

public class Test {
    @After
    public void aa(){
        System.out.println("aaaa");
    }
    @Before
    public void bb(){
        System.out.println("bbbb");
    }

    @org.junit.Test
    public void a(){
        int sum = MathUtil.sum(3, 4);

        Assert.assertEquals(7,sum);
        System.out.println(sum);
    }
}

反射：框架设计的灵魂

框架：半成品软件。可以在框架的基础上进行软件开发，简化编码

反射：将类的各个组成部分封装为其他对象，这就是反射机制

好处：

	1. 可以在程序运行过程中，操作这些对象。
	2. 可以解耦，提高程序的可扩展性。

高内聚低耦合（提高类独自完成某一件事的能力，不需要调用其他的类，降低其他类。）

获取Class对象的方式：

• Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象
  • 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
• 类名.class：通过类名的属性class获取
  • 多用于参数的传递
• 对象.getClass()：getClass()方法在Object类中定义着。
  • 多用于对象的获取字节码的方式

同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

Class对象功能：

获取功能：

• 获取成员变量们
  • Field[] getFields() ：获取所有public修饰的成员变量
  • Field getField(String name) 获取指定名称的 public修饰的成员变量
  • Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
  • Field getDeclaredField(String name)
• 获取构造方法们
  • Constructor<?>[] getConstructors()
  • Constructor getConstructor(类<?>… parameterTypes)
  • Constructor getDeclaredConstructor(类<?>… parameterTypes)
  • Constructor<?>[] getDeclaredConstructors()
• 获取成员方法们：
  • Method[] getMethods()
  • Method getMethod(String name, 类<?>… parameterTypes)
  • Method[] getDeclaredMethods()
  • Method getDeclaredMethod(String name, 类<?>… parameterTypes)
• 获取全类名
  • String getName()

Field：成员变量

• 设置值
  • void set(Object obj, Object value)
• 获取值
  • get(Object obj)
• 忽略访问权限修饰符的安全检查
  • setAccessible(true):暴力反射
• 获取变量名称：
  • String getName:获取变量名

Constructor:构造方法

• 创建对象：
  • T newInstance(Object… initargs)
  • 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

Method：方法对象

• 执行方法：
  • Object invoke(Object obj, Object… args)
• 获取方法名称：
  • String getName:获取方法名

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

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

//    public Student() {
//    }
    public void say(){
        System.out.println("hello");
    }
    private void say(String a){
        System.out.println("hello"+a);
    }
    public String getName(){
        return name;
    }
}

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
//        Student student = new Student();
        /*student.name="李四";
        System.out.println(student.getName());
        student.say();*/

        //获取字节码文件
        //1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
        //    * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
        Class<?> aClass = Class.forName("com.sibd.pojo.Student");
        //2. 类名.class：通过类名的属性class获取
        //    * 多用于参数的传递
        /*Class<Student> aClass1 = Student.class;
        //3. 对象.getClass()：getClass()方法在Object类中定义着。
        //    * 多用于对象的获取字节码的方式
        Class<? extends Student> aClass2 = student.getClass();
        System.out.println(aClass==aClass1);
        System.out.println(aClass1==aClass2);*/

        //空参构造器
        /*Constructor<?> constructor = aClass.getConstructor();
        Student student1 = (Student) constructor.newInstance();
        student1.say();
*/
        //实参构造器
        Constructor<?> constructor1 = aClass.getConstructor(String.class,Integer.class);
        Student student2 = (Student) constructor1.newInstance("张三", 15);
//        student2.say();

        //获取属性
        /*Field name = aClass.getField("name");
        name.set(student2,"李四");
        System.out.println(name.get(student2));

        Field[] fields = aClass.getFields();
        for (Field f :fields) {
            if(f.getName()=="age"){
                System.out.println(f.get(student2));
            }else if(f.getName()=="name"){
                System.out.println(f.get(student2));
            }
        }*/

        //获取私有属性(暴力反射)
        /*Field age = aClass.getDeclaredField("age");
        age.setAccessible(true);
        age.set(student2,15);
        System.out.println(age.get(student2));*/

        //获取空参方法
        Method say = aClass.getMethod("say");
        say.invoke(student2);
        //获取实参方法
        /*Method say1 = aClass.getMethod("say",String.class);
        say1.invoke(student2,"java");*/
        //获取私有方法
        Method say1 = aClass.getDeclaredMethod("say",String.class);
        say1.setAccessible(true);
        say1.invoke(student2,"java");

        Method[] methods = aClass.getMethods();
        for (Method m: methods) {
            if(m.getName().equals("getName")){
                String invoke = (String) m.invoke(student2);
                System.out.println(invoke);
            }
        }
    }
}

写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

public class Factory {
    private static Properties properties = new Properties();
    static {
        try {
            properties.load(new FileInputStream("a.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public Object getObject() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        String className = (String) properties.get("class");
        Class<?> aClass = Class.forName(className);
        Method method = aClass.getMethod((String) properties.get("method"));
        Constructor<?> constructor = aClass.getConstructor();
        method.invoke(constructor.newInstance());
        return constructor.newInstance();
    }
}

打包为jar文件，并导入项目中

public class Reflect0813Test {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
//        Factory.getObject//静态方法
        //非静态方法
        Factory factory = new Factory();
        Student student = (Student) factory.getObject();
        student.say();
    }
}

//a.properties文件
class=com.sibd.pojo.Student
method=say