String Templates (Preview)

例如，输入字符-和=只有在没有空格或注释时才能形成运算符标记-=（3.12）。另一个例子，十个输入字符staticvoid形成一个单一的标识符标记，而十一个输入字符static void（在c和v之间有一个ASCII SP字符）形成一对关键字标记，static和void，之间用空格分隔。

为了与某些操作系统兼容，如果ASCII SUB字符（\u001a，或控制-Z）是转义输入流中的最后一个字符，则会被忽略。

输入产生是模棱两可的，这意味着对于一些输入字符序列，将输入字符减少为输入元素（即对输入字符进行标记化）的方式不止一种。歧义解决如下：

• 一个可以减少为标识符标记或文字标记的输入字符序列总是减少为文字标记。

• 一个可以减少为标识符标记或保留关键字标记（3.9）的输入字符序列总是减少为保留关键字标记。

• 一个可以减少为上下文关键字标记或其他（非关键字）标记的输入字符序列根据上下文减少，如3.9中指定的。

• 如果输入字符>出现在类型上下文中（4.11），即作为句法语法中的类型或未声明类型的一部分（4.1，8.3），它总是减少为数值比较运算符>，即使它可以与相邻的>字符结合形成不同的运算符。

  如果没有这个>字符的规则，类型中的两个连续>括号（例如List<List<String>>）将被标记为有符号右移运算符>>，而类型中的三个连续>括号（例如List<List<List<String>>>）将被标记为无符号右移运算符>>>。更糟糕的是，类型中四个或更多连续的>括号（例如List<List<List<List<String>>>>）的标记是模棱两可的，因为各种组合的>，>>和>>>标记可以代表>>>>字符。

考虑结果输入流中的两个标记x和y。如果x在y之前，则我们说x在y的左侧，并且y在x的右侧。

例如，在这段简单的代码中：

class Empty {
}

我们说}标记在{标记的右侧，即使在这个二维表示中，它出现在{标记的下方和左侧。关于使用左和右这两个词的约定使我们可以谈论，例如，二元运算符的右操作数或赋值的左侧。

3.10 文字

3.10.7 转义序列

在字符文字、字符串文字、 和文本块以及模板片段（3.10.4，3.10.5，3.10.6，3.13）中，转义序列允许表示一些非图形字符，而不使用Unicode转义（3.3），以及单引号、双引号和反斜杠字符。

转义序列：

\ b *（退格 BS，Unicode \u0008）*

\ s *（空格 SP，Unicode \u0020）*

\ t *（水平制表符 HT，Unicode \u0009）*

\ n *（换行 LF，Unicode \u000a）*

\ f *（换页 FF，Unicode \u000c）*

\ r *（回车 CR，Unicode \u000d）*

\ 行终止符 *（行继续，没有Unicode表示）*

\ " *（双引号"，Unicode \u0022）*

\ ' *（单引号'，Unicode \u0027）*

\ \ *（反斜杠\，Unicode \u005c）*

八进制转义 *（八进制值，Unicode \u0000到\u00ff）*

八进制转义：

\ 八进制数字

\ 八进制数字 八进制数字

\ ZeroToThree 八进制数字 八进制数字 #

八进制数字：

（之一）

0 1 2 3 4 5 6 7

ZeroToThree：

（之一）

0 1 2 3

上述八进制数字产生来自3.10.1。八进制转义是为了与C兼容而提供的，但只能表示Unicode值\u0000到\u00FF，因此通常更喜欢使用Unicode转义。

如果在转义序列中反斜杠后面的字符不是行终止符或ASCII b、s、t、n、f、r、"、'、\、0、1、2、3、4、5、6或7，则是编译时错误。

字符文字、字符串文字、 或文本块或模板片段中的转义序列通过用转义序列语法中的Unicode转义表示的单个字符替换其\和尾随字符来解释。行继续转义序列没有对应的Unicode转义，因此通过将其替换为无内容来解释。

行继续转义序列可以出现在文本块中，但不能出现在字符文字或字符串文字中，因为每个都不允许行终止符。

3.13 片段

第7章：包和模块

7.3 编译单元

CompilationUnit是Java程序的语法文法（2.3）的目标符号（2.1）。它由以下产生式定义：

CompilationUnit：

OrdinaryCompilationUnit

ModularCompilationUnit

OrdinaryCompilationUnit：

[PackageDeclaration] {ImportDeclaration} {TopLevelClassOrInterfaceDeclaration}

ModularCompilationUnit：

{ImportDeclaration} ModuleDeclaration

普通编译单元由三个部分组成，每个部分都是可选的：

• package声明（7.4），给出编译单元所属包的完全限定名称（6.7）。

  没有package声明的编译单元属于一个未命名包（7.4.2）。

• import声明（7.5），允许引用其他包中的类和接口，以及类和接口的static成员，使用它们的简单名称。

• 类和接口的顶层声明（7.6）。

模块编译单元由一个module声明（7.7）组成，可选地在前面有import声明。这些import声明允许在module声明内使用它们的简单名称引用来自此模块和其他模块的包中的类和接口，以及static类和接口的成员。

每个编译单元隐式导入

1. 每个在预定义包java.lang中声明的public类或接口，就好像在每个编译单元的开头出现了声明import java.lang.*;，紧随任何package声明之后。

因此，所有 那些隐式导入的 类和接口类、接口和静态字段的名称在每个编译单元中都可以作为简单名称使用。

主机系统确定哪些编译单元是可观察的，除了预定义包java及其子包lang和io中的编译单元始终是可观察的。

7.5 导入声明

7.5.3 单静态导入声明

一个单静态导入声明从一个类或接口中导入所有可访问的具有给定简单名称的static成员。这使得这些static成员在单静态导入声明所在的模块、类和接口声明中可以使用其简单名称。

SingleStaticImportDeclaration:

import static TypeName . Identifier ;

TypeName必须是一个类或接口的规范名称（6.7）。

该类或接口必须是命名包的成员，或者是一个类或接口的成员，其最外层词法封闭的类或接口声明（8.1.3）是命名包的成员，否则将出现编译时错误。

如果命名的类或接口不可访问（6.6），则会出现编译时错误。

Identifier必须命名命名类或接口的至少一个static成员。如果没有该名称的static成员，或者所有命名的成员都不可访问，则会出现编译时错误。

一个单静态导入声明可以导入具有相同名称的多个字段、类或接口，或者具有相同名称和签名的多个方法。当命名的类或接口从其自身的超类型继承多个具有相同名称的字段、成员类、成员接口或方法时，就会发生这种情况。

如果同一编译单元中的两个单静态导入声明尝试导入具有相同简单名称的类或接口，则会出现编译时错误，除非这两个类或接口相同，此时重复声明将被忽略。

如果单静态导入声明导入一个简单名称为x的类或接口，并且编译单元还声明了一个顶级类或接口（7.6），其简单名称为x，则会出现编译时错误。

如果一个编译单元既包含导入一个简单名称为x的类或接口的单静态导入声明，又包含一个单类型导入声明（7.5.1），导入一个简单名称为x的类或接口，则会出现编译时错误，除非这两个类或接口相同，此时重复声明将被忽略。

7.5.4 静态导入所有声明

一个静态导入所有声明允许根据需要导入一个命名类或接口的所有可访问的static成员。

StaticImportOnDemandDeclaration:

import static TypeName . * ;

TypeName必须是一个类或接口的规范名称（6.7）。

该类或接口必须是命名包的成员，或者是一个类或接口的成员，其最外层词法封闭的类或接口声明（8.1.3）是命名包的成员，否则将出现编译时错误。

如果命名的类或接口不可访问（6.6），则会出现编译时错误。

同一编译单元中的两个或更多静态导入所有声明可以命名相同的类或接口；效果就好像确实有一个这样的声明。

第12章：执行

12.5 创建新类实例

当对类实例创建表达式（15.9）进行评估导致实例化类时，将显式创建一个新的类实例。

在以下情况下可能隐式创建一个新的类实例：

• 加载包含字符串文字（3.10.5）或文本块（3.10.6）的类或接口可能创建一个新的String对象，用于表示由字符串文字或文本块表示的字符串。（如果表示与字符串文字或文本块表示的Unicode代码点序列相同的String实例已经被interned，则不会发生对象创建。）

• 执行导致装箱转换（5.1.7）的操作。装箱转换可能会创建与原始类型之一关联的包装类（Boolean、Byte、Short、Character、Integer、Long、Float、Double）的新对象。

• 执行不是常量表达式的字符串连接运算符+（15.18.1）总是创建一个新的String对象来表示结果。字符串连接运算符还可能为原始类型的值创建临时包装对象。

• 评估方法引用表达式（15.13.3）或lambda表达式（15.27.4）可能需要创建一个实现函数式接口类型（9.8）的类的新实例。

这些情况中的每一个都确定要调用的特定构造函数（8.8），并在类实例创建过程中为其分配指定参数（可能没有）的内存空间。

每当创建一个新的类实例时，都会为其分配内存空间，以容纳类中声明的所有实例变量以及类的每个超类中声明的所有实例变量，包括可能被隐藏的所有实例变量（8.3）。

如果没有足够的空间可用来为对象分配内存，则创建类实例将以OutOfMemoryError异常突然完成。否则，新对象中的所有实例变量，包括在超类中声明的变量，都将被初始化为它们的默认值（4.12.5）。

在将新创建的对象的引用作为结果返回之前，将处理指定构造函数以使用以下过程初始化新对象：

1. 将构造函数的参数分配给此构造函数调用的新创建的参数变量。

2. 如果此构造函数以同一类中的另一个构造函数的显式构造函数调用（8.8.7.1）（使用this）开头，则评估参数并递归地处理该构造函数调用，使用相同的五个步骤。如果该构造函数调用突然完成，则出于同样的原因，此过程也会突然完成；否则，继续进行第5步。

3. 此构造函数不以同一类中的另一个构造函数的显式构造函数调用（使用this）开头。如果此构造函数不是为Object类而设计的，则此构造函数将以超类构造函数的显式或隐式调用（使用super）开头。评估参数并递归地处理该超类构造函数调用，使用相同的五个步骤。如果该构造函数调用突然完成，则出于同样的原因，此过程也会突然完成。否则，继续进行第4步。

4. 执行此类的实例初始化程序和实例变量初始化程序，将实例变量初始化程序的值分配给源代码中以文本方式按从左到右的顺序出现的相应实例变量。如果执行任何这些初始化程序导致异常，则不会处理更多的初始化程序，并且此过程将以相同的异常突然完成。否则，继续进行第5步。

5. 执行此构造函数的其余部分。如果执行完成突然完成，则出于同样的原因，此过程也会突然完成。否则，此过程正常完成。

与C++不同，Java编程语言在创建新类实例期间不指定方法分派的修改规则。如果在初始化对象时调用了被子类覆盖的方法，则会使用这些覆盖方法，即使在新对象完全初始化之前也是如此。

class Point {
    int x, y;
    Point() { x = 1; y = 1; }
}
class ColoredPoint extends Point {
    int color = 0xFF00FF;
}
class Test {
    public static void main(String[] args) {
        ColoredPoint cp = new ColoredPoint();
        System.out.println(cp.color);
    }
}

ColoredPoint() { super(); }

Point() { super(); x = 1; y = 1; }

Object() { }

class Super {
    Super() { printThree(); }
    void printThree() { System.out.println("three"); }
}
class Test extends Super {
    int three = (int)Math.PI;  // 即，3
    void printThree() { System.out.println(three); }

    public static void main(String[] args) {
        Test t = new Test();
        t.printThree();
    }
}

0
3

第15章：表达式

15.8 主要表达式

主要表达式包括大多数最简单的表达式类型，所有其他表达式都是由它们构建的：字面量、对象创建、字段访问、方法调用、方法引用、数组访问和模板表达式。带括号的表达式在语法上也被视为主要表达式。

主要：

非新数组主要

数组创建表达式

非新数组主要：

字面量

类字面量

this

类型名称 . this

( 表达式 )

类实例创建表达式

字段访问

数组访问

方法调用

方法引用

模板表达式

Java编程语言的这部分语法在两个方面是不寻常的。首先，人们可能期望简单名称，例如局部变量和方法参数的名称，是主要表达式。出于技术原因，当引入后缀表达式时（15.14），名称稍后与主要表达式一起分组。

技术原因与允许仅具有一个令牌前瞻的左到右解析Java程序有关。考虑表达式(z[3])和(z[])。第一个是带括号的数组访问（15.10.3），第二个是强制转换的开始（15.16）。在前瞻符号为[时，左到右解析将z减少为非终结符Name。在强制转换的上下文中，我们不希望将名称减少为Primary，但如果Name是Primary的替代方案之一，那么我们无法确定是否进行减少（也就是说，我们无法确定当前情况是否会变成带括号的数组访问或强制转换），而不查看两个令牌的前瞻，即[后面的令牌。这里提供的语法通过保持Name和Primary分开，并允许在某些其他语法规则中使用任一者（ClassInstanceCreationExpression、MethodInvocation、ArrayAccess和PostfixExpression，尽管不包括FieldAccess，因为它直接使用标识符）。这种策略有效地推迟了是否应将Name视为Primary的问题，直到可以检查更多上下文。

第二个不寻常的特征避免了表达式"new int[3][3]"中的潜在语法歧义，该表达式在Java中始终表示创建多维数组的单个操作，但如果没有适当的语法技巧，也可能被解释为与"(new int[3])[3]"相同的含义。

通过将Primary的预期定义分为Primary和PrimaryNoNewArray来消除此歧义。（这可以与将Statement分为Statement和StatementNoShortIf（14.5）以避免"悬挂else"问题进行比较。）

15.8.1 词法字面量

字面量（3.10）表示一个固定的、不变的值。

以下来自3.10的产生式仅供参考：

字面量：

整数字面量

浮点数面量

布尔字面量

字符字面量

字符串字面量

文本块

空字面量

字面量的类型确定如下：

• 以L或l（小写L）结尾的整数字面量（3.10.1）的类型为long（4.2.1）。

  任何其他整数字面量的类型为int（4.2.1）。

• 以F或f结尾的浮点数面量（3.10.2）的类型为float（4.2.3）。

  任何其他浮点数面量的类型为double（4.2.3）。

• 布尔字面量（3.10.3）的类型为boolean（4.2.5）。

• 字符字面量（3.10.4）的类型为char（4.2.1）。

• 字符串字面量（3.10.5）或文本块（3.10.6）的类型为String（4.3.3）。

• 空字面量null（3.10.8）的类型为null类型（4.1）；其值为null引用。

对字面值的评估总是正常完成。

15.8.6 模板表达式

// 带有简单嵌入字符串变量的字符串模板
String firstName = "Joan";
String lastName  = "Smith";
String fullName  = STR."\{firstName} \{lastName}";

// 带有嵌入整数表达式的字符串模板
int x = 10, y = 20;
String s1 = STR."\{x} + \{y} = \{x + y}";

// 嵌入表达式可以调用方法和访问字段
String s2 = STR."您有一个等待您的\{getOfferType()}！";
String s3 = STR."在\{req.date} \{req.time}从\{req.ipAddress}访问";

// 一个文本块模板，模拟带有嵌入表达式的HTML元素
String title = "我的网页";
String text  = "你好，世界";
String html = STR."""
        <html>
          <head>
            <title>\{title}</title>
          </head>
          <body>
            <p>\{text}</p>
          </body>
        </html>
        """;

// 一个文本块模板，模拟带有嵌入表达式的JSON值
String name    = "Joan Smith";
String phone   = "555-123-4567";
String address = "1 Maple Drive, Anytown";
String json = STR."""
    {
        "name":    "\{name}",
        "phone":   "\{phone}",
        "address": "\{address}"
    }
    """;

StringTemplate.Processor<String, RuntimeException> UPPER = (StringTemplate st) ->
    st.interpolate().toUpperCase();

String name = "Joan";
String result = UPPER."我的名字是\{name}";

StringTemplate.Processor<String, RuntimeException> MY_UPPER_STRINGS = (StringTemplate st) -> {
    List<String> fragments = st.fragments()
        .stream()
        .map(String::toUpperCase)
        .toList();
    List<Object> values = st.values();
    return StringTemplate.interpolate(fragments, values);
};

String name = "Joan";
String result = MY_UPPER_STRINGS."我的名字是\{name}";

StringTemplate.Processor<String, RuntimeException> MY_UPPER_VALUES = (StringTemplate st) -> {
    List<String> values = st.values()
        .stream()
        .map((o) -> (o==null)?"":o.toString().toUpperCase())
        .toList();
    return StringTemplate.interpolate(st.fragments(), values);
};

String title = null;
String firstName = "Joan";
String familyName = "Smith";
String result = MY_UPPER_VALUES."欢迎\{title}\{firstName} \{familyName}";

StringTemplate.Processor<JSONObject, RuntimeException> JSON =
    (StringTemplate st) -> new JSONObject(st.interpolate());

String name    = "Joan Smith";
String phone   = "555-123-4567";
String address = "1 Maple Drive, Anytown";

JSONObject doc = JSON."""
    {
        "name":    "\{name}",
        "phone":   "\{phone}",
        "address": "\{address}"
    }
    """;

StringTemplate.Processor<JSONObject, JSONException> JSON_VALIDATE = (StringTemplate st) -> {
    String stripped = st.interpolate().strip();
    if (!stripped.startsWith("{") || !stripped.endsWith("}")) {
        throws new JSONException("Missing brace");
    }
    return new JSONObject(stripped);
};

String name    = "Joan Smith";
String phone   = "555-123-4567";
String address = "1 Maple Drive, Anytown";
try {
    JSONObject doc = JSON_VALIDATE."""
        {
            "name":    "\{name}",
            "phone":   "\{phone}",
            "address": "\{address}"
        }
        """;
} catch (JSONException ex) {
    ...
}