枚举、注解、反射、单元测试

于 2023-04-23 22:37:27 发布
阅读量144 收藏
点赞数
文章标签： junit java 单元测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61162288/article/details/130332357
版权

枚举

1.1 枚举概述

枚举是JDK1.5新增的引用数据类型，和类，接口是一个级别的，定义枚举的关键字为enum。

java.lang.Enum类，是所有枚举的父类。

枚举的本质就是一个类的多个对象。

1.2 枚举的定义

  • 格式：public enmu 枚举名{}

  • 枚举常量定义：

    • 枚举中的常量名字大写，多个常量之间逗号分开，最后一个常量可以写分号，也可以不写。每一个常量，都表示这个类的对象。修饰符为public static final。

    • 枚举中有默认的无参数的private修饰的构造方法，如果手写构造方法，也必须是私有修饰的。而且构造方法必须写在常量的后面，这时最后一个常量就必须要写分号。

public enum  Color {
    //枚举的静态常量
    RED,GREEN,YELLOW
}
public enum Color{
    //枚举静态常量，直接为变量color赋值
    RED("红色"),GREEN("绿色"),YELLOW("黄色");
    private String color;
    priate Color(String color){
        this.color = color ;
    }
    //省略get/set
}

1.3 枚举的使用

由于枚举的常量为静态修饰可以直接枚举名.调用

public static void main(String[] args){
    MyEnum myEnum = MyEnum.GREEN;
    System.out.println(myEnum);
    System.out.println(myEnum.getName());
}

 单元测试

1.1 测试分类：

  • 黑盒测试：不需要写代码，给输入值，看程序是否能够输出期望的值。

  • 白盒测试：需要写代码的。关注程序具体的执行流程。

  •  

1.2 Junit介绍

Junit是一个Java语言的单元测试框架，属于白盒测试，简单理解为可以用于取代java的main方法。Junit属于第三方工具，需要导入jar包后使用。

1.3 Junit的使用

  1. 编写测试类，简单理解Junit可以用于取代java的main方法。

  2. 在测试类方法上添加注解 @Test。

  3. @Test修饰的方法要求：public void 方法名() {…} ，方法名自定义建议test开头，没有参数。

  4. 添加Junit库到lib文件夹中，然后进行jar包关联。

  5.  

使用：点击方法左侧绿色箭头，执行当前方法（方法必须标记@Test）。执行结果红色：代表失败；执行结果绿色：代表成功。

/*
    哪个方法想使用单元测试,就在方法上,添加注解: @Test
    注意:
        该方法的返回值类型,必须写为void
        该方法必须没有参数列表
​
     运行:
        方法上右键运行,运行的是含有@Test注解的方法
        类上右键运行,运行的是类当中含有@Test注解的所有方法
        绿条: 正常运行
        红条: 出现问题,异常了
 */

1.3 常用注解

  • @Test，用于修饰需要执行的测试方法。

  • @Before，修饰的方法会在测试方法之前被自动执行。

  • @After，修饰的方法会在测试方法执行之后自动被执行。

 类的加载器

3.1 类的加载器时机

  1. 创建类的实例。

  2. 类的静态变量，或者为静态变量赋值。

  3. 类的静态方法。

  4. 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。

  5. 初始化某个类的子类。

  6. 直接使用java.exe命令来运行某个主类。

以上6个情况，只要有1个出现，那么类的加载器就会将这个类的class文件加载到内存中，我们就可以使用这个类了。java.lang.ClassLoader：是类的加载器的父类。

3.2 引导类加载器

引导类加载器Bootstrap：是C++语言编写，负责加载JDK核心类库，核心类库位置\jdk\jre\lib\下的jar包。

由于引导类加载器器在JVM内部，开发人员是不能直接操作的。

ClassLoader loader = String.class.getClassLoader();

程序的输出结果是null，C++编写的加载器，根本就不是Java中的类。

3.3 扩展类加载器

扩展类加载器ExtClassLoader：Java语言编写的类加载器，负责加载JDK扩展类库，类库位置\jdk\lib\ext\下的jar包。

ClassLoader loader = DNSNameService.class.getClassLoader();
System.out.println(loader);

程序的输出结果是：sun.misc.Launcher$ExtClassLoader@45ee12a7，ExtClassLoader类继承URLClassLoader，URLClassLoader继承SecureClassLoader，SecureClassLoader继承ClassLoader。

3.4 应用类加载器

应用类加载器AppClassLoader：Java语言编写的类加载器，负责加载我们定义的类和第三方jar包中的类。

ClassLoader loader = Test.class.getClassLoader();
System.out.println(loader);

程序的输出结果是：sun.misc.Launcher$AppClassLoader@18b4aac2，AppClassLoader继承URLClassLoader，URLClassLoader继承SecureClassLoader，SecureClassLoader继承ClassLoader。

3.5 类加载器的双亲委派

ClassLoader类定义了方法 ClassLoader getParent()：返回父类加载器。

//获取自己定义类的加载器，结果为AppClassLoader
ClassLoader loader = Test.class.getClassLoader();
//获取AppClassLoader的父类加载器，结果为ExtClassLoader
System.out.println(loader.getParent());
//获取ExtClassLoader的父类加载器，结果为null
System.out.println(loader.getParent().getParent());

结论： AppClassLoader的父类加载器是ExtClassLoader，ExtClassLoader的父类加载器是Bootstrap。

注意：ExtClassLoader是AppClassLoader的父加载器，并不是父类，他们没有继承关系。

双亲委派机制：当AppClassLoader收到一个加载类的请求时，会先让他的父类加载器ExtClassLoader尝试加载，ExtClassLoader也会让他的父类加载器Bootstrap尝试加载，如果Bootstrap能加载，就加载该类。如果Bootstrap不能加载，则ExtClassLoader会进行加载，如果也不能加载，AppClassLoader会进行加载。

 

3.6 Class对象创建

当一个类的class文件被类加载器加载到内存后，类的加载器会创建出此class文件的对象。class文件的对象是Class类的对象，是反射技术的基石。

第四章 反射

4.1 反射概念

  • 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码

  • 反射：将java代码的各个组成部分封装为其他对象，可以在程序运行过程中操作这些对象，这就是java的反射机制，如下图。

  • 反射的好处：

    1. 可以在程序运行过程中，操作这些对象。

    2. 可以解耦，提高程序的可扩展性。

    3.  

4.2 获取Class对象的方式

获取class对象方式作用应用场景
Class.forName("全类名")通过指定的字符串路径获取多用于配置文件，将类名定义在配置文件中。读取文件，加载类
类名.class通过类名的属性class获取多用于参数的传递
对象.getClass()通过对象的getClass()方法获取多用于对象的获取字节码的方式

Student类：

public class Student {
    private String name;
    private int age;
    public Student(){
    }
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public void study(){
        System.out.println("学生在学习");
    }
​
    public void eat(String s,double d){
        System.out.println("带参数方法:"+s+"::"+d);
    }
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

获取Student类的class文件对象：

public static void main(String[] args)throws Exception{
    Student student = new Student(); 
    Class c1 = student.getClass();
    System.out.println(c1);
    Class c2 = Student.class;
    System.out.println(c2);
    Class c3 = Class.forName("com.doit.communication.Student");
    System.out.println(c3);
}

4.3 反射获取构造方法

Class类中与Constructor相关方法

1. Constructor[] getConstructors() 
    获取所有的public修饰的构造方法
​
2. Constructor getConstructor(Class... parameterTypes) 
    根据参数类型获取构造方法对象，只能获得public修饰的构造方法。
    如果不存在对应的构造方法，则会抛出 java.lang.NoSuchMethodException 异常。
    参数是可变参数,调用此方法时,可以不写参数,获取的空参构造
                可以写参数,给定的参数必须是Class对象
                    比如:
                        参数 String name,int age
                        调用此方法: String.class,int.class

Constructor类中常用方法

1. T newInstance(Object... initargs) 
    根据指定参数创建对象。
2. T newInstance()
    空参构造方法创建对象。

获取无参数构造方法

public static void main(String[] args)throws Exception{
    Class cla = Class.forName("com.doit.communication.Student");
    //获取无参数构造方法
    Constructor constructor = cla.getConstructor();
    //运行构造方法
    Object object =  constructor.newInstance();
    System.out.println(object);
}

获取有参数构造方法

public static void main(String[] args)throws Throwable{
    Class cla = Class.forName("com.doit.communication.Student");
    //获取有参数构造方法
    Constructor constructor = cla.getConstructor(String.class, int.class);
    //运行构造方法，传递实际参数
    Object object = constructor.newInstance("张三",20);
    System.out.println(object);
​
}

4.4 反射获取构造方法的简单方式

Class类中定义了方法 T newInstance()，可以直接运行获取到的构造方法。

要求：被反射的类中必须有public权限的无参数构造方法。

public static void main(String[] args)throws Throwable{
    Class cla = Class.forName("com.doit.communication.Student");
    Object object = cla.newInstance();
    System.out.println(object);
}

4.5 反射成员方法执行

Class类中与Method相关方法

1. Method[] getMethods()
    获取所有的public修饰的成员方法，包括父类中。
​
2. Method getMethod("方法名", 方法的参数类型... 类型) 
    根据方法名和参数类型获得一个方法对象，只能是获取public修饰的

Method类中常用方法

Object invoke(Object obj, Object... args) 
    返回值Object，表示调用方法后，该方法的返回值
    根据参数args调用对象obj的该成员方法   
    如果obj=null，则表示该方法是静态方法

反射获取无参数方法

public static void main(String[] args)throws Throwable{
    Class cla = Class.forName("com.doit.communication.Student");
    Object object = cla.newInstance();
    //获取study方法
    Method method = cla.getMethod("study");
    //执行方法，传递对象
    method.invoke(object);
}

反射获取有参数方法

public static void main(String[] args)throws Throwable{
    Class cla = Class.forName("com.doit.communication.Student");
    Object object = cla.newInstance();
    //获取有参数的方法eat
    Method method = cla.getMethod("eat",String.class,double.class);
    //调用eat方法，传递实际参数
    method.invoke(object,"吃饭",9.9);
}

4.6 反射案例

需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法

实现：

  1. 配置文件

  2. 反射

步骤：

  1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中

  2. 在程序中加载读取配置文件

  3. 使用反射技术来加载类文件进内存

  4. 创建对象

  5. 执行方法

注意：需要将配置文件放在src目录下，放在src目录下的任何文件，都会被编译到classes目录下，这样做的目的是为了让配置文件跟随编译后的class文件一起，因为交付用户使用的是class文件，而不是源代码。

如何读取src目录下的文件：使用类的加载器ClassLoader类的方法 :

  • InputStream getResourceAsStream(String name)

    • 此方法返回输入流，该流从类目录下读取文件

    • 参数传递文件名

properties文件：

className=com.doit.domain.Student
methodName=sleep

Student类：

package com.doit.domain;
​
public class Student {
    public void sleep(){
        System.out.println("sleep...");
    }
}

RefectTest测试类：

public static void main(String[] args)throws Throwable{
    //获取RefectTest类的加载器
    ClassLoader classLoader = RefectTest.class.getClassLoader();
    //加载器获取输入流，读取pro.properties文件
    InputStream inputStream = classLoader.getResourceAsStream("pro.properties");
    Properties properties = new Properties();
    //集合IO关联
    properties.load(inputStream);
    //获取集合中的键值对，类名
    String className = properties.getProperty("className");
    //获取集合中的键值对，方法名
    String methodName = properties.getProperty("methodName");
    //反射获取指定类的class文件对象
    Class cla = Class.forName(className);
    Object object = cla.newInstance();
    //获取指定的方法
    Method method = cla.getMethod(methodName);
    //运行方法
    method.invoke(object);
}

 注解

5.1 注解概述

定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

作用分类：

  • 编写文档：通过代码里标识的注解生成文档【例如，生成文档doc文档】

  • 代码分析：通过代码里标识的注解对代码进行分析【例如，注解的反射】

  • 编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【例如，Override】

常见注解

  1. @author：用来标识作者名

  2. @version：用于标识对象的版本号，适用范围：文件、类、方法。

  3. @Override ：用来修饰方法声明，告诉编译器该方法是重写父类中的方法，如果父类不存在该方法，则编译失败。

5.2 自定义注解

定义格式

元注解
public @interface 注解名称{
    属性列表;
}

注解本质上就是一个接口，该接口默认继承Annotation接口。

public @interface MyAnno extends java.lang.annotation.Annotation {}

任何一个注解，都默认的继承Annotation接口。

注解的属性

  1. 属性的作用

    • 可以让用户在使用注解时传递参数，让注解的功能更加强大。

  2. 属性的格式

    • 格式1：数据类型 属性名();

    • 格式2：数据类型 属性名() default 默认值;

  3. 属性定义示例

    public @interface Student {
  String name(); // 姓名
  int age() default 18; // 年龄
  String gender() default "男"; // 性别
} 
// 该注解就有了三个属性：name，age，gender

  4. 属性适用的数据类型

    • 八种基本数据类型（int,float,boolean,byte,double,char,long,short)。

    • String类型，Class类型，枚举类型，注解类型。

    • 以上所有类型的一维数组。

5.3 使用自定义注解

在程序中使用(解析)注解的步骤（获取注解中定义的属性值）：

  1. 获取注解定义的位置的对象 （Class，Method,Field）

  2. 获取指定的注解 getAnnotation(Class)

  3. 调用注解中的抽象方法获取配置的属性值

使用格式:

@注解名(属性名=属性值,属性名=属性值,属性名=属性值...)

定义注解

  1. 定义一个注解：Book

    • 包含属性：String value() 书名

    • 包含属性：double price() 价格，默认值为 100

    • 包含属性：String[] authors() 多位作者

  2. 代码实现

public @interface Book {
    // 书名
    String value();
    // 价格
    double price() default 100;
    // 多位作者
    String[] authors();
}

使用注解

​
public class BookShelf {
  
    @Book(value = "西游记",price = 998,authors = {"吴承恩","白求恩"})
    public void showBook(){
​
    }
}

使用注意事项

  • 如果属性有默认值，则使用注解的时候，这个属性可以不用赋值。

  • 如果属性没有默认值，那么在使用注解时一定要给属性赋值。

特殊属性value

  1. 当注解中只有一个属性且名称是value，在使用注解时给value属性赋值可以直接给属性值，无论value是单值元素还是数组类型。

    // 定义注解Book
public @interface Book {
    // 书名
    String value();
}
​
// 使用注解Book
public class BookShelf {
    @Book("西游记")
    public void showBook(){
​
    }
}
或
public class BookShelf {
    @Book(value="西游记")
    public void showBook(){
​
    }
}

  2. 如果注解中除了value属性还有其他属性，且至少有一个属性没有默认值，则在使用注解给属性赋值时，value属性名不能省略。

    // 定义注解Book
public @interface Book {
    // 书名
    String value();
    // 价格
    double price() default 100;
    // 多位作者
    String[] authors();
}
// 使用Book注解：正确方式
@Book(value="红楼梦",authors = "曹雪芹")
public class BookShelf {
  // 使用Book注解：正确方式
    @Book(value="西游记",authors = {"吴承恩","白求恩"})
    public void showBook(){
​
    }
}
​
// 使用Book注解：错误方式
public class BookShelf {
    @Book("西游记",authors = {"吴承恩","白求恩"})
    public void showBook(){
​
    }
}
// 此时value属性名不能省略了。

5.4 注解之元注解

默认情况下，注解可以用在任何地方，比如类，成员方法，构造方法，成员变量等地方。如果要限制注解的使用位置怎么办？那就要学习一个新的知识点：元注解。

  • @Target

  • @Retention

元注解之@Target

  • 作用：指明此注解用在哪个位置，如果不写默认是任何地方都可以使用。

    • 可选的参数值在枚举类ElemenetType中包括：

 TYPE： 用在类,接口上
 FIELD：用在成员变量上
 METHOD： 用在方法上
 PARAMETER：用在参数上
 CONSTRUCTOR：用在构造方法上
 LOCAL_VARIABLE：用在局部变量上

元注解之@Retention

  • 作用：定义该注解的生命周期(有效范围)。

    • 可选的参数值在枚举类型RetentionPolicy中包括

SOURCE：注解只存在于Java源代码中，编译生成的字节码文件中就不存在了。
CLASS：注解存在于Java源代码、编译以后的字节码文件中，运行的时候内存中没有，默认值。
RUNTIME：注解存在于Java源代码中、编译以后的字节码文件中、运行时内存中，程序可以通过反射获取该注解。

5.5 注解解析

通过Java技术获取注解数据的过程则称为注解解析。

与注解解析相关的接口

  • Annotation：所有注解类型的公共接口，类似所有类的父类是Object。

  • AnnotatedElement：定义了与注解解析相关的方法，常用方法以下四个：

boolean isAnnotationPresent(Class annotationClass); 判断当前对象是否有指定的注解，有则返回true，否则返回false。
T getAnnotation(Class<T> annotationClass);  获得当前对象上指定的注解对象。
Annotation[] getAnnotations(); 获得当前对象及其从父类上继承的所有的注解对象。
Annotation[] getDeclaredAnnotations();获得当前对象上所有的注解对象，不包括父类的。

获取注解数据的原理

注解作用在那个成员上，就通过反射获得该成员的对象来得到它的注解。

  • 如注解作用在方法上，就通过方法(Method)对象得到它的注解。

     // 得到方法对象
 Method method = clazz.getDeclaredMethod("方法名"); 
 // 根据注解名得到方法上的注解对象
 Book book = method.getAnnotation(Book.class);

  • 如注解作用在类上，就通过Class对象得到它的注解。

    // 获得Class对象
Class c = 类名.class;
// 根据注解的Class获得使用在类上的注解对象
Book book = c.getAnnotation(Book.class);

使用反射获取注解的数据

需求说明

  1. 定义注解Book，要求如下：

    • 包含属性：String value() 书名

    • 包含属性：double price() 价格，默认值为 100

    • 包含属性：String[] authors() 多位作者

    • 限制注解使用的位置：类和成员方法上

    • 指定注解的有效范围：RUNTIME

  2. 定义BookStore类，在类和成员方法上使用Book注解

  3. 定义TestAnnotation测试类获取Book注解上的数据

代码实现

注解Book

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {
    // 书名
    String value();
    // 价格
    double price() default 100;
    // 作者
    String[] authors();
}

BookStore类

@Book(value = "红楼梦",authors = "曹雪芹",price = 998)
public class BookStore {
}

TestAnnotation类

public class TestAnnotation {
    public static void main(String[] args)  throws Exception{
        System.out.println("---------获取类上注解的数据----------");
        test();
    }
​
    /**
     * 获取BookStore类上使用的Book注解数据
     */
    public static void test(){
        // 获得BookStore类对应的Class对象
        Class c = BookStore.class;
        // 判断BookStore类是否使用了Book注解
        if(c.isAnnotationPresent(Book.class)) {
            // 根据注解Class对象获取注解对象
            Book book = (Book) c.getAnnotation(Book.class);
            // 输出book注解属性值
            System.out.println("书名：" + book.value());
            System.out.println("价格：" + book.price());
            System.out.println("作者：" + Arrays.toString(book.authors()));
        }
}

5.6 模拟Junit

案例分析

  1. 模拟Junit测试的注释@Test，首先需要编写自定义注解@MyTest，并添加元注解，保证自定义注解只能修饰方法，且在运行时可以获得。

  2. 然后编写目标类（测试类），然后给目标方法（测试方法）使用 @MyTest注解，编写三个方法，其中两个加上@MyTest注解。

  3. 最后编写调用类，使用main方法调用目标类，模拟Junit的运行，只要有@MyTest注释的方法都会运行。

注解MyTest

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

目标类MyTestDemo

public class MyTestDemo {
    @MyTest
    public void test01(){
        System.out.println("test01");
    }
​
    public void test02(){
        System.out.println("test02");
    }
​
    @MyTest
    public void test03(){
        System.out.println("test03");
    }
}

调用类TestMyTest

public class TestMyTest {
    public static void main(String[] args) throws  Exception{
        // 获得MyTestDemo类Class对象
        Class c = MyTestDemo.class;
        // 获得所有的成员方法对象
        Method[] methods = c.getMethods();
        // 创建MyTestDemo类对象
        Object obj = c.newInstance();
        // 遍历数组
        for (Method m:methods) {
            // 判断方法m上是否使用注解MyTest
            if(m.isAnnotationPresent(MyTest.class)){
                // 执行方法m
                m.invoke(obj);
            }
        }
    }
}

子非我104
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
枚举enum的一些案例
07-18
枚举的一些案例通过举例一些实例来讲解枚举，附有代码
单元测试-枚举类覆盖
qq_40301204的博客
08-10 783
单元测试-枚举类覆盖
枚举、注解及单元测试的简单笔记
m0_61961937的博客
09-18 657
枚举、注解及单元测试
单元测试/枚举
fqc的博客
08-18 1655
单元测试 可以理解为 取代main方法 定义一个空参数没有返回值的方法 在方法上写@org.junit.Test 选中Test方法名 右键运行 在其他方法上@Before 之前 @After 之后 当写了这个之后,每当有一个单元测试,这个单元测试前后都会执行被@Before@After 修饰的方法 public class Demo02_Junit { @After public vo...
java之单元测试与注解与枚举
m0_60027772的博客
08-01 739
/属性//季节名字//季节描述//利用构造器对属性赋值//构造器私有化，外界不能调用这个构造器,只能season自己调用}//提供枚举类有限的，确定的对象——外界可以通过类名直接调用获得对象publicstaticfinalSeasonSPRING=newSeason("春天","春暖花开");publicstaticfinalSeasonSUMMER=newSeason("夏天","烈日炎炎");...
day24_枚举_注解_反射.pdf
11-02
单元测试是对软件中的最小可测试单元进行检查和验证。Junit是一个流行的Java单元测试框架，它允许程序员编写测试代码来验证被测试代码的功能。Junit属于白盒测试，关注程序的内部逻辑。使用Junit时，我们需要在测试...
折射-反射-枚举-单元测试综合案例
05-30
在IT行业中，"折射-反射-枚举-单元测试综合案例"这个主题涵盖了四个关键的编程概念：折射（代理）、反射、枚举和单元测试。这些是Java编程中尤为重要的技术，广泛应用于软件开发的不同阶段。 首先，让我们来详细...
JDK5.0新特性 常量 、枚举、 for each、反射
07-13
这对于框架开发、元编程和单元测试等场景非常有用。以下是一个简单的反射示例： ```java Class<?> clazz = Class.forName("java.lang.String"); Object obj = clazz.newInstance(); Method method = clazz....
Android 反射注解与动态代理综合使用详解
01-20
注解可以应用于不同类型的目标，如TYPE（类、接口、枚举），FIELD（字段）、METHOD（方法）等。自定义注解时，可以使用`@Target`来指定注解的应用目标，`@Retention`来设定注解的保留策略。例如，以下自定义注解用于...
spring aop+自定义注解+反射实现统一校验脚手架
05-24
工程介绍：SpringBoot项目脚手架，利用spring aop+java反射实现自定义注解校验参数 源码里有使用都例子在DemoContorller example1：校验userName参数必填 @CheckParams(notNull = true) private String userName;...
Java枚举,注解和单元测试 学习
最新发布
weixin_42801177的博客
03-06 290
Java枚举、注解和单元测试
【java高级】枚举Enum、泛型Generic、注解Annotation、单元测试Junit
A-Itfuture的博客
09-10 382
【java高级】枚举Enum、泛型Generic、注解Annotation、单元测试Junit【枚举Enum】【泛型Generic】【注解Annotation】【单元测试Junit】知识图谱 【枚举Enum】 使用 类的对象是有限个，确定的。如：日期月份等 当需要定义一组常量时，建议枚举 JDK1.5之前，自定义枚举 JDK1.5之后，enum关键字定义枚举 属性应为不允许被改变，故private final修饰，构造器中赋值， 自定义枚举 1.私有化类的构造器，保证不在外部创建对象 2.在类内部创建枚
Junit单元测试遇见的一个枚举类型的坑（枚举类型详解）
weixin_33971977的博客
11-28 1671
2019独角兽企业重金招聘Python工程师标准>>> ...
枚举，注解，实体类，单元测试，反射对象字段------------举例使用
lixiao1048的博客
05-30 1602
/**  * 定义一个枚举，枚举多用来存放常量，是一种数据类型  * @author Administrator  *  */ public enum Myenum { RED,BLUE,YELLOW } =========================================================================================
注解、泛型、枚举、Lambda表达式、JUnit单元测试
weixin_33951761的博客
07-13 222
注解 1、JDK 1.5之后新特性2、对元素进行说明（包、类、字段、方法、局部变量，方法参数） 注解与注释的区别 注解：用特定格式名称说明程序，给计算机看的 注释: 用文字说明程序，给程序员看的 作用分类 1、编写文档的注解：生成Apidoc文档（写在注释中） 2、代码分析的注解：对代码进行分析(反射) 3、编译检查的注解：进行编译检查...
java 不识别enum_java – 不存在的Enum值的单元测试？
weixin_39644614的博客
02-16 268
一些示例代码首先……枚举：public enum TestEnum {YES,NO}一些代码：public static boolean WorkTheEnum(TestEnum theEnum) {switch (theEnum) {case YES:return true;case NO:return false;default:// throws an exception here}}问题：...
单元测试发现研发写代码习惯造就的坑-Java的Enum类型详解
Criss@陈磊
02-22 253
Enum的简介 枚举类型很早就在计算机语言中存在了，主要被用来将一组相似的值包含进一种类型中，这种类型的名称被定义成独一无二的类型描述符，这就是枚举类型。 在java语言中，枚举类型是一个完整功能的类，允许开发者给枚举类型添加方法和属性，同时也可以提供接口。同时Java也为Enum提供了高质量的实现，比如comparable和Serializable接口. ** 其中：Comparable 是排序接口，如果一个Java类有这个接口，那么只能说明这个类支持排序。即然实现Comparable接口的类支持排序，假
单元测试、注解、枚举、反射（5）JavaSE
jayden
02-15 282
对注解，枚举和反射进行解释和代码实例解析
Java枚举、注解、反射与单元测试详解
单元测试是对程序中最小可测试单元进行检查和验证的过程。根据关注点的不同，测试分为黑盒测试和白盒测试。 - 黑盒测试：不考虑内部结构，只关注输入值和预期的输出结果。 - 白盒测试：需要了解代码内部实现，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值