单元测试&反射机制（未完结）

单元测试

单元测试是指程序猿写的测试代码给自己的类中的方法进行预期正确性的验证

单元测试一旦写好了这些测试代码，就可以一直使用，可以实现一定程度上的自动化验证

单元测试一般是要使用框架进行

单元测试的经典框架：Junit

Junit是什么？

• Junit是Java语言编写的第三方单元测试框架
• Junit框架的方案可以帮助我们方便且快速的测试我们代码的正确性

单元测试概念

• 单元：在Java，一个类就是一个单元
• 单元测试：程序员用Junit编写的一小段代码，用来对某个方法进行功能测试或业务逻辑测试。

Junit单元测试框架的作用：

• 用来对类中的方法功能进行有目的的测试，以保证程序的正确性和稳定性
• 能够独立的测试某个方法或者所有方法的预期正确性

框架一般是jar包的形式，jar包里面都是class文件

测试类的命名规范

• 以Test开头，以业务类类名结尾，使用驼峰式命名规范

测试类的注意事项:

• 必须是public修饰的，没有返回值，没有参数
• 必须使注解@Test修饰

/**Junit常用注解(Junit 4.xxxx版本)
    * @Test 测试方法！
    * @Before：用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次。
    * @After：用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次。
    * @BeforeClass：用来静态修饰方法，该方法会在所有测试方法之前只执行一次。
    * @AfterClass：用来静态修饰方法，该方法会在所有测试方法之后只执行一次。

   开始执行的方法:初始化资源。
   执行完之后的方法:释放资源。

Junit常用注解(Junit5.xxxx版本)
    * @Test 测试方法！
    * @BeforeEach：用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次。
    * @AfterEach：用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次。
    * @BeforeAll：用来静态修饰方法，该方法会在所有测试方法之前只执行一次。
    * @AfterAll：用来静态修饰方法，该方法会在所有测试方法之后只执行一次。

例子

package com.fudao._01单元测试;

import org.junit.*;

public class UserServiceTest {
    UserService userService;
    // @Before：用来修饰实例方法，该方法会在每一个测试方法执行之前执行一次。
    @Before
    public void before(){
        userService = new UserService();
        System.out.println("===before===");

    }
    // @After：用来修饰实例方法，该方法会在每一个测试方法执行之后执行一次。
    @After
    public void after(){
        System.out.println("===after===");
    }

    // @BeforeClass：用来静态修饰方法，该方法会在所有测试方法之前只执行一次。
    @BeforeClass
    public static void beforeClass(){
        System.out.println("===beforeClass===");
    }

    // @AfterClass：用来静态修饰方法，该方法会在所有测试方法之后只执行一次。
    @AfterClass
    public static void afterClass(){
        System.out.println("===afterClass===");
    }


    /**
     * 测试方法的要求：
     *  1.必须public修饰
     *  2.没有返回值没有参数
     *  3. 必须使注解@Test修饰
     */
    @Test
    public void testLogin(){
//        UserService userService = new UserService();
        String rs = userService.login("admin","123456");
        // 断言预期结果的正确性。
        /**
         * 参数一：测试失败的提示信息。
         * 参数二：期望值。
         * 参数三：实际值
         */
        // public static void assertEquals(String message, Object expected, Object actual)
        
        Assert.assertEquals("登录业务功能方法有错误，请检查！","success",rs);
    }

    @Test
    public void testChu(){
//        UserService userService = new UserService();
        userService.chu(10 , 0);
    }
}

反射

反射是java独有的技术，是java技术显著的特点

反射是指对于任何一个类，在运行的时候 都可以直接得到这个类的全部成份

• 在运行时，可以直接得到这个类的构造器对象Constructor
• 在运行时，可以直接得到这个类的成员变量Field
• 在运行时，可以直接得到这个类的成员方法对象Method

反射的核心思想和关键就是得到：编译以后的class文件对象

反射提供了一个Class类型，就是可以得到编译以后的Class类对象

Class c = HelloWorld.class;

注意：反射是工作在运行时的技术，因为只有运行之后才会有class文件对象

Class：字节码文件的类型

Constructor:构造器的类型

Field：成员变量的类型

Method：方法的类型

反射技术的第一步永远是先得到Class类对象：三种方式 获取

1. 类名.class
2. 通过类的对象.getClass()方法
3. Class.forName(“类的全限名”)

Class类的方法：

String getSimoleName(); 获取类名字符串：类名

String getName() 获得类全名：包名+类名

例子

public class ReflectDemo01 {
    public static void main(String[] args) throws Exception {
        // 反射的第一步永远是先得到类的Class文件对象: 字节码文件。
        // 1.类名.class
        Class c1 = Student.class;
        System.out.println(c1);

        // 2.对象.getClass()
        Student swk = new Student();
        Class c2 = swk.getClass();
        System.out.println(c2);

        // 3.Class.forName("类的全限名")
        // 直接去加载该类的class文件。
        Class c3 = Class.forName("com.fudao._03反射_获取Class类对象.Student");
        System.out.println(c3);

        System.out.println(c1.getSimpleName()); // 获取类名本身（简名）
        System.out.println(c1.getName()); // 获取类的全限名
        // Student s1 = (Student) c1.newInstance(); // 调用无参数构造器得到对象，被淘汰了！

    }

}

反射中Class类型获取构造器提供了很多的API:
1. Constructor getConstructor(Class… parameterTypes)
根据参数匹配获取某个构造器，只能拿public修饰的构造器，几乎不用！
2. Constructor getDeclaredConstructor(Class… parameterTypes)
根据参数匹配获取某个构造器，只要申明就可以定位，不关心权限修饰符，建议使用！
3. Constructor[] getConstructors()
获取所有的构造器，只能拿public修饰的构造器。几乎不用！！太弱了！
4. Constructor[] getDeclaredConstructors()
获取所有申明的构造器，只要你写我就能拿到，无所谓权限。建议使用！！

小结：
获取类的全部构造器对象： Constructor[] getDeclaredConstructors()
– 获取所有申明的构造器，只要你写我就能拿到，无所谓权限。建议使用！！
获取类的某个构造器对象：Constructor getDeclaredConstructor(Class… parameterTypes)
– 根据参数匹配获取某个构造器，只要申明就可以定位，不关心权限修饰符，建议使用！

例子

public class TestStudent {
    // 1. getConstructors:
    // 获取全部的构造器：只能获取public修饰的构造器。
    // Constructor[] getConstructors()
    @Test
    public void getConstructors(){
        // a.反射第一步先得到Class类对象
        Class c = Student.class ;
        // b.getConstructors()：定位全部构造器，只能拿public修饰的！
        Constructor[] cons = c.getConstructors();
        // c.遍历这些构造器
        for (Constructor con : cons) {
            System.out.println(con.getName()+"===>"+con.getParameterCount());
        }
    }

    // 2.getDeclaredConstructors():
    // 获取全部的构造器：只要你敢写，这里就能拿到，无所谓权限是否可及。
    @Test
    public void getDeclaredConstructors(){
        // a.反射第一步先得到Class类对象
        Class c = Student.class ;
        // b.getDeclaredConstructors()：定位全部构造器，只要申明了就可以拿到
        Constructor[] cons = c.getDeclaredConstructors();
        // c.遍历这些构造器
        for (Constructor con : cons) {
            System.out.println(con.getName()+"===>"+con.getParameterCount());
        }
    }

    // 3.getConstructor(Class... parameterTypes)
    // 获取某个构造器：只能拿public修饰的某个构造器
    @Test
    public void getConstructor() throws Exception {
        // a.反射第一步先得到Class类对象
        Class c = Student.class ;
        // b.getConstructor()：定位某个构造器，根据参数匹配，只能拿public修饰的！
        // Constructor con = c.getConstructor(); // 报错!
        Constructor con = c.getConstructor(String.class  , int.class); // 有参数的！!
        // c.构造器名称和参数
        System.out.println(con.getName()+"===>"+con.getParameterCount());
    }

    // 4.getDeclaredConstructor
    // 获取某个构造器：只要你敢写，这里就能拿到，无所谓权限是否可及。
    @Test
    public void getDeclaredConstructor() throws Exception {
        // a.反射第一步先得到Class类对象
        Class c = Student.class ;
        // b.getDeclaredConstructor()：定位某个构造器，根据参数匹配，只要申明了就可以获取
        Constructor con = c.getDeclaredConstructor(); // 可以拿到！定位无参数构造器！
        //Constructor con = c.getDeclaredConstructor(String.class  , int.class); // 有参数的！!
        // c.构造器名称和参数
        System.out.println(con.getName()+"===>"+con.getParameterCount());
    }
}