Unnamed patterns and variables (Preview)

8.4.8.3）不同，因为字段隐藏中没有区分静态和非静态字段，而在方法隐藏中区分静态和非静态方法。

一个隐藏字段可以通过使用限定名称（6.5.6.2）来访问，如果它是static，或者通过包含关键字super的字段访问表达式（15.11.2）或者转型为超类类型。

在这方面，字段的隐藏类似于方法的隐藏。

如果字段声明隐藏了另一个字段的声明，则这两个字段不需要具有相同的类型。

一个类从其直接超类和直接超接口继承所有非private字段，这些字段对于类中的代码是可访问的（6.6），并且没有被类中的声明隐藏。

超类的private字段可能对子类可访问 - 例如，如果两个类都是同一个类的成员。然而，private字段永远不会被子类继承。

一个类可能从其超类和超接口或仅从其超接口继承具有相同名称的多个字段。这种情况本身不会导致编译时错误。然而，在类的主体内部尝试通过其简单名称引用任何这样的字段将导致编译时错误，因为引用是模糊的。

可能有几条路径通过接口继承相同的字段声明。在这种情况下，该字段被认为只继承一次，并且可以通过其简单名称引用而不会产生歧义。

interface Frob  { float v = 2.0f; }
class SuperTest { int   v = 3; }
class Test extends SuperTest implements Frob {
    public static void main(String[] args) {
        new Test().printV();
    }
    void printV() { System.out.println(v); }
}

interface Frob  { float v = 2.0f; }
class SuperTest { int   v = 3; }
class Test extends SuperTest implements Frob {
    public static void main(String[] args) {
        new Test().printV();
    }
    void printV() {
        System.out.println((super.v + Frob.v)/2);
    }
}

2.5

interface Color        { int RED=0, GREEN=1,  BLUE=2;  }
interface TrafficLight { int RED=0, YELLOW=1, GREEN=2; }
class Test implements Color, TrafficLight {
    public static void main(String[] args) {
        System.out.println(GREEN);  // 编译时错误
        System.out.println(RED);    // 编译时错误
    }
}

8.4 方法声明

8.4.1 形式参数

方法或构造函数的形式参数（如果有）由逗号分隔的参数规范器列表指定。每个参数规范器由类型（可选地由final修饰符和/或一个或多个注释前导）和一个标识符（可选地跟随方括号）组成，指定参数的名称。

如果方法或构造函数没有形式参数，也没有接收者参数，则在方法或构造函数的声明中会出现一个空的括号对。

FormalParameterList:

FormalParameter {, FormalParameter}

FormalParameter:

{VariableModifier} UnannType VariableDeclaratorId

VariableArityParameter

VariableArityParameter:

{VariableModifier} UnannType {Annotation} ... Identifier

VariableModifier:

Annotation

final

这里为方便起见显示了来自8.3和4.3的以下产生：

Dims:

{Annotation} [ ] {{Annotation} [ ]}

方法或构造函数的形式参数可以是可变数量参数，在类型后面跟着省略号表示。对于一个方法或构造函数，最多只允许一个可变数量参数。如果可变数量参数出现在参数规范器列表的除最后位置之外的任何位置，则会导致编译时错误。

在VariableArityParameter的语法中，注意省略号（...）是一个独立的标记（3.11）。可以在它和类型之间放置空格，但这在风格上是不鼓励的。

如果一个方法的最后一个形式参数是可变数量参数，则该方法是一个可变数量方法。否则，它是一个固定数量方法。

有关形式参数声明的注释修饰符和接收者参数的规则在9.7.4和9.7.5中指定。

如果final作为形式参数声明的修饰符出现超过一次，则会导致编译时错误。

形式参数的作用域和遮蔽在6.3和6.4中指定。

从嵌套类或接口或lambda表达式中引用形式参数受限，如6.5.6.1中指定。

如果一个方法或构造函数声明了两个具有相同名称的形式参数，则会导致编译时错误。（即，它们的声明提到相同的Identifier。）

如果一个声明为final的形式参数在方法或构造函数的主体内部被赋值，则会导致编译时错误。

形式参数的声明类型取决于它是否是可变数量参数：

• 如果形式参数不是可变数量参数，则如果UnannType和VariableDeclaratorId中没有方括号对出现，则声明类型由UnannType表示，否则由10.2指定。

• 如果形式参数是可变数量参数，则声明类型是由10.2指定的数组类型。

如果可变数量参数的声明类型具有不可具体化的元素类型（4.7），则对于可变数量方法的声明会产生编译时未经检查的警告，除非该方法带有@SafeVarargs注解（9.6.4.7）或警告被@SuppressWarnings（9.6.4.5）抑制。

当方法或构造函数被调用时（15.12），实际参数表达式的值会在方法或构造函数体执行之前初始化新创建的参数变量，每个都声明了类型。在方法或构造函数体中，FormalParameter中出现的Identifier可以作为简单名称用于引用形式参数。

可变元方法的调用可能包含比形式参数更多的实际参数表达式。所有不对应于可变元参数之前的形式参数的实际参数表达式将被评估，并将结果存储到一个数组中，该数组将传递给方法调用（15.12.4.2）。

以下是实例方法和内部类构造函数中接收器参数的一些示例：

class Test {
    Test(/* ?? ?? */) {}
      // 在顶层类的构造函数中不允许有接收器参数，因为没有可想象的类型或名称。

    void m(Test this) {}
      // OK：实例方法中的接收器参数

    static void n(Test this) {}
      // 非法：静态方法中的接收器参数

    class A {
        A(Test Test.this) {}
          // OK：接收器参数表示立即包围正在构造的A实例的Test实例。

        void m(A this) {}
          // OK：接收器参数表示调用A.m()的A实例。

        class B {
            B(Test.A A.this) {}
              // OK：接收器参数表示立即包围正在构造的B实例的A实例。

            void m(Test.A.B this) {}
              // OK：接收器参数表示调用B.m()的B实例。
        }
    }
}

B的构造函数和实例方法显示了接收器参数的类型可以用限定的TypeName表示，就像其他类型一样；但是内部类构造函数中接收器参数的名称必须使用封闭类的简单名称。

8.10 记录类

8.10.1 记录组件

如果有的话，记录类的记录组件在记录声明的头部中指定。每个记录组件由一个类型（可选地由一个或多个注释前导）和一个标识符组成，该标识符指定记录组件的名称。记录组件对应于记录类的两个成员：隐式声明的private字段和显式或隐式声明的public访问器方法（8.10.3）。

如果记录类没有记录组件，则记录声明的头部中会出现一个空的括号对。

RecordHeader:

( [RecordComponentList] )

RecordComponentList:

RecordComponent {, RecordComponent}

RecordComponent:

{RecordComponentModifier} UnannType Identifier

VariableArityRecordComponent

VariableArityRecordComponent:

{RecordComponentModifier} UnannType {Annotation} ... Identifier

RecordComponentModifier:

Annotation

记录组件可以是可变元记录组件，在类型后面跟着省略号表示。对于记录类，最多只允许一个可变元记录组件。如果可变元记录组件出现在记录组件列表中除了最后位置之外的任何位置，则会导致编译时错误。

有关记录组件声明的注释修饰符的规则在9.7.4和9.7.5中指定。

如果记录声明中声明了一个记录组件的名称为clone、finalize、getClass、hashCode、notify、notifyAll、toString或wait，则会导致编译时错误。

这些是Object中的无参public和protected方法的名称。禁止将它们作为记录组件的名称有助于避免混淆。首先，每个记录类提供了hashCode和toString的实现，返回记录对象作为整体的表示；它们不能作为记录组件的访问器方法（8.10.3）， 因此无法从记录类外部访问这些记录组件。类似地，一些记录类可能提供clone和（遗憾的是）finalize的实现，因此无法通过访问器方法访问名为clone或finalize的记录组件。最后，Object中的getClass、notify、notifyAll和wait方法是final的，因此具有相同名称的记录组件无法具有访问器方法（这些访问器方法具有与final方法相同的签名，因此会尝试但无法成功地覆盖它们）。

如果记录声明中声明了两个名称相同的记录组件，则会导致编译时错误。

记录组件的声明类型取决于它是否是可变元记录组件：

• 如果记录组件不是可变元记录组件，则声明的类型由UnannType表示。

• 如果记录组件是可变元记录组件，则声明的类型是由10.2指定的数组类型。

如果可变元记录组件的声明类型具有不可具体化的元素类型（4.7），则在可变元记录组件的声明中会发生编译时未经检查的警告，除非规范构造函数（8.10.4）带有@SafeVarargs注解（9.6.4.7）或通过@SuppressWarnings抑制警告（9.6.4.5）。

第9章：接口

9.3 字段（常量）声明

ConstantDeclaration:

{ConstantModifier} UnannType VariableDeclaratorList ;

ConstantModifier:

（其中之一）

Annotation public

static final

有关UnannType，请参阅8.3。以下来自4.3和8.3的产生规则如下：

VariableDeclaratorList:

VariableDeclarator {, VariableDeclarator}

VariableDeclarator:

VariableDeclaratorId [= VariableInitializer]

Dims:

{Annotation} [ ] {{Annotation} [ ]}

VariableInitializer:

Expression

ArrayInitializer

接口字段声明的注释修饰符规则在9.7.4和9.7.5中指定。

接口声明体中的每个字段声明都是隐式public、static和final的。对于这些字段，可以冗余地指定这些修饰符中的任何一个或全部。

如果同一个关键字在字段声明的修饰符中出现超过一次，则会导致编译时错误。

如果一个字段声明中出现两个或更多（不同的）字段修饰符，通常情况下，尽管不是必须的，它们应该按照ConstantModifier的产生规则中所示的顺序出现。

如果在UnannType和VariableDeclaratorId中没有出现括号对，则字段的声明类型由UnannType表示，否则由10.2指定。

接口字段声明的作用域和遮蔽在6.3和6.4.1中指定。

因为接口字段是static的，其声明引入了一个静态上下文（8.1.3），这限制了引用当前对象的构造的使用。特别地，关键字this和super在静态上下文中是被禁止的（15.8.3，15.11.2），未经限定的引用实例变量、实例方法和词法封闭声明的类型参数也是被禁止的（6.5.5.1，6.5.6.1，15.12.3）。

如果接口声明了一个带有特定名称的字段，则该字段的声明被认为是隐藏了接口的超级接口中具有相同名称的所有可访问字段的声明。

一个接口可以继承多个具有相同名称的字段。这种情况本身不会导致编译时错误。然而，在接口声明的主体内部尝试通过简单名称引用任何这样的字段将导致编译时错误，因为引用是模糊的。

同一个字段声明从一个接口继承可能有多条路径。在这种情况下，该字段被认为只继承一次，并且可以通过其简单名称引用而不会产生歧义。

interface BaseColors {
    int RED = 1, GREEN = 2, BLUE = 4;
}
interface RainbowColors extends BaseColors {
    int YELLOW = 3, ORANGE = 5, INDIGO = 6, VIOLET = 7;
}
interface PrintColors extends BaseColors {
    int YELLOW = 8, CYAN = 16, MAGENTA = 32;
}
interface LotsOfColors extends RainbowColors, PrintColors {
    int FUCHSIA = 17, VERMILION = 43, CHARTREUSE = RED+90;
}

第14章：块、语句和模式

14.4 本地变量声明

一个本地变量声明声明并可选择初始化一个或多个本地变量（4.12.3）。

LocalVariableDeclaration:

{VariableModifier} LocalVariableType VariableDeclaratorList

LocalVariableType:

UnannType

var

参见UnannType的8.3。这里为方便起见展示了来自4.3、8.3和8.4.1的以下产生：

VariableModifier:

Annotation

final

VariableDeclaratorList:

VariableDeclarator {, VariableDeclarator}

VariableDeclarator:

VariableDeclaratorId [= VariableInitializer]

Dims:

{Annotation} [ ] {{Annotation} [ ]}

VariableInitializer:

Expression

ArrayInitializer

本地变量声明可以出现在以下位置：

• 块中的本地变量声明语句（14.4.2）

• 基本for语句的头部（14.14.1）

• 增强for语句的头部（14.14.2）

• try-with-resources语句的资源规范（14.20.3）

• 模式（14.30.1）

有关本地变量声明的注解修饰符的规则在9.7.4和9.7.5中指定。

如果关键字final作为本地变量声明的修饰符出现，则本地变量是一个final变量（4.12.4）。

如果final作为本地变量声明的修饰符出现超过一次，则会导致编译时错误。

如果LocalVariableType是var，并且以下任一情况为真，则会导致编译时错误：

• 列出了多个VariableDeclarator。

• VariableDeclaratorId有一个或多个方括号对。

• VariableDeclarator缺少初始化器。

• VariableDeclarator的初始化器是一个ArrayInitializer。

• VariableDeclarator的初始化器包含对该变量的引用。

var a = 1;            // 合法
var b = 2, c = 3.0;   // 非法：多个声明符
var d[] = new int[4]; // 非法：额外的方括号对
var e;                // 非法：没有初始化器
var f = { 6 };        // 非法：数组初始化器
var g = (g = 7);      // 非法：初始化器中的自引用

14.11 switch语句

switch语句根据表达式的值将控制转移到多个语句或表达式中的一个。

SwitchStatement:

switch ( Expression ) SwitchBlock

Expression称为选择器表达式。选择器表达式的类型必须是char、byte、short、int或引用类型，否则会导致编译时错误。

14.11.1 switch块

switch语句和switch表达式的主体都称为switch块。本小节介绍适用于所有switch块的一般规则，无论它们出现在switch语句中还是switch表达式中。其他小节介绍适用于switch语句中的switch块（14.11.2）或switch表达式中的switch块（15.28.1）的其他规则。

SwitchBlock:

{ SwitchRule {SwitchRule} }

{ {SwitchBlockStatementGroup} {SwitchLabel :} }

SwitchRule:

SwitchLabel -> Expression ;

SwitchLabel -> Block

SwitchLabel -> ThrowStatement

SwitchBlockStatementGroup:

SwitchLabel : { SwitchLabel :} BlockStatements

CaseConstant：

条件表达式

CasePattern：

模式

Guard：

when 表达式

一个switch块可以包含以下内容之一：

• Switch规则，使用->引入switch规则表达式、switch规则块或switch规则throw语句；或

• Switch标记语句组，使用:引入switch标记块语句。

每个switch规则和switch标记语句组都以switch标签开头，可以是case标签或default标签。对于switch标记语句组，允许有多个switch标签。

case标签由case常量列表或case模式一个或多个组成。

• 对于具有case常量的case标签，每个case常量必须是（1）null文字、（2）常量表达式（15.29）或（3）枚举常量（简单或限定）的名称（8.9.1）；否则会发生编译时错误。单个null case常量也可以与default关键字配对。

• 对于具有case模式的case标签，如果任何case模式声明一个或多个模式变量，则会发生编译时错误。

  如果一个case标签有多个声明模式变量的case模式，那么如果应用case标签，则不清楚哪个变量将被初始化。例如，在代码片段switch (obj) { case Integer i, Boolean b -> { ... } ... }中，在->右侧的块中不清楚哪个模式变量i或b将被初始化，因此这是一个编译时错误。代码片段switch(obj) { case Integer i, Boolean _ -> { ... } ... }仍然导致编译时错误，因为仍然不清楚模式变量i是否将被初始化。代码片段switch (obj) { case Integer _, Boolean _ -> { ... } ... }不会导致编译时错误。

具有case模式的case标签可以具有可选的when表达式，称为守卫，它表示与模式匹配的值的进一步测试。如果（i）它没有守卫，或者（ii）它具有值为true的常量表达式（15.29）的守卫，则称case标签为未守卫；否则为守卫。

switch标签及其case常量和case模式称为与switch块关联。

对于给定的switch块，以下两个条件都必须为真，否则会发生编译时错误：

• 与switch块关联的case常量中的任何两个值不能相同。

• 与switch块关联的default标签不能超过一个。

与case标签关联的任何守卫必须具有类型boolean或Boolean。任何守卫中使用但未声明的变量必须是final或有效最终的（4.12.4），不能被赋值（15.26）、递增（[15.14.2]）或递减（[15.14.3]），否则会发生编译时错误。如果守卫是值为false的常量表达式（15.29），则会发生编译时错误。

switch语句或switch表达式的switch块与选择器表达式的类型T是switch兼容的，如果以下所有条件都为真：

• 如果与switch块关联任何null常量，则T是引用类型。

• 如果T是枚举类型，则与switch块关联的每个case常量，如果是枚举常量的名称，则是类型T的枚举常量的名称。

• 如果T不是枚举类型，则与switch块关联的每个case常量，如果是枚举常量的限定名称，则是与T兼容的枚举常量的限定名称（5.2）。

• 与switch块关联的每个case常量，如果是常量表达式，则与T兼容，并且T是char、byte、short、int、Character、Byte、Short、Integer或String之一。

• 与switch块关联的每个模式p，p适用于类型T（14.30.3）。

switch块不适用于boolean、long、float和double类型。switch语句或switch表达式的选择器表达式不能具有这些类型之一。

switch语句或switch表达式的switch块必须与选择器表达式的类型兼容，否则会发生编译时错误。

在switch块中的switch标签被称为支配的，如果对于它适用的每个值，前面的switch标签也将适用。如果switch块中的任何switch标签被支配，则会发生编译时错误。确定switch标签是否被支配的规则如下：

• 如果在switch块中有一个带有case模式q的case标签被支配，那么如果在switch块中有一个前置的无保护的带有case模式p的case标签，并且p支配q，则q被支配（14.30.3）。

  一个模式支配另一个模式的定义基于类型。例如，类型模式Object o支配类型模式String s，因此以下代码会导致编译时错误：

  Object obj = ...
  switch (obj) {
      case Object o ->
          System.out.println("一个对象");
      case String s   ->                 // 错误 - 被支配的case标签
          System.out.println("一个字符串");
  }

  带有case模式的有保护case标签被不带有保护的相同模式的case标签支配。例如，以下代码会导致编译时错误：

  String str = ...;
  switch (str) {
      case String s ->
          System.out.println("一个字符串");
      case String s when s.length() == 2 ->  // 错误 - 被支配的case标签
          System.out.println("长度为两个字符的字符串");
      ...
  }

  另一方面，带有case模式的有保护case标签不被认为支配具有相同case模式的无保护case标签。这允许以下常见的模式编程风格：

  Integer j = ...;
  switch (j) {
      case Integer i when i <= 0 ->
          System.out.println("小于或等于零");
      case Integer i ->
          System.out.println("一个整数");
  }

  唯一的例外是当保护是一个具有值为true的常量表达式时，例如：

  Integer j = ...;
  switch (j) {
      case Integer i when true ->            // 允许但为什么写这个？
          System.out.println("一个整数");
      case Integer i ->                     // 错误 - 被支配的case标签
          System.out.println("一个整数");
  }

  如果一个case标签具有多个模式，那么如果任何一个模式被前置的无保护case标签中出现的模式支配，则该case标签被支配；例如Integer _被前置的无保护case中的Number _支配：

  Object o = ...
  switch (o) {
      case Number _ ->
          System.out.println("一个数字");
      case Integer _, String _ ->             // 错误 - 被支配的case模式：`Integer _`
          System.out.println("一个整数或一个字符串");
  }

• 如果一个带有case常量c的case标签被支配，那么以下情况之一成立：

  • c是原始类型S的常量表达式，并且在switch块中有一个前置的带有S的包装类为无条件模式的case标签。

  • c是引用类型T的常量表达式，并且在switch块中有一个前置的带有T类型为无条件模式的case标签。

  • c是类型T的枚举常量，并且在switch块中有一个前置的带有T类型为无条件模式的case标签。

  例如，带有Integer类型模式的case标签支配整数字面值的case标签：

  Integer j = ...;
  switch (j) {
      case Integer i ->
          System.out.println("一个整数");
      case 42 ->                              // 错误 - 被支配！
          System.out.println("42!");
  }

  对保护的分析——一般情况下是不可判定的。例如，即使如果选择器表达式的值为42，以下代码也会导致编译时错误：

  Integer j = ...;
  switch (j) {
      case Integer i when i != 42 ->
          System.out.println("一个不是42的整数");
      case 42 ->                                  // 错误 - 被支配！
          System.out.println("42!");
  }

  任何带有case常量的case标签应该出现在带有case模式的标签之前；例如：

  Integer j = ...;
  switch (j) {
      case 42 ->
          System.out.println("42");
      case Integer i when i < 50 ->
          System.out.println("小于50的整数");
      case Integer i  ->
          System.out.println("一个整数");
  }

int sum(int[] a) {
    int sum = 0;
    for (int i : a) sum += i;
    return sum;
}

Map<String, Integer> histogram = ...;
double total = 0;
for (int i : histogram.values())
    total += i;
for (Map.Entry<String, Integer> e : histogram.entrySet())
    System.out.println(e.getKey() + " " + e.getValue() / total);
}

try (VariableAccess ...)
    Block

try (T #r = VariableAccess ...) {
    Block
}

try ({VariableModifier} R Identifier = Expression ...)
    Block

{
    final {VariableModifierNoFinal} R Identifier = Expression;
    Throwable #primaryExc = null;

    try ResourceSpecification_tail
        Block
    catch (Throwable #t) {
        #primaryExc = #t;
        throw #t;
    } finally {
        if (Identifier != null) {
            if (#primaryExc != null) {
                try {
                    Identifier.close();
                } catch (Throwable #suppressedExc) {
                    #primaryExc.addSuppressed(#suppressedExc);
                }
            } else {
                Identifier.close();
            }
        }
    }
}

try ({VariableModifier} R _ = Expression ...)
    Block

{
    final {VariableModifierNoFinal} R #i = Expression;
    Throwable #primaryExc = null;

    try ResourceSpecification_tail
        Block
    catch (Throwable #t) {
        #primaryExc = #t;
        throw #t;
    } finally {
        if (#i != null) {
            if (#primaryExc != null) {
                try {
                    #i.close();
                } catch (Throwable #suppressedExc) {
                    #primaryExc.addSuppressed(#suppressedExc);
                }
            } else {
                #i.close();
            }
        }
    }
}

try ResourceSpecification
    Block
[Catches]
[Finally]

try {
    try ResourceSpecification
        Block
}
[Catches]
[Finally]