Java单元测试、反射、注解

本文主要是介绍Java单元测试、反射、注解，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

单元测试

Junit

public class UserService {
    public String login(String loginName, String password) {
        if ("admin".equals(loginName) && "123456".equals(password)) {
            return "success";
        }
        return "用户名或密码错误";
    }
}


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

Junit常用注解

如Junit4，如5个注解都有，则执行顺序为@BeforeClass、@Before、@Test、@After、@AfterClass

反射

反射获取类对象

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 反射的第一步永远是先得到类的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 c3 = Class.forName("Student");
        System.out.println(c3);
    }
}

反射获取构造器对象

public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 反射的第一步永远是先得到类的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 c3 = Class.forName("Student");
        System.out.println(c3);
    }

    @Test
    public void getConstructors() {
        // 1.反射第一步得到Class类对象
        Class c = Student.class;

        // 2.定位全部构造器，只能拿public修饰
        Constructor[] cons = c.getConstructors();

        // 3.遍历构造器
        for (Constructor con: cons) {
            System.out.println(con.getName() + "===>" + con.getParameterCount());
        }
    }

    @Test
    public void getDeclaredConstructors() {
        // 1.反射第一步得到Class类对象
        Class c = Student.class;

        // 2.定位全部构造器，只要申明了就可以拿到
        Constructor[] cons = c.getDeclaredConstructors();

        // 3.遍历构造器
        for (Constructor con: cons) {
            System.out.println(con.getName() + "===>" + con.getParameterCount());
        }
    }

    @Test
    public void getDeclaredConstructor() throws NoSuchMethodException {
        // 1.反射第一步得到Class类对象
        Class c = Student.class;

        // 2.定位全部构造器，只要申明了就可以拿到
        // Constructor con = c.getDeclaredConstructor();
        Constructor con = c.getDeclaredConstructor(String.class, int.class);
        // 3.遍历构造器
        System.out.println(con.getName() + "===>" + con.getParameterCount());
    }
}

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

    public Student() {
    }

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

    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;
    }
}

反射获取构造器然后通过构造器初始化对象

    // 调用无参构造器得到一个类的对象返回
    @Test
    public void createObj01() throws Exception {
        // a.反射第一步是先得到Class类对象
        Class c = Student.class;
        // b.定位无参数构造器对象
        Constructor constructor = c.getDeclaredConstructor();
        // c.通过无参数构造器初始化对象返回
        constructor.setAccessible(true);
        // d.通过无参数构造器初始化对象返回
        Student swk = (Student) constructor.newInstance();
        System.out.println(swk);
    }

    // 调用有参构造器得到一个类的对象返回
    @Test
    public void createObj02() throws Exception {
        // a.反射第一步是先得到Class类对象
        Class c = Student.class;
        // b.定位无参数构造器对象
        Constructor constructor = c.getDeclaredConstructor(String.class, int.class);

        // c.通过有参数构造器初始化对象返回
        Student swk = (Student) constructor.newInstance("测试", 100);
        System.out.println(swk);
    }

反射获取Field成员变量对象及赋值

    /**
     * 获取全部的成员变量
     * @throws Exception
     */
    @Test
    public void createObj03() throws Exception {
        // a.反射第一步是先得到Class类对象
        Class c = Dog.class;
        // b.获取全部申明的成员变量对象
        Field[] fields = c.getDeclaredFields();
        for (Field field: fields) {
            System.out.println(field.getName()+"");
        }

        Field nameF = c.getDeclaredField("name");

        // c. 为这个成员变量赋值
        Dog taidi = new Dog();
        /**
         * 参数一：被赋值的对象
         * 参数二：该成员变量的值
         */
        nameF.setAccessible(true);
        nameF.set(taidi, "勇敢的泰迪");
        System.out.println(taidi);

        String value = nameF.get(taidi) + "";
        System.out.println(value);
    }

反射获取Method方法对象

    /**
     * 获取所有方法对象
     */
    @Test
    public void getDeclaredMethods() {
        Class d = Dog.class;

        Method[] methods = d.getDeclaredMethods();

        for (Method method: methods) {
            System.out.println(method.getName() + "====>" + method.getParameterCount() + "===>" + method.getReturnType());

        }
    }

    /**
     * 获取某个方法对象
     */
    @Test
    public void getDeclardMethod() throws Exception {
        // 1.先获取class类对象
        Class c = Dog.class;
        // 2.定位它的某个方法
        Method run = c.getDeclaredMethod("run");
        // 3.触发方法执行
        Dog jinmao = new Dog();
        run.invoke(jinmao); // 触发jinMao对象的run()方法执行

        /**
         * 参数一：方法名称
         * 参数二：方法的参数个数和类型（可变参数）
         */
        Method eat = c.getDeclaredMethod("eat", String.class);
        eat.setAccessible(true);
        /**
         * 参数一：被触发方法所在的对象
         * 参数二：方法需要的入参值
         */
        eat.invoke(jinmao, "肉");
        System.out.println();
    }

public class Dog {
    private void eat() {
        System.out.println("狗吃骨头");
    }

    private void eat(String name) {
        System.out.println("狗吃" + name);
    }

    public void run() {
        System.out.println("狗在跑");
    }
}

反射破坏类的封装性与泛型的约束性

    @Test
    public void getDeclardMethod1() throws Exception {
        // 泛型只能工作在编译阶段，运行阶段泛型就消失了
        // 反射工作在运行阶段
        List<Double> scores = new ArrayList<>();
        scores.add(24.1);
        scores.add(123.4);

        // 拓展：通过反射暴力注入一个其它类型数据
        Class c = scores.getClass();
        // 从ArrayList的class对象中定位add方法
        Method add = c.getDeclaredMethod("add", Object.class);
        // 出发scores集合对象中的add执行（运行阶段，泛型不能约束了）
        add.invoke(scores, "波仔");
        System.out.println(scores);
    }

反射的作用

    public static void main(String[] args) throws ClassNotFoundException {
        Dog dog = new Dog("haha", 15, "红");
        MyBatis.save(dog);
    }

public class Dog {
    private String name;
    private int age;
    private String color;

    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public Dog() {
    }

    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 getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}


import java.io.FileOutputStream;
import java.io.PrintStream;
import java.lang.reflect.Field;

public class MyBatis {
    // 提供一个方法：可以保存一切对象数据的字段和具体值
    public static void save(Object obj) {
        try (
                PrintStream ps = new PrintStream(new FileOutputStream("反射/src/test.txt", true));
        ) {
            // 1.先得到对象的Class文件对象
            Class c = obj.getClass();
            // 2.定位它的全部成员变量
            Field[] fields = c.getDeclaredFields();
            // 3.遍历这些字段并取值
            for (Field field: fields) {
                // 字段名称
                String name = field.getName();
                // 字段的值
                field.setAccessible(true); // 暴力反射
                String value = field.get(obj) + "";
                ps.println(name + "=" + value);
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注解

自定义注解

注解的属性

注解的特殊属性

元注解——是用在自定义注解上的注解

 注解的解析

@Book(value="test1", authors = {"1", "2"}, price = 5.1)
public class MyBook {
    public static void main(String[] args) throws NoSuchMethodException {
        // 1.定位Class类对象
        Class c = BookStore.class;
        // 2.判断这个类上是否使用了某个注解
        if (c.isAnnotationPresent(Book.class)) {
            // 3.获取这个注解对象
            Book book = (Book) c.getDeclaredAnnotation(Book.class);
            System.out.println(book.value());
            System.out.println(book.price());
        }

        Method run = c.getDeclaredMethod("run");

        // 2.判断这个方法上是否使用了某个注解
        if (run.isAnnotationPresent(Book.class)) {
            // 3.获取这个注解对象
            Book book = (Book) run.getDeclaredAnnotation(Book.class);
            System.out.println(book.value());
            System.out.println(book.price());
        }
    }
}

@Book(value = "Java基础精通", price = 50, authors = {"脖子", "哈哈"})
class BookStore {
    @Book(value = "Java基础精通1", price = 500, authors = {"脖1子", "哈2哈"})
    public void run() {

    }
}
// 自定义一个注解
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE}) // 申明只能注解方法与成员变量与类
    @Retention(RetentionPolicy.RUNTIME)
@interface Book {
    String value();
    String[] authors();
    double price();
    String address() default "广州";
}

注解模拟Junit框架的基本使用

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyTest {

}

MyBook t = new MyBook();
Class d = MyBook.class;
// 2.获取类中全部方法对象
Method[] methods = d.getDeclaredMethods();
for (Method method: methods) {
　　if (method.isAnnotationPresent(MyTest.class)) {
　　　　// 触发此方法执行
　　　　method.invoke(t);
　　　　}
}

@MyTest
public void test01() {
　　System.out.println("====test01====");
}

@MyTest
public void test02() {
　　System.out.println("====test02====");
}

@MyTest
public void test03() {
　　System.out.println("====test03====");
}

这篇关于Java单元测试、反射、注解的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！