Java 中文官方教程 2022 版(四十四)(4)

简介: Java 中文官方教程 2022 版(四十四)

Java 中文官方教程 2022 版(四十四)(3)https://developer.aliyun.com/article/1488321

检查枚举

原文:docs.oracle.com/javase/tutorial/reflect/special/enumMembers.html

反射提供了三个特定于枚举的 API:

Class.isEnum()

表示此类是否表示枚举类型

Class.getEnumConstants()

检索由枚举定义的枚举常量列表,按照它们声明的顺序

java.lang.reflect.Field.isEnumConstant()

表示此字段是否表示枚举类型的元素

有时需要动态检索枚举常量的列表;在非反射代码中,可以通过在枚举上调用隐式声明的静态方法 values() 来实现这一点。 如果枚举类型的实例不可用,则获取可能值列表的唯一方法是调用 Class.getEnumConstants(),因为无法实例化枚举类型。

给定完全限定名称,EnumConstants 示例显示如何使用 Class.getEnumConstants() 检索枚举中常量的有序列表。

import java.util.Arrays;
import static java.lang.System.out;
enum Eon { HADEAN, ARCHAEAN, PROTEROZOIC, PHANEROZOIC }
public class EnumConstants {
    public static void main(String... args) {
  try {
      Class<?> c = (args.length == 0 ? Eon.class : Class.forName(args[0]));
      out.format("Enum name:  %s%nEnum constants:  %s%n",
           c.getName(), Arrays.asList(c.getEnumConstants()));
      if (c == Eon.class)
    out.format("  Eon.values():  %s%n",
         Arrays.asList(Eon.values()));
        // production code should handle this exception more gracefully
  } catch (ClassNotFoundException x) {
      x.printStackTrace();
  }
    }
}

输出示例如下。 用户输入以斜体显示。

$ *java EnumConstants java.lang.annotation.RetentionPolicy*
Enum name:  java.lang.annotation.RetentionPolicy
Enum constants:  [SOURCE, CLASS, RUNTIME]
$ *java EnumConstants java.util.concurrent.TimeUnit*
Enum name:  java.util.concurrent.TimeUnit
Enum constants:  [NANOSECONDS, MICROSECONDS, 
                  MILLISECONDS, SECONDS, 
                  MINUTES, HOURS, DAYS]

该示例还表明,通过调用 Class.getEnumConstants() 返回的值与在枚举类型上调用 values() 返回的值相同。

$ *java EnumConstants*
Enum name:  Eon
Enum constants:  [HADEAN, ARCHAEAN, 
                  PROTEROZOIC, PHANEROZOIC]
Eon.values():  [HADEAN, ARCHAEAN, 
                PROTEROZOIC, PHANEROZOIC]

由于枚举是类,可以使用本教程中描述的字段、方法和构造函数部分中描述的相同反射 API 获取其他信息。 EnumSpy 代码示例说明了如何使用这些 API 获取有关枚举声明的其他信息。 该示例使用 Class.isEnum() 来限制要检查的类集。 它还使用 Field.isEnumConstant() 来区分枚举声明中的枚举常量和其他字段(并非所有字段都是枚举常量)。

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Member;
import java.util.List;
import java.util.ArrayList;
import static java.lang.System.out;
public class EnumSpy {
    private static final String fmt = "  %11s:  %s %s%n";
    public static void main(String... args) {
  try {
      Class<?> c = Class.forName(args[0]);
      if (!c.isEnum()) {
    out.format("%s is not an enum type%n", c);
    return;
      }
      out.format("Class:  %s%n", c);
      Field[] flds = c.getDeclaredFields();
      List<Field> cst = new ArrayList<Field>();  // enum constants
      List<Field> mbr = new ArrayList<Field>();  // member fields
      for (Field f : flds) {
    if (f.isEnumConstant())
        cst.add(f);
    else
        mbr.add(f);
      }
      if (!cst.isEmpty())
    print(cst, "Constant");
      if (!mbr.isEmpty())
    print(mbr, "Field");
      Constructor[] ctors = c.getDeclaredConstructors();
      for (Constructor ctor : ctors) {
    out.format(fmt, "Constructor", ctor.toGenericString(),
         synthetic(ctor));
      }
      Method[] mths = c.getDeclaredMethods();
      for (Method m : mths) {
    out.format(fmt, "Method", m.toGenericString(),
         synthetic(m));
      }
        // production code should handle this exception more gracefully
  } catch (ClassNotFoundException x) {
      x.printStackTrace();
  }
    }
    private static void print(List<Field> lst, String s) {
  for (Field f : lst) {
      out.format(fmt, s, f.toGenericString(), synthetic(f));
  }
    }
    private static String synthetic(Member m) {
  return (m.isSynthetic() ? "[ synthetic ]" : "");
    }
}
$ *java EnumSpy java.lang.annotation.RetentionPolicy*
Class:  class java.lang.annotation.RetentionPolicy
     Constant:  public static final java.lang.annotation.RetentionPolicy
                  java.lang.annotation.RetentionPolicy.SOURCE 
     Constant:  public static final java.lang.annotation.RetentionPolicy
                  java.lang.annotation.RetentionPolicy.CLASS 
     Constant:  public static final java.lang.annotation.RetentionPolicy 
                  java.lang.annotation.RetentionPolicy.RUNTIME 
        Field:  private static final java.lang.annotation.RetentionPolicy[] 
                  java.lang.annotation.RetentionPolicy. [ synthetic ]
  Constructor:  private java.lang.annotation.RetentionPolicy() 
       Method:  public static java.lang.annotation.RetentionPolicy[]
                  java.lang.annotation.RetentionPolicy.values() 
       Method:  public static java.lang.annotation.RetentionPolicy
                  java.lang.annotation.RetentionPolicy.valueOf(java.lang.String) 

输出显示,java.lang.annotation.RetentionPolicy的声明仅包含三个枚举常量。枚举常量暴露为public static final字段。字段、构造函数和方法是由编译器生成的。$VALUES字段与values()方法的实现有关。


**注意:**出于各种原因,包括支持枚举类型的演变,枚举常量的声明顺序很重要。Class.getFields()Class.getDeclaredFields()不能保证返回值的顺序与声明源代码中的顺序匹配。如果应用程序需要排序,请使用Class.getEnumConstants()


对于java.util.concurrent.TimeUnit的输出显示,更复杂的枚举是可能的。这个类包括几个方法以及额外声明为static final的字段,这些字段不是枚举常量。

$ java EnumSpy java.util.concurrent.TimeUnit
Class:  class java.util.concurrent.TimeUnit
     Constant:  public static final java.util.concurrent.TimeUnit
                  java.util.concurrent.TimeUnit.NANOSECONDS
     Constant:  public static final java.util.concurrent.TimeUnit
                  java.util.concurrent.TimeUnit.MICROSECONDS
     Constant:  public static final java.util.concurrent.TimeUnit
                  java.util.concurrent.TimeUnit.MILLISECONDS
     Constant:  public static final java.util.concurrent.TimeUnit
                  java.util.concurrent.TimeUnit.SECONDS
     Constant:  public static final java.util.concurrent.TimeUnit
                  java.util.concurrent.TimeUnit.MINUTES
     Constant:  public static final java.util.concurrent.TimeUnit
                  java.util.concurrent.TimeUnit.HOURS
     Constant:  public static final java.util.concurrent.TimeUnit
                  java.util.concurrent.TimeUnit.DAYS
        Field:  static final long java.util.concurrent.TimeUnit.C0
        Field:  static final long java.util.concurrent.TimeUnit.C1
        Field:  static final long java.util.concurrent.TimeUnit.C2
        Field:  static final long java.util.concurrent.TimeUnit.C3
        Field:  static final long java.util.concurrent.TimeUnit.C4
        Field:  static final long java.util.concurrent.TimeUnit.C5
        Field:  static final long java.util.concurrent.TimeUnit.C6
        Field:  static final long java.util.concurrent.TimeUnit.MAX
        Field:  private static final java.util.concurrent.TimeUnit[] 
                  java.util.concurrent.TimeUnit. [ synthetic ]
  Constructor:  private java.util.concurrent.TimeUnit()
  Constructor:  java.util.concurrent.TimeUnit
                  (java.lang.String,int,java.util.concurrent.TimeUnit)
                  [ synthetic ]
       Method:  public static java.util.concurrent.TimeUnit
                  java.util.concurrent.TimeUnit.valueOf(java.lang.String)
       Method:  public static java.util.concurrent.TimeUnit[] 
                  java.util.concurrent.TimeUnit.values()
       Method:  public void java.util.concurrent.TimeUnit.sleep(long) 
                  throws java.lang.InterruptedException
       Method:  public long java.util.concurrent.TimeUnit.toNanos(long)
       Method:  public long java.util.concurrent.TimeUnit.convert
                  (long,java.util.concurrent.TimeUnit)
       Method:  abstract int java.util.concurrent.TimeUnit.excessNanos
                  (long,long)
       Method:  public void java.util.concurrent.TimeUnit.timedJoin
                  (java.lang.Thread,long) throws java.lang.InterruptedException
       Method:  public void java.util.concurrent.TimeUnit.timedWait
                  (java.lang.Object,long) throws java.lang.InterruptedException
       Method:  public long java.util.concurrent.TimeUnit.toDays(long)
       Method:  public long java.util.concurrent.TimeUnit.toHours(long)
       Method:  public long java.util.concurrent.TimeUnit.toMicros(long)
       Method:  public long java.util.concurrent.TimeUnit.toMillis(long)
       Method:  public long java.util.concurrent.TimeUnit.toMinutes(long)
       Method:  public long java.util.concurrent.TimeUnit.toSeconds(long)
       Method:  static long java.util.concurrent.TimeUnit.x(long,long,long)

使用枚举类型获取和设置字段

原文:docs.oracle.com/javase/tutorial/reflect/special/enumSetGet.html

存储枚举的字段与任何其他引用类型一样设置和检索,使用Field.set()Field.get()。有关访问字段的更多信息,请参阅本教程的 Fields 部分。

考虑一个需要在服务器应用程序中动态修改跟踪级别的应用程序,通常在运行时不允许此更改。假设服务器对象的实例可用。SetTrace示例展示了代码如何将枚举的String表示转换为枚举类型,并检索和设置存储枚举的字段的值。

import java.lang.reflect.Field;
import static java.lang.System.out;
enum TraceLevel { OFF, LOW, MEDIUM, HIGH, DEBUG }
class MyServer {
    private TraceLevel level = TraceLevel.OFF;
}
public class SetTrace {
    public static void main(String... args) {
  TraceLevel newLevel = TraceLevel.valueOf(args[0]);
  try {
      MyServer svr = new MyServer();
      Class<?> c = svr.getClass();
      Field f = c.getDeclaredField("level");
      f.setAccessible(true);
      TraceLevel oldLevel = (TraceLevel)f.get(svr);
      out.format("Original trace level:  %s%n", oldLevel);
      if (oldLevel != newLevel) {
    f.set(svr, newLevel);
    out.format("    New  trace level:  %s%n", f.get(svr));
      }
        // production code should handle these exceptions more gracefully
  } catch (IllegalArgumentException x) {
      x.printStackTrace();
  } catch (IllegalAccessException x) {
      x.printStackTrace();
  } catch (NoSuchFieldException x) {
      x.printStackTrace();
  }
    }
}

由于枚举常量是单例,可以使用==!=运算符来比较相同类型的枚举常量。

$ *java SetTrace OFF*
Original trace level:  OFF
$ *java SetTrace DEBUG*
Original trace level:  OFF
    New  trace level:  DEBUG

故障排除

原文:docs.oracle.com/javase/tutorial/reflect/special/enumTrouble.html

以下示例展示了在使用枚举类型时可能遇到的问题。

尝试实例化枚举类型时出现 IllegalArgumentException

正如前面提到的,实例化枚举类型是被禁止的。EnumTrouble示例尝试这样做。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import static java.lang.System.out;
enum Charge {
    POSITIVE, NEGATIVE, NEUTRAL;
    Charge() {
  out.format("under construction%n");
    }
}
public class EnumTrouble {
    public static void main(String... args) {
  try {
      Class<?> c = Charge.class;
      Constructor[] ctors = c.getDeclaredConstructors();
      for (Constructor ctor : ctors) {
    out.format("Constructor: %s%n",  ctor.toGenericString());
    ctor.setAccessible(true);
    ctor.newInstance();
      }
        // production code should handle these exceptions more gracefully
  } catch (InstantiationException x) {
      x.printStackTrace();
  } catch (IllegalAccessException x) {
      x.printStackTrace();
  } catch (InvocationTargetException x) {
      x.printStackTrace();
  }
    }
}
$ *java EnumTrouble*
Constructor: private Charge()
Exception in thread "main" java.lang.IllegalArgumentException: Cannot
  reflectively create enum objects
        at java.lang.reflect.Constructor.newInstance(Constructor.java:511)
        at EnumTrouble.main(EnumTrouble.java:22)

提示: 明确实例化枚举是一种编译时错误,因为这将阻止定义的枚举常量保持唯一。这种限制也在反射代码中执行。试图使用默认构造函数实例化类的代码应该首先调用Class.isEnum()来确定该类是否为枚举。


设置具有不兼容枚举类型的字段时出现 IllegalArgumentException

存储枚举的字段应该设置为适当的枚举类型。(实际上,任何类型的字段都必须设置为兼容的类型。)EnumTroubleToo示例会产生预期的错误。

import java.lang.reflect.Field;
enum E0 { A, B }
enum E1 { A, B }
class ETest {
    private E0 fld = E0.A;
}
public class EnumTroubleToo {
    public static void main(String... args) {
  try {
      ETest test = new ETest();
      Field f = test.getClass().getDeclaredField("fld");
      f.setAccessible(true);
      f.set(test, E1.A);  // IllegalArgumentException
        // production code should handle these exceptions more gracefully
  } catch (NoSuchFieldException x) {
      x.printStackTrace();
  } catch (IllegalAccessException x) {
      x.printStackTrace();
  }
    }
}
$ *java EnumTroubleToo*
Exception in thread "main" java.lang.IllegalArgumentException: Can not set E0
  field ETest.fld to E1
        at sun.reflect.UnsafeFieldAccessorImpl.throwSetIllegalArgumentException
          (UnsafeFieldAccessorImpl.java:146)
        at sun.reflect.UnsafeFieldAccessorImpl.throwSetIllegalArgumentException
          (UnsafeFieldAccessorImpl.java:150)
        at sun.reflect.UnsafeObjectFieldAccessorImpl.set
          (UnsafeObjectFieldAccessorImpl.java:63)
        at java.lang.reflect.Field.set(Field.java:657)
        at EnumTroubleToo.main(EnumTroubleToo.java:16)

提示: 严格来说,将类型为X的字段设置为类型为Y的值只有在以下语句成立时才能成功:

X.class.isAssignableFrom(Y.class) == true

代码可以修改以执行以下测试,以验证类型是否兼容:

if (f.getType().isAssignableFrom(E0.class))
    // compatible
else
    // expect IllegalArgumentException


相关文章
|
3天前
|
机器学习/深度学习 移动开发 测试技术
《手把手教你》系列技巧篇(五十一)-java+ selenium自动化测试-字符串操作-下篇(详解教程)
【5月更文挑战第15天】自动化测试中进行断言的时候,我们可能经常遇到的场景。从一个字符串中找出一组数字或者其中的某些关键字,而不是将这一串字符串作为结果进行断言。这个时候就需要我们对字符串进行操作,宏哥这里介绍两种方法:正则和字符串切片函数split()。
18 2
|
10天前
|
Web App开发 JavaScript 前端开发
《手把手教你》系列技巧篇(三十九)-java+ selenium自动化测试-JavaScript的调用执行-上篇(详解教程)
【5月更文挑战第3天】本文介绍了如何在Web自动化测试中使用JavaScript执行器(JavascriptExecutor)来完成Selenium API无法处理的任务。首先,需要将WebDriver转换为JavascriptExecutor对象,然后通过executeScript方法执行JavaScript代码。示例用法包括设置JS代码字符串并调用executeScript。文章提供了两个实战场景:一是当时间插件限制输入时,用JS去除元素的readonly属性;二是处理需滚动才能显示的元素,利用JS滚动页面。还给出了一个滚动到底部的代码示例,并提供了详细步骤和解释。
35 10
|
10天前
|
Java 测试技术 Python
《手把手教你》系列技巧篇(三十六)-java+ selenium自动化测试-单选和多选按钮操作-番外篇(详解教程)
【4月更文挑战第28天】本文简要介绍了自动化测试的实战应用,通过一个在线问卷调查(&lt;https://www.sojump.com/m/2792226.aspx/&gt;)为例,展示了如何遍历并点击问卷中的选项。测试思路包括找到单选和多选按钮的共性以定位元素,然后使用for循环进行点击操作。代码设计方面,提供了Java+Selenium的示例代码,通过WebDriver实现自动答题。运行代码后,可以看到控制台输出和浏览器的相应动作。文章最后做了简单的小结,强调了本次实践是对之前单选多选操作的巩固。
26 0
|
1天前
|
前端开发 JavaScript 测试技术
《手把手教你》系列技巧篇(五十三)-java+ selenium自动化测试-上传文件-上篇(详细教程)
【5月更文挑战第17天】本文介绍了在Web自动化测试中处理文件上传操作的方法。Selenium的WebDriver未提供直接的API来处理文件上传,因为这涉及到操作系统级别的窗口交互,而WebDriver无法识别非Web元素。文件上传主要分为两类:基于input控件的上传和非input控件的上传。对于input控件,可以直接使用sendKeys()方法输入文件的绝对路径来模拟选择文件。在项目实战中,给出了一个简单的HTML页面和对应的Java代码示例,展示了如何使用Selenium选取并上传文件。
7 0
|
2天前
|
JavaScript 前端开发 Java
《手把手教你》系列技巧篇(五十二)-java+ selenium自动化测试-处理面包屑(详细教程)
【5月更文挑战第16天】本文介绍了网页面包屑导航的概念、作用及其实现方式。面包屑导航是一种用户界面元素,帮助用户理解他们在网站中的位置并方便返回。通常形式为“首页>分类>子分类>内容页”,最多三层结构。在自动化测试中,处理面包屑涉及获取层级关系和当前层级,可以通过查找包含面包屑的div或ul元素,再提取其中的链接来实现。文中还提供了一个基于HTML和JavaScript的简单示例,并展示了相应的自动化测试代码设计和运行结果。
10 0
|
4天前
|
搜索推荐 Java 测试技术
《手把手教你》系列技巧篇(五十)-java+ selenium自动化测试-字符串操作-上篇(详解教程)
【5月更文挑战第14天】本文介绍了自动化测试中如何从字符串中提取特定信息,主要讲解了两种方法:正则表达式和字符串切片操作。文章提供了一个测试场景,即在搜索引擎中搜索“北京宏哥”并比较百度和必应的搜索结果数量。通过字符串切片函数`split()`,可以从搜索结果的描述中提取出数字。代码示例展示了如何使用Java实现这个功能,包括在百度和必应的搜索页面获取结果数量,并进行比较。文章最后还简单提到了其他字符串截取的方法,如`substring()`和`StringUtils`类中的方法。
19 2
|
5天前
|
JavaScript 前端开发 Java
《手把手教你》系列技巧篇(四十九)-java+ selenium自动化测试-隐藏元素定位与操作(详解教程)
【5月更文挑战第13天】本文主要讨论了在Selenium自动化测试中如何处理前端隐藏元素的问题。隐藏元素通常是通过`type="hidden"`或`style="display: none;"`属性实现的,它们在页面上不可见,但仍然存在于HTML代码中。Selenium可以定位到这些隐藏元素,但无法直接进行点击、输入等操作,会报错“ElementNotInteractableException”。
28 3
|
6天前
|
JavaScript 前端开发 测试技术
《手把手教你》系列技巧篇(四十八)-java+ selenium自动化测试-判断元素是否可操作(详解教程)
【5月更文挑战第12天】本文介绍了WebDriver中用于判断元素状态的三个方法:`isEnabled()`、`isSelected()`和`isDisplayed()`。`isSelected()`检查元素是否被选中,通常用于勾选框。`isDisplayed()`则用来判断元素是否在页面上可见。`isEnabled()`方法确定元素是否可操作,例如是否能点击或输入内容。
17 1
|
7天前
|
存储 JavaScript Java
《手把手教你》系列技巧篇(四十七)-java+ selenium自动化测试-判断元素是否显示(详解教程)
【5月更文挑战第11天】WebDriver 的 `isDisplayed()` 方法用于检查页面元素是否可见,如果元素存在于DOM中且可视,返回`true`,否则返回`false`。在自动化测试中,这个方法常用于验证元素是否真正显示在页面上。示例代码展示了如何使用 `isDisplayed()` 判断百度登录页面的特定错误提示文字是否出现。
18 1
|
8天前
|
JavaScript Java 测试技术
《手把手教你》系列技巧篇(四十六)-java+ selenium自动化测试-web页面定位toast-下篇(详解教程)
【5月更文挑战第10天】本文介绍了使用Java和Selenium进行Web自动化测试的实践,以安居客网站为例。最后,提到了在浏览器开发者工具中调试和观察页面元素的方法。
22 2