Java（单元测试，反射）

单元测试、反射

一、单元测试

1.1 单元测试快速入门

所谓单元测试，就是针对最小的功能单元，编写测试代码对其进行正确性测试。
我们想想，咱们之前是怎么进行测试的呢？
比如说我们写了一个学生管理系统，有添加学生、修改学生、删除学生、查询学生等这些功能。要对这些功能这几个功能进行测试，我们是在main方法中编写代码来测试的。
但是在main方法中写测试代码有如下的几个问题，如下图所示：

 
 
 
为了测试更加方便，有一些第三方的公司或者组织提供了很好用的测试框架，给开发者使用。这里给同学们介绍一种Junit测试框架。
Junit是第三方公司开源出来的，用于对代码进行单元测试的工具（IDEA已经集成了junit框架）。相比于在main方法中测试有如下几个优点。

 
 
 
我们知道单元测试是什么之后，接下来带领同学们使用一下。由于Junit是第三方提供的，所以我们需要把jar包导入到我们的项目中，才能使用，具体步骤如下图所示：

 
 
 
接下来，我们就按照上面的步骤，来使用一下.
先准备一个类，假设写了一个StringUtil工具类，代码如下

1. public class StringUtil{
2.     public static void printNumber(String name){
3.         System.out.println("名字长度："+name.length());
4.     }
5. }

复制代码

 
接下来，写一个测试类，测试StringUtil工具类中的方法能否正常使用。

1. public class StringUtilTest{
2.     @Test
3.     public void testPrintNumber(){
4.         StringUtil.printNumber("admin");
5.         StringUtil.printNumber(null);
6.     }
7. }

复制代码

 
写完代码之后，我们会发现测试方法左边，会有一个绿色的三角形按钮。点击这个按钮，就可以运行测试方法。

 
 
 
1.2 单元测试断言

接下来，我们学习一个单元测试的断言机制。所谓断言：意思是程序员可以预测程序的运行结果，检查程序的运行结果是否与预期一致。
我们在StringUtil类中新增一个测试方法

1. public static int getMaxIndex(String data){
2.      if(data == null){
3.          return -1;
4.      }
5.      return data.length();
6. }

复制代码

 
接下来，我们在StringUtilTest类中写一个测试方法

1. public class StringUtilTest{
2.     @Test
3.     public void testGetMaxIndex(){
4.        int index1 = StringUtil.getMaxIndex(null);
5.        System.out.println(index1);
6.         
7.        int index2 = StringUtil.getMaxIndex("admin");
8.        System.out.println(index2);
9.         
10.         //断言机制：预测index2的结果
11.         Assert.assertEquals("方法内部有Bug",4,index2);
12.     }
13. }

复制代码

 
运行测试方法，结果如下图所示，表示我们预期值与实际值不一致

 
 
 
1.3 Junit框架的常用注解

同学们，刚才我们以及学习了@Test注解，可以用来标记一个方法为测试方法，测试才能启动执行。
除了@Test注解，还有一些其他的注解，我们要知道其他注解标记的方法什么时候执行，以及其他注解在什么场景下可以使用。

 
 
 
接下来，我们演示一下其他注解的使用。我们在StringUtilTest测试类中，再新增几个测试方法。代码如下

1. public class StringUtilTest{
2.     @Before
3.     public void test1(){
4.         System.out.println("--> test1 Before 执行了");
5.     }
6.     @BeforeClass
7.     public static void test11(){
8.         System.out.println("--> test11 BeforeClass 执行了");
9.     }
10.     @After
11.     public void test2(){
12.         System.out.println("--> test2 After 执行了");
13.     }
14.     @AfterClass
15.     public static void test22(){
16.         System.out.println("--> test22 AfterCalss 执行了");
17.     }
18. }

复制代码

 
执行上面的测试类，结果如下图所示，观察执行结果特点如下

1. 1.被@BeforeClass标记的方法,执行在所有方法之前<br>2.被@AfterCalss标记的方法，执行在所有方法之后<br>3.被@Before标记的方法，执行在每一个@Test方法之前<br>4.被@After标记的方法，执行在每一个@Test方法之后

复制代码

 
 
 
我们现在已经知道每一个注解的作用了，那他们有什么用呢？应用场景在哪里?
我们来看一个例子，假设我想在每个测试方法中使用Socket对象，并且用完之后，需要把Socket关闭。代码就可以按照下面的结构来设计

1. public class StringUtilTest{
2.     private static Socket socket;
3.     @Before
4.     public void test1(){
5.         System.out.println("--> test1 Before 执行了");
6.     }
7.     @BeforeClass
8.     public static void test11(){
9.         System.out.println("--> test11 BeforeClass 执行了");
10.         //初始化Socket对象
11.         socket = new Socket();
12.     }
13.     @After
14.     public void test2(){
15.         System.out.println("--> test2 After 执行了");
16.     }
17.     @AfterCalss
18.     public static void test22(){
19.         System.out.println("--> test22 AfterCalss 执行了");
20.          //关闭Socket
21.         socket.close();
22.     }
23. }

复制代码

 
 
二、反射

 
什么是反射。其实API文档中对反射有详细的说明，我们去了解一下。在java.lang.reflect包中对反射的解释如下图所示

 
 
 
翻译成人话就是：反射技术，指的是加载类的字节码到内存，并以编程的方法解刨出类中的各个成分（成员变量、方法、构造器等）。
反射有啥用呢？其实反射是用来写框架用的，但是现阶段同学们对框架还没有太多感觉。为了方便理解，我给同学们看一个我们见过的例子：平时我们用IDEA开发程序时，用对象调用方法，IDEA会有代码提示，idea会将这个对象能调用的方法都给你列举出来，供你选择，如果下图所示

 
 
 
问题是IDEA怎么知道这个对象有这些方法可以调用呢? 原因是对象能调用的方法全都来自于类，IDEA通过反射技术就可以获取到类中有哪些方法，并且把方法的名称以提示框的形式显示出来，所以你能看到这些提示了。
 
为反射获取的是类的信息，那么反射的第一步首先获取到类才行。由于Java的设计原则是万物皆对象，获取到的类其实也是以对象的形式体现的，叫字节码对象，用Class类来表示。获取到字节码对象之后，再通过字节码对象就可以获取到类的组成成分了，这些组成成分其实也是对象，其中每一个成员变量用Field类的对象来表示、每一个成员方法用Method类的对象来表示，每一个构造器用Constructor类的对象来表示。
如下图所示：

 
 
 
1.1 获取类的字节码

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

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

1. public class Test01_Class {
2. ​
3.     public static void main(String[] args) throws ClassNotFoundException {
4.         /*
5.           字节码文件对象获取三种方式
6.          */
7.         //1:根据类名.class
8.         Class c1 = Student.class;
9.         System.out.println(c1);
10.         System.out.println(c1.getName());// 获取全类名  包名+类名
11.         System.out.println(c1.getSimpleName());// 获取简单类名
12. ​
13.         //2:根据类的全路径 (包名+类名)获取
14.         Class c2 = Class.forName("com.itheima.d2_reflect.Student");
15.         // c1 c2 是不是一个对象？ 类只加载一次！！
16.         System.out.println(c1==c2);
17. ​
18.         //3:得到对象之后，通过对象的方法获取 运行时类
19.         Student stu = new Student();
20.         Class c3= stu.getClass();
21.         System.out.println(c1==c3);
22.     }
23. }
24. ​

复制代码

 
 
1.2 获取类的构造器

同学们，上一节我们已经可以获取到类的字节码对象了。接下来，我们学习一下通过字节码对象获取构造器，并使用构造器创建对象。
获取构造器，需要用到Class类提供的几个方法，如下图所示：

 
 
 
想要快速记住这个方法的区别，给同学们说一下这些方法的命名规律，按照规律来记就很方便了。

1. get:获取<br>Declared: 有这个单词表示可以获取任意一个，没有这个单词表示只能获取一个public修饰的<br>Constructor: 构造方法的意思<br>后缀s: 表示可以获取多个，没有后缀s只能获取一个

复制代码

话不多少，上代码。假设现在有一个Cat类，里面有几个构造方法，代码如下

1. public class Cat{
2.     private String name;
3.     private int age;
4.    
5.     public Cat(){
6.         
7.     }
8.    
9.     private Cat(String name, int age){
10.         
11.     }
12. }

复制代码

 

• 
  
  • 接下来，我们写一个测试方法，来测试获取类中所有的构造器
     
    
  
  

1.   @Test
2.     public void testGetConstructors(){
3.         // 反射第一步 获取字节码对象
4.         Class c= Cat.class;
5. ​
6.         // 获取 所有的 public 修饰的 构造器
7. //        Constructor[] constructors = c.getConstructors();
8. //        System.out.println(constructors.length);
9. //        for (Constructor constructor : constructors) {
10. //            System.out.println("构造器全称:"+constructor);
11. //            System.out.println("构造器名称:"+constructor.getName());//获取构造器的名字
12. //            System.out.println("参数个数:"+constructor.getParameterCount());
13. //        }
14.         // 获取 所有存在的 构造器 (无所谓修饰符)
15.         Constructor[] constructors = c.getDeclaredConstructors();
16.         System.out.println("总共:"+constructors.length+"个构造器");
17.         for (Constructor constructor : constructors) {
18.             System.out.println("构造器全称:"+constructor);
19.             System.out.println("构造器名称:"+constructor.getName());//获取构造器的名字
20.             System.out.println("参数个数:"+constructor.getParameterCount());
21.             System.out.println("==============================");
22.         }
23. ​
24.     }

复制代码

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

 
 
 

• 
  
  • 刚才演示的是获取Cat类中所有的构造器，接下来，我们演示单个构造器试一试
    
  
  

1. //获取指定的构造器
2.     @Test
3.     public void testContructor() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
4.         // 获取构造器(方法 )  是不需要指定名字的 因为构造方法名字是类名！！！
5. ​
6.         //第一步 获取 字节码对象
7.         Class c = Cat.class;
8.         //获取 无参这个构造器  public
9.         Constructor constructor1 = c.getConstructor();
10.         //打印构造器 相关信息
11.         System.out.println("构造器全称:"+constructor1);
12.         System.out.println("构造器名称:"+constructor1.getName());//获取构造器的名字
13.         System.out.println("参数个数:"+constructor1.getParameterCount());
14. ​
15.         Cat cat1 = (Cat)constructor1.newInstance();
16.         System.out.println("查看对象:"+cat1);
17.         System.out.println("==============================");
18.         // String类型？String.class
19. ​
20.         //获取两个参数的构造器   忽略修饰符
21.         Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class);
22.         //() 参数的顺序和类型来匹配指定的构造器
23.         System.out.println("构造器全称:"+constructor2);
24.         System.out.println("构造器名称:"+constructor2.getName());//获取构造器的名字
25.         System.out.println("参数个数:"+constructor2.getParameterCount());
26.         //针对私有的成员 需要绕过权限访问
27.        constructor2.setAccessible(true);
28.        Cat cat2 =(Cat)constructor2.newInstance("小花",3);//参数 俩 第一个参数String,第二个是int
29.         System.out.println(cat2);
30.     }

复制代码

 
打印结果如下

 
 
 
 
1.3 反射获取构造器的作用

同学们，刚才上一节我们已经获取到了Cat类中的构造器。获取到构造器后，有什么作用呢？
其实构造器的作用：初始化对象并返回。
这里我们需要用到如下的两个方法，注意：这两个方法时属于Constructor的，需要用Constructor对象来调用。

 
 
 
如下图所示，constructor1和constructor2分别表示Cat类中的两个构造器。现在我要把这两个构造器执行起来

 
 
 
由于构造器是private修饰的，先需要调用setAccessible(true) 表示禁止检查访问控制，然后再调用newInstance(实参列表) 就可以执行构造器，完成对象的初始化了。
代码如下：为了看到构造器真的执行， 故意在两个构造器中分别加了两个打印语句

 
 
 
代码的执行结果如下图所示：

 
 
 
 
1.4 反射获取成员变量&使用

同学们，上一节我们已经学习了获取类的构造方法并使用。接下来，我们再学习获取类的成员变量，并使用。
其实套路是一样的，在Class类中提供了获取成员变量的方法，如下图所示。

 
 
 
这些方法的记忆规则，如下

1. get:获取<br>Declared: 有这个单词表示可以获取任意一个，没有这个单词表示只能获取一个public修饰的<br>Field: 成员变量的意思<br>后缀s: 表示可以获取多个，没有后缀s只能获取一个

复制代码

• 假设有一个Cat类它有若干个成员变量，用Class类提供 的方法将成员变量的对象获取出来。
  

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

 
 
 

1.  

复制代码

1. public class Test03_Field {
2. ​
3.     @Test
4.     public void getFields() throws NoSuchFieldException, IllegalAccessException {
5.        //获取所有的属性
6.        // 1:获取字节码对象
7.        Class c = Cat.class;
8.        //2:获取所有的成员属性
9.         Field[] fields = c.getDeclaredFields();
10.         //3：遍历得到每个成员属性的 对象形式
11.         for (Field field : fields) {
12.             System.out.println("全称:"+field+" 查小名:"+field.getName()+" 属性的类型:"+field.getType());
13.         }
14.         System.out.println("=========================");
15.         // 需求 对某个对象的某个属性完成 赋值  取值
16.         Cat cat = new Cat();
17.         //   给cat对象的 name 属性 赋值  "加菲猫"
18.         //   给cat对象的 age 属性 赋值  3
19.         //  通过反射方式 找到指定的属性对象
20.         Field fName = c.getDeclaredField("name");
21.         Field fAge= c.getDeclaredField("age");
22. ​
23.         // 只要是在反射形式调用 可以绕过权限检查
24.         fName.setAccessible(true);
25.         fAge.setAccessible(true);
26.         // 完成 赋值
27. //        fName  fAge  属性的对象形式
28.          fName.set(cat,"加菲猫");
29.          fAge.set(cat,3);
30. ​
31.         System.out.println(cat);
32.         // 获取到 指定对象的指定属性的值？  cat.getName() cat.name
33.         //属性对象反向调用
34.         String name = (String) fName.get(cat);//cat.name
35.         System.out.println(name);
36.     }
37. }
38. ​

复制代码

 

1.  

复制代码

 

• 获取到成员变量的对象之后该如何使用呢？
  

在Filed类中提供给给成员变量赋值和获取值的方法，如下图所示。

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

 
 
 
执行代码，控制台会有如下的打印

 
 
 
 
1.5 反射获取成员方法

各位同学，上面几节我们已经学习了反射获取构造方法、反射获取成员变量，还剩下最后一个就是反射获取成员方法并使用了。
在Java中反射包中，每一个成员方法用Method对象来表示，通过Class类提供的方法可以获取类中的成员方法对象。如下下图所示

 
 
 
接下来我们还是用代码演示一下：假设有一个Cat类，在Cat类中红有若干个成员方法
[code]public class Cat{    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("(>^ω^^ω^^ω^