Junit测试、反射

1.1 测试
1.2 反射
- 获取Class的三种方式
- Class对象功能

1.1 测试

测试分类：

黑盒测试：不看代码，进行输入参数，查看输出结果是否符合要求
白盒测试：能够参考代码执行过程

步骤
1.定义一个测试类（测试用例）

建议：测试类名：被测试的类名+Test： CalculatorTest 包名：xxx.xxx.xx.test： cn.itcast.test

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

建议：方法名：test+测试的方法名： testAdd() 返回值：void 参数列表：空参

3.给方法加@Test
4.倒入Junit的依赖文件
结果
绿色：成功
红色：失败
一般会使用断言操作来处理结果
Assert.assertEquals(expected,result);
*断言

//3断言，断言结果为3
Assert.assertEquals(3,result);
//期望值为3，真实值为result
结果：
java.lang.AssertionError: 
Expected :3
Actual   :-1
<Click to see difference>

补充
@Before:
修饰的方法会在测试方法之前被自动执行
@After：
修饰的方法会在测试方法执行之后自动被执行

/*
    * 初始化方法：
    *   用于资源申请，所有测试方法在执行之前都会先执行该方法
    */
    @Before
    public void init(){
        System.out.println("init....");
    }
    /*
    * 释放资源都方法：
    *   在所有测试方法执行完成后，都会自动执行该方法
    */
    @After
    public void close(){
        System.out.println("closed...");
    }

1.2 反射

反射也被成为 “框架设计的灵魂”
框架：半成品软件
可以在框架的基础上进行软件开发，简化编码。
概念
将类的各个组成部分封装为其他对象，这就是反射机制
好处

在程序的运行过程中操作一些对象（Class对象阶段的Class对象）

例如：通过InteliJ软件可以在写代码的阶段调用各种方法
截屏2020-07-27 09.58.23.png

可以解耦，降低程序耦合性，提高程序的可拓展性

获取Class的三种方式
class.forName(“全类名”):将字节码文件加载进内存，返回class对象

Tips：全类名是指：包名+类名，例如：code.junit.domain.Person 该方法多用于配置文件，将类名定义在配置文件中，读取文件，加载类
类名.class : 通过类名的属性class来获取

该方法多用于参数的传递
对象.getClass()：getClass()方法在Object类中定义

多用于对象的获取字节码的方式

创建一个Person类

public class Person {
    private String name;
    private int age;
//....省略构造方法和getset
}

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class.forName
        Class<?> cls1 = Class.forName("code.junit.domain.Person");
        System.out.println(cls1);//class code.junit.domain.Person
        //2.类名.Class
        Class cls2=Person.class;
        System.out.println(cls2);//class code.junit.domain.Person
        //3.对象.getClass()
        Person p=new Person();
        Class cls3=p.getClass();
        System.out.println(cls3);//class code.junit.domain.Person
        //==比较三个对象
        System.out.println(cls1 == cls2);//true
        System.out.println(cls1 == cls3);//true
    }
}

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

Class对象功能

*获取功能

获取成员变量们

Field[] getFields() :获取所有public修饰的成员变量
Field getField(String name) ：获取指定名称的public修饰的成员变量
Field[] getDeclaredFields() :获取所有成员变量，不考虑修饰符
Field getDeclaredField(String name)

获取构造方法们

Constructor<?>[] getConStructors()
Constructor<T> getConstructor(类<?> ... parameterTypes)
Constructor<?>[] getDeclaredConStructors()
Constructor<T> getDeclaredConstructor(类<?> ... parameterTypes)

获取成员方法们

Method[] getMethods()
Method getMethod(String name, 类<?>... parameterTypes)
Method[] getDeclaredMethods()
Method getDeclaredMethod(String name, 类<?>... parameterTypes)

获取类名

String getName()

成员变量
操作：
1.设置值： void set(Object obj,Object value) ：obj是指成员所在的对象名
2.获取值: get (Object obj) ：obj是值该成员变量所在的对象名
3.忽略访问权限修饰符的安全检查(暴力反射)
setAccessible(true)

  public static void main(String[] args) throws Exception {
        //1 获取Person的class对象
        Class<Person> cls = Person.class;
        // 获取成员变量：
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("-----------");
        Field a = cls.getField("a");
        System.out.println(a);
        //获取成员变量a的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);//null
        //设置值
        a.set(p,"雨落");
        System.out.println(p.a);//雨落
        System.out.println("----------");
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field f : declaredFields) {
            System.out.println(f);
        }
        System.out.println("-----------");
        Field d = cls.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);//null
    }

构造方法：
创建对象
T newInstance(Object... initargs) initargs:参数

//1 获取Person的class对象
        Class<Person> cls = Person.class;
        //获取构造方法
        Constructor<Person> constructor = cls.getConstructor(String.class, int.class);
        System.out.println(constructor);
        //创建对象
        Object person = constructor.newInstance("雨落", 19);
        System.out.println(person);
//输出：
//public code.junit.domain.Person(java.lang.String,int)
//Person{name='雨落', age=19}
        System.out.println("---------");
        Constructor<Person> constructor1 = cls.getConstructor();//空参
        System.out.println(constructor1);
        //创建对象
        Object person1 = constructor1.newInstance();//空参
        System.out.println(person1);
//输出：
//public code.junit.domain.Person()
//Person{name='null', age=0}

如果使用空参数构造方法创建对象，操作可以简化：Class对象的 newInstance 方法

//1 获取Person的class对象
        Class<Person> cls = Person.class;
        Object o = cls.newInstance();
        System.out.println(o);

1.1 测试

1.2 反射

获取Class的三种方式

Class对象功能