Java之Junit和反射

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java之Junit和反射，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8003字，纯文字阅读大概需要12分钟。

内容图文

Junit,反射

Junit

1.测试的分类:

黑盒测试 : 不需要写代码，给输入值，看程序是否能够输出期望的值。
白盒测试 : 需要进行代码的编写,关注的是程序的具体流程.

2.使用步骤(方法类的命名可以参考阿里巴巴开发手册):

        * 步骤：
    1. 定义一个测试类(测试用例)
        * 建议：
            * 测试类名：被测试的类名Test       
            * 包名：xxx.xxx.xx.test        

    2. 定义测试方法：可以独立运行
        * 建议：
            * 方法名：test测试的方法名        testAdd()  
            * 返回值：void
            * 参数列表：空参

    3. 给方法加@Test
    4. 导入junit依赖环境
    
* 判定结果：
    * 红色：失败
    * 绿色：成功
    * 一般我们会使用断言操作来处理结果
        * Assert.assertEquals(期望的结果,运算的结果);

* 补充：
    * @Before:
        * 修饰的方法会在测试方法之前被自动执行
    * @After:
        * 修饰的方法会在测试方法执行之后自动被执行
        
        
// 举个例子
public class Calculator {

    /**
     * 加法运算
     * @param a  加数
     * @param b  被加数
     * @return   和
     */
    public int add(int a,int b){
        return a + b;
    }

    /**
     * 减法运算
     * @param a  减数
     * @param b  被减数
     * @return   差值
     */
    public int sub(int a,int b){
        return a - b;
    }
}

// 测试类的创建
package com.wzlove.test;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

/**
 * @author 王智
 * @date 2018/7/31
 * @描述 测试类
 */

public class CalculatorTest {

    Calculator cal;

    /**
     * 初始化
     */
    @Before
    public void init(){
        // 初始化对象
        cal = new Calculator();
        System.out.println("init==================================================");
    }

    /**
     * 测试加法运算
     */
    @Test
    public void testAdd(){
        // 调用方法
        int result = cal.add(10, 10);
        // 断言
        Assert.assertEquals(20,result);
    }

    /**
     * 测试减法运算
     */
    @Test
    public void testSub(){
        // 调用方法
        int result = cal.sub(10, 10);
        // 断言
        Assert.assertEquals(0,result);
    }

    @After
    public void end(){
        System.out.printf("end========================================");
    }   
}

反射 : 框架的设计灵魂

框架：半成品软件。可以在框架的基础上进行软件开发，简化编码
反射：将类的各个组成部分封装为其他对象，这就是反射机制
- 好处：
  1. 可以在程序运行过程中，操作这些对象。
  2. 可以解耦，提高程序的可扩展性。

获取Class对象的方式：

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

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

package com.wzlove.reflect;

  /**
   * @author 王智
   * @date 2018/7/31
   * @描述  获取字节码对象的三种方式
   */
  public class GetClassObject {

      public static void main(String[] args) throws Exception {
          // 第一种: 使用全类名进行获取
          Class<?> aClass = Class.forName("com.wzlove.reflect.GetClassObject");
          System.out.println(aClass);
          // 第二种: 使用类名的属性获取
          Class aClass1 = GetClassObject.class;
          System.out.println(aClass1);
          // 第三种: 使用类的方法进行获取
          Class<?> aClass2 = new GetClassObject().getClass();
          System.out.println(aClass2);

          System.out.println(aClass == aClass1);
          System.out.println(aClass == aClass2);
      }
  }

Class对象功能：
- 获取功能：
 1. 获取成员变量们
 - Field[] getFields() ：获取所有public修饰的成员变量
 - Field getField(String name) 获取指定名称的 public修饰的成员变量
 - Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
 - Field getDeclaredField(String name)
 2. 获取构造方法们
 - Constructor<?>[] getConstructors()
 - Constructor
 - Constructor
 - Constructor<?>[] getDeclaredConstructors()
 3. 获取成员方法们：
 - Method[] getMethods()
 - Method getMethod(String name, Class<?>... parameterTypes)
 - Method[] getDeclaredMethods()
 - Method getDeclaredMethod(String name, Class<?>... parameterTypes)
 4. 获取全类名
 - String getName()

Field：成员变量

操作：
1. 设置值
  - void set(Object obj, Object value)
2. 获取值
  - get(Object obj)
3. 忽略访问权限修饰符的安全检查
  - setAccessible(true):暴力反射

// 下面的例子全部使用Student类
package com.wzlove.reflect;

  /**
   * @author 王智
   * @date 2018/7/31
   * @描述
   */
  public class Student {

      private String name;

      private int age;

      public String sex;

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

      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 String getSex() {
          return sex;
      }

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

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

      public Student() {
      }
  }


  package com.wzlove.reflect;

  import java.lang.reflect.Field;

  /**
   * @author 王智
   * @date 2018/7/31
   * @描述 利用反射获取对象的成员变量
   */
  public class GetFieldDemo {

      public static void main(String[] args) throws Exception {
          // 利用反射获取公有成员变量的步骤
          // 1. 获取反射对象(3种方法)
          Class aClass = Student.class;
          // 2. 获取成员变量
          Field sex =  aClass.getField("sex");
          // 3. 使用Field的方法设置值(需要创建对象)
          Student stu = new Student();
          sex.set(stu,"男");
          // 4. 使用Field的方法获取值
          System.out.println(sex.get(stu));



          // 获取所有成员变量
          // 1. 获取反射对象(3种方法)
          Class aClass1 = Student.class;
          // 2. 获取成员变量
          Field name =  aClass1.getDeclaredField("name");
          // 3. 使用Field的方法设置值(需要创建对象)
          Student stu1 = new Student();
          // 4. 再使用私有变量的时候会报错,所以要跳过检测,也成为暴力反射
          name.setAccessible(true);
          name.set(stu1,"王智");
          // 6. 使用Field的方法获取值
          System.out.println(name.get(stu1));
      }

  }

Constructor:构造方法

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

package com.wzlove.reflect;

  import java.lang.reflect.Constructor;

  /**
   * @author
   * @date 2018/7/31
   * @描述 利用反射获取对象的构造方法
   */
  public class GetConstructDemo {

      public static void main(String[] args) throws Exception {
          // 利用反射获取公有成员变量的步骤
          // 1. 获取反射对象(3种方法)
          Class aClass = Student.class;
          // 2. 使用方法获取构造方法的对象
          Constructor constructor = aClass.getConstructor(String.class, int.class, String.class);
          // 3. 使用Constructor对象初始化对象
          Object obj = constructor.newInstance("张三", 23, "男");
          // 测试输出结果
          System.out.println(obj);
          System.out.println("===================================");

          // 无参构造的方法
          // 1. 获取反射对象(3种方法)
          Class aClass1 = Student.class;
          // 2. 使用方法获取构造方法的对象
          Constructor constructor1 = aClass1.getConstructor();
          // 3. 使用Constructor初始化对象
          Object obj1 = constructor1.newInstance();
          // 测试输出结果
          System.out.println(obj1);

          // 还有个简化写法,仅仅适用于无参构造,但是我使用JDK10已经不推荐使用了
          Object obj2 = aClass1.newInstance();
          System.out.println(obj2);

          // getDeclaredConstructor方法也是获取私有的构造方法,就不演示了
      }

  }

Method：方法对象
- 执行方法：
  - Object invoke(Object obj, Object... args)
- 获取方法名称：
  - String getName:获取方法名

首先在Student中添加两个方法

        public void eat(){
    System.out.println("eat..............");
}

public int add(int a, int b){
   return a + b;
}

package com.wzlove.reflect;

import java.lang.reflect.Method;

/**
 * @author 王智
 * @date 2018/7/31
 * @描述 反射执行方法
 */
public class GetMethodDemo {

    public static void main(String[] args) throws Exception {
        // 无参无返回值的方法
        // 1. 创建字节码对象
        Class aClass = Student.class;
        // 2. 创建方法的对象
        Method eat = aClass.getMethod("eat");
        // 3. 执行方法
        Student stu = new Student();
        eat.invoke(stu);

        // 有参有返回值的方法
        // 1. 创建字节码对象
        Class aClass1 = Student.class;
        // 2. 创建方法的对象
        Method add = aClass1.getMethod("add", int.class,int.class);
        // 3. 执行方法
        Student stu1 = new Student();
        Object sum = add.invoke(stu1, 10, 10);
        System.out.println("和为" + sum);
        System.out.println("======================================================");
        // 获取该类所有的方法(这里获取的不仅仅是自己定义的方法,还有从父类继承来的方法)
        Method[] methods = aClass1.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            System.out.println(method.getName());
        }
        System.out.println("======================================================");

        // 获取类名
        System.out.println(aClass1.getName());
        // getDeclaredMethod也是同样的道理
    }
}

以上就是反射的简单使用了.举个简单例子,当然这个例子并不完善,将就看

        package com.wzlove.reflect;


import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * @author 
 * @date 2018/7/31
 * @描述
 * * 案例：
 *  * 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，
 *  并且执行其中任意方法
 *      * 实现：
 *          1. 配置文件
 *          2. 反射
 *      * 步骤：
 *          1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
 *          2. 在程序中加载读取配置文件
 *          3. 使用反射技术来加载类文件进内存
 *          4. 创建对象
 *          5. 执行方法
 */
public class ReflectDemo {

    public static void main(String[] args) throws Exception {
        // 创建本类的字节码对象
        Class aClass = ReflectDemo.class;
        // 获取类加载器对象
        ClassLoader classLoader = aClass.getClassLoader();
        // 加载配置文件,返回字节流对象
        InputStream resourceAsStream = classLoader.getResourceAsStream("pro.properties");

        // 读取配置文件
        // 创建Properties对象
        Properties properties = new Properties();
        properties.load(resourceAsStream);

        // 反射的使用
        Object className = properties.getProperty("className");
        Object methodName = properties.getProperty("methodName");
        // 使用反射创建对象
        Class aClass1 = Class.forName((String) className);
        Constructor constructor = aClass1.getConstructor();
        Object obj = constructor.newInstance();
        // 利用反射获取方法
        Method method = aClass1.getMethod((String) methodName);
        // 使用反射执行方法
        method.invoke(obj);

    }

}

原文：https://www.cnblogs.com/wadmwz/p/9397627.html

内容总结

以上是互联网集市为您收集整理的Java之Junit和反射全部内容，希望文章能够帮你解决Java之Junit和反射所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1249117.html

来源：【匿名】

【上一篇】java网站架构设计【下一篇】JAVA/JSP学习系列之五

更多 ►

【Java之Junit和反射】教程文章相关的互联网学习教程文章

Junit,反射Junit1.测试的分类:黑盒测试 : 不需要写代码，给输入值，看程序是否能够输出期望的值。白盒测试 : 需要进行代码的编写,关注的是程序的具体流程.2.使用步骤(方法类的命名可以参考阿里巴巴开发手册):* 步骤：1. 定义一个测试类(测试用例)* 建议：* 测试类名：被测试的类名Test * 包名：xxx.xxx.xx.test 2. 定义测试方法：可以独立运行* 建议：* 方法名：test测试的方法名 testAdd() * 返回值：void* ...

JavaWeb-1.2.3【基础加强：案例（反射+配置文件）】【代码】

1package com.yubaby.reflect;2 3import com.yubaby.domain.Person;4 5import java.io.IOException;6import java.io.InputStream;7import java.lang.reflect.InvocationTargetException;8import java.lang.reflect.Method;9import java.util.Properties; 1011/*12* 案例： 13 * 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法 14 * 实现： 15 1. 配...

Java反射之一：反射概念与获取反射源头Class【代码】【图】

Java反射机制概念“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”，如Python，Ruby是动态语言；显然C++，Java，C#不是动态语言，但是JAVA有着一个非常突出的动态相关机制：Reflection。JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。如：/*** ...

Java中的反射

镜子中的你，是真实的自己。Java-反射Java中的反射是一种机制，它能让你在对目标对象毫不知情的条件下，在运行时期获取该对象的所有信息。这要得益于JVM加载类时候的机制：每当加载一个新的类时，JVM都会创建一个Class实例（一个被命名为Class的class）并将其与新建类关联起来，该实例包含新建类的所有信息。Class实例就像一面镜子，反射出关联类的完整信息，因此该机制称为反射（Reflection）原文：https://www.cnblogs.com/tHcLo...

java反射简解【代码】

1、首先一个问题，什么是类，类是不是对象？我们总是说我们new一个对象出来那么我们还没有new的时候，建造的那个java类是不是对象呢？是它是java.lang.Class的对象对于反射我们首先要知道的就是什么是Class类java.lang.Class到底是什么，有啥用。首先我们要得到Class，我们有三种可以得到的方法，代码如下，c1，c2，c3就是我们需要的Class//任何一个类都有一个隐含的成员变量叫做calss Class c1 = Man.class;//通过对象的getClass...

Java带默认值的反序列化，特别适用于方法反射调用的时候参数不能为空【代码】

Java带默认值的反序列化，特别是方法反射调用的时候参数不能为空，避免出现空指针异常本文连接：https://www.cnblogs.com/muphy/p/15242173.htmlprivate Object parseObject(Class<?> paramType, String value) {if (Integer.class == paramType || int.class == paramType) {if (StringUtils.isEmpty(value)) {return 0;}return Integer.valueOf(value);}if (Long.class == paramType || long.class == paramType) {if (StringUti...

JAVA反射实例详解

一：反射???? 反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。? 使用java的反射，一般有下面三步：??? 1：获得你想操作类的Class对象??? 2：通过第一步获得的Class对象去取得操作类的方法或是属性名??? 3：操作第二步取得的方法或是属性二：例子????Java的反射机制中类有Class对应，类的方法有Method对应，当然属性也有Field与之对应。2.1 通过反射...

Java 反射【代码】

1.类加载器　　1.1类的加载　　　　程序使用某个类时，该类加载进内存中　　　　通过加载，连接，初始化三步进行初始化　　　　1.1.1加载，读入内存，将class读入内存，并且创建一个对象　　　　1.1.2连接，验证，是否有正确结构　　　　　　给静态成员分配内存　　　　　　解析，将类的二进制数中符号转换为直接引用　　1.2类加载实际　　　　凡是用到某个类时，都全部进行加载　　1.3类加载器　　　　用来把class文件加载进内存，...

对JAVA Bean使用PropertyDescriptor反射调用JAVA方法低耦合【代码】

对于符合JAVA Bean规范的bean，调用其方法应优先使用java.beans.PropertyDescriptor获取Method进行方法调用，以获得更大的可维护性。 public void gridColumnFilter(List<?> list, Map<String, Object> dataMap){ for (Iterator<?> iterator = list.iterator(); iterator.hasNext();) {Object bean = iterator.next(); for (int i = 0; i < indexs.length; i++) {//使用反射类 PropertyDescriptor pd = new PropertyDescripto...

Java---类反射(2)---类反射加强【代码】

经过前面的一篇博客，Java—类反射(1)，相信大家对类反射有了一定的了解了。下面来进行对类反射的加强，了解一下怎么通过类反射去new一个对象，怎么通过类反射去访问其他类的方法。怎么通过类反射去访问其他类的成员变量。大家也许认为一个类的私有方法，私有的成员变量是其他类访问不到。但是，类反射是可以通过暴力访问去访问的。还有：最后要模拟Java内省的功能类的调用（调用类中的成员）★ 构造类对象使用构造器新建对象...

Java 反射修改类的常量值、静态变量值、属性值【代码】

前言有的时候，我们需要修改一个变量的值，但变量也许存在于 Jar 包中或其他位置，导致我们不能从代码层面进行修改，于是我们就用到了下面的场景，通过反射来进行修改变量的值。定义一个实体类class Bean{ private static final Integer INT_VALUE = 100; } 利用反射修改私有静态常量方法System.out.println(Bean.INT_VALUE); Field field = Bean.class.getField("INT_VALUE"); //将字段的访问权限设为true：即去除privat...

利用Java反射机制实现对象相同字段的复制【代码】

一。如何实现不同类型对象之间的复制问题？ 1、为什么会有这个问题？近来在进行一个项目开发的时候，为了隐藏后端数据库表结构、同时也为了配合给前端一个更友好的API接口文档（swagger API文档），我采用POJO来对应数据表结构，使用VO来给传递前端要展示的数据，同时使用DTO来进行请求参数的封装。以上是一个具体的场景，可以发现这样子一个现象：POJO、VO、DTO对象是同一个数据的不同视图，所以会有很多相同的字段，由于不同的地...

如果有人再问你 Java 的反射，把这篇文章扔给他【代码】

在 Java 中，并不是所有的类型信息都能在编译阶段明确，有一些类型信息需要在运行时才能确定，这种机制被称为 RTTI，英文全称为 Run-Time Type Identification，即运行时类型识别，有没有一点“知行合一”的味道？运行时类型识别主要由Class类实现。在日常的学习工作当中，有一些知识是我们在读书的时候就能够习得；但有一些知识不是的，需要在实践的时候才能得到真知——这或许就是王阳明提倡的“知行合一”。01、 Class类在Java...

java 反射调用反射方法【图】

java 反射调用反射方法使用： />Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->(Boolean) invokeMethod(LockPatternUtils.class, mLockutils, "savedPasswordExists", new Class[] {int.class}, new Object[] {UserHandle.myUserId()});(Boolean) invokeMethod(LockPatternUtils.class, mLockutils, "checkPattern", new Class[] {L...

Java 反射工具类封装【代码】

封装了常用的反射相关方法public class ReflectUtil {/*** 通过类路径获取Class* * @author LHY * Description * LastModified 2014-5-9 Content */public static Class<?> getClass(String packagePath) throws ClassNotFoundException {return Class.forName(packagePath);}/*** 获取的Activity的Class* * @author LHY * Description packageRoot：模块跟路径 * activityPat...

首页 / JAVA / Java之Junit和反射