Java编程中的字段、方法与构造器详解

### Java编程中的字段、方法与构造器详解 #### 1. Java传统与编程感悟 在Java技术写作中，引用伟大思想家的话语是一种传统。当回顾计算机编程经历时，亨利·戴维·梭罗在《瓦尔登湖》中的这段话常常浮现在脑海：“劳动者日复一日无暇保持真正的正直。他无力与他人维持最有男子气概的关系。他的劳动在市场上会贬值。他没时间做别的，只能成为一台机器。一个经常运用知识的人，怎能很好地记住成长所需的无知呢……我们天性中最美好的品质，就像水果上的光泽，只有小心翼翼地对待才能保存。然而，我们对待自己和他人都不够温柔。大多数人都在无声的绝望中生活。” 写作的动机是为他人服务，努力为“广大程序员”带来益处。真正伟大的程序员往往很谦逊，Java技术的发明者詹姆斯·高斯林博士就是这方面的完美榜样。 #### 2. 静态分析与编译器警告问题 詹姆斯·高斯林博士在接受采访时提到，尝试进行某些静态分析超出了当前技术水平，但可以进行各种其他分析。将更多分析推到系统的静态分析阶段能提高系统的可靠性。然而，这与对Bug Id 4128179 “为javac添加类似lint的功能” 的评估存在矛盾。由于一致性的重要性以及javac在建立一致性方面的作用，默认情况下不给出警告，但可以有一个非默认的可选模式。 目前 “一次编写，随处编译” 仅描述了确定赋值和不可达语句，应该在JLS中添加一章，将其扩展到包括编译器警告。不应该使用特殊标志（编译器选项）来解决这个问题，因为每个编译器的选项不同，Java程序员无法从他们习惯的标准化中受益。所有负责编写Java编译器的软件工程师应尽早坐下来讨论编译器警告问题。 #### 3. 字段和方法概述 方法和构造器有很多共同点，根据相关规范，构造器和方法在参数列表、签名、throws子句和重载方面 “结构和行为相同”。由于这些相似性，很多关于方法的内容同样适用于构造器。 文中大量使用了 `<init>` 和 `<clinit>` 方法名，它们分别是实例初始化方法和类初始化方法的简称。本章详细讨论的字段和方法修饰符只有 `final` 和 `abstract`，其他修饰符将在不同章节讨论。 #### 4. 字段详解 字段分为类变量、实例变量或接口常量，它们在类或接口体中声明，而局部变量在块中声明。字段和局部变量有共同的声明语法，如下表所示： | Part | Notes | | --- | --- | | 字段或局部变量修饰符 | 类和实例变量的字段修饰符有访问修饰符（`public`、`protected` 和 `private`）、`static`、`final`、`transient` 和 `volatile`。接口常量的修饰符只有 `public`、`static` 和 `final`。局部变量修饰符只有 `final`。 | | 类型名 | 字段或局部变量的类型。 | | 变量声明符 | 标识符是字段或局部变量的名称。变量初始化器由简单赋值运算符后跟一个表达式组成，该表达式的值必须与字段或局部变量声明中使用的类型兼容。 | 接口体中的字段声明隐式为 `public`、`static` 和 `final`，在原规范中显式使用这些常量修饰符不被鼓励，但在第二版中这种限制被移除。当使用多个字段修饰符时，习惯上按 `[public protected private] static final transient volatile` 的顺序列出，这个顺序反映了修饰符的常用顺序。 字段修饰符中，`final` 和 `volatile` 不能同时使用，因为 `final` 字段是常量，而 `volatile` 修饰符意味着变量会改变。`transient` 关键字用于默认序列化机制，未声明为 `transient` 的实例变量代表对象的持久状态。 变量声明符由标识符和可选的变量初始化器组成，可在同一声明语句中声明多个变量。例如： ```java /** Constant for the Unicode character block of the same name. */ public static final UnicodeBlock BASIC_LATIN = new UnicodeBlock("BASIC_LATIN"), LATIN_1_SUPPLEMENT = new UnicodeBlock("LATIN_1_SUPPLEMENT"), LATIN_EXTENDED_A = new UnicodeBlock("LATIN_EXTENDED_A"), LATIN_EXTENDED_B = new UnicodeBlock("LATIN_EXTENDED_B"), … ``` 类变量和接口常量的内存在类或接口加载时分配，卸载时销毁；实例变量的内存在类实例创建表达式求值时分配，对象被垃圾回收时销毁。 #### 5. 字段初始化 字段的初始化过程如下： 1. 内存分配后，字段会使用标准默认值自动初始化。 2. 然后执行 `<clinit>` 或 `<init>` 特殊初始化方法，其中变量初始化器和初始化块按文本顺序执行，并且会执行一个或多个构造器。 ##### 5.1 自动使用标准默认值初始化 与必须由程序员显式初始化的局部变量不同，字段和数组组件会自动初始化为标准默认值，如下表所示： | Data Type | Default Initialization | Literal Value | | --- | --- | --- | | byte | zero | (byte)0 | | short | zero | (short)0 | | char | NULL character | '\u0000' | | int | zero | 0 | | long | zero | 0L | | float | positive zero | 0.0f | | double | positive zero | 0.0 | | boolean | false | false | | 所有引用类型 | null reference | null | 是否应显式使用标准默认值初始化字段存在争议。显式赋值具有自我文档化的优点，能明确表示字段初始化没有延迟，但会有轻微的性能损失，因为在默认初始化后还需执行变量初始化器。数组组件总是初始化为标准默认值，无论数组是在方法还是构造器中创建并赋值给局部变量。 ##### 5.2 初始化块 初始化块是独立的代码块，最多有一个修饰符（`static` 关键字）且没有名称。文中使用实例初始化块和静态初始化块来称呼它们，以避免与实例变量初始化器和类变量初始化器混淆。 静态初始化块在类加载时只执行一次，实例初始化块每次类实例化时都会执行。使用初始化块的原因有： - 复杂的初始化逻辑，如加载数组。 - 调用会抛出受检查异常的方法（在变量初始化器中会产生编译器错误，匿名类除外）。 - 在匿名类中替代构造器（仅实例初始化块）。 例如，使用静态初始化块加载数组： ```java static final long[] BIT_MASK = new long[64]; static { for (int i = 0, length = BIT_MASK.length; i < length; i++) BIT_MASK[i] = 1L << i; } ``` 除匿名类外，变量初始化器不能调用会抛出受检查异常的方法，因此这些方法必须在初始化块中调用。静态初始化块必须捕获并处理受检查异常，实例初始化块可以抛出受检查异常，但前提是该异常包含在类中每个构造器的 `throws` 子句中。 初始化块必须能够正常完成。如果一个初始化块无法正常完成，后续的初始化块将不可达，例如： ```java public class Test { static final int x; static { while (true) {} } static { x = 1; } } ``` 编译这个类会产生编译器错误： ``` Test.java:3: Initializer must be able to complete normally. static { while (true) {} } ^ 1 error ``` #### 6. 构造器详解 构造器并非真正 “构造” 对象，在对象创建后，构造器主要是为实例变量赋值。无论是否有构造器，运行时系统在每次计算类实例创建表达式时都会创建并初始化对象。`this` 关键字在构造器中的使用表明对象在构造器（对应的 `<init>` 方法）执行之前就已创建。`<init>` 方法与其他实例方法的不同之处在于它是对象创建后第一个被调用的方法。 实例变量的初始化方式有四种，如下表所示： | 实例初始化代码 | 静态编译 | 动态分配 | | --- | --- | --- | | 使用标准默认值自动初始化 | ✔ | | | 变量初始化器 | ✔ | | | 实例初始化块 | ✔ | | | 构造器 | | ✔ | 构造器参数分为必需和可选两种。如果类中的每个构造器都包含某个动态分配初始值的参数，则该参数是必需的；否则是可选的。可选构造器参数在未指定时会使用默认值，默认值是静态编译的，即使在构造器中赋值也是如此。 例如： ```java //Store as long because Date is mutable private long date = new Date().getTime(); Widget() { } Widget(Date date) { if (date == null) throw new NullPointerException(); this.date = date.getTime(); } ``` 另一种实现方式： ```java //Store as long because Date is mutable private long date; Widget() { date = new Date().getTime(); } Widget(Date date) { if (date == null) throw new NullPointerException(); this.date = date.getTime(); } ``` 在无参数构造器中分配默认值可能是更好的实现方式，因为在调用带参数构造器时，变量初始化器可能是浪费时间的。但如果有多个构造器使用当前日期作为默认值，在变量初始化器中调用 `new Date()` 所需的代码更少。 实例变量的初始值总是以下三种情况之一： 1. 静态编译。 2. 必需的构造器参数。 3. 未指定时使用默认值的可选构造器参数。 这三种可能性构成了 “构造器数学” 的基础，不同的初始值组合对应不同的构造器要求，如下表所示： | 初始值 | 构造器要求 | | --- | --- | | 没有实例变量（如工具类）或所有实例变量都有静态编译的值 | 无（使用默认构造器） | | 所有实例变量都用必需的构造器参数初始化 | 一个构造器（也称为最小构造器） | | 所有实例变量未指定时都使用默认值，所有构造器参数都是可选的 | 对于每个 “数学上可能” 的构造器参数组合，有一个构造器。如果使用所有组合，构造器数量为 2 的可选构造器参数数量次方，再加上一个无参数构造器。 | | 静态编译的值和必需的构造器参数 | 与第二行相同（一个构造器） | | 静态编译的值和可选的构造器参数 | 与第三行相同 | | 必需的构造器参数和可选的构造器参数 | 与第三行相同，但用最小构造器代替无参数构造器 | | 静态编译的值、必需的构造器参数和可选的构造器参数 | 与第三行相同，但用最小构造器代替无参数构造器 | 在设计构造器时，还需要考虑以下两点： - 可能需要选择调用哪个超类构造器，选择可能取决于传递给子类构造器的参数。 - 构造器应尽可能调用同一类中的其他构造器，以避免冗余编码，特别是在涉及参数检查和初始化逻辑时。 确定构造器参数的顺序也很重要，必需的构造器参数应在每个构造器中处于相同位置，并且应始终位于前面。同时，要尽量减少构造器的数量，过多的构造器会成为接口设计问题。 综上所述，理解字段、方法和构造器的相关知识对于Java编程至关重要，它们是构建Java程序的基础。在实际编程中，需要根据具体需求合理使用这些概念，以提高代码的可读性、可维护性和性能。 ### Java编程中的字段、方法与构造器详解（续） #### 7. 字段初始化异常情况 在字段初始化过程中，可能会遇到一些异常情况，下面详细介绍几种常见的问题。 ##### 7.1 前向引用问题 前向引用是指在一个字段声明中引用了在其之后声明的字段。例如： ```java class ForwardReferenceExample { int a = b; // 前向引用 int b = 1; } ``` 在这个例子中，`a` 的初始化依赖于 `b`，但 `b` 在 `a` 之后声明。这种情况下，`a` 会被初始化为默认值（对于 `int` 类型是 0），而不是 `b` 的实际值。这可能会导致意外的结果，在编程时需要特别注意。 ##### 7.2 对象初始化期间调用重写方法 当在对象初始化过程中调用重写方法时，可能会出现一些意想不到的情况。考虑以下代码： ```java class Parent { Parent() { printMessage(); } void printMessage() { System.out.println("Parent message"); } } class Child extends Parent { String message = "Child message"; @Override void printMessage() { System.out.println(message); } } public class Main { public static void main(String[] args) { Child child = new Child(); } } ``` 在这个例子中，当创建 `Child` 对象时，会先调用 `Parent` 的构造器，在 `Parent` 构造器中调用了 `printMessage` 方法。由于 `printMessage` 方法被 `Child` 类重写，实际调用的是 `Child` 类的 `printMessage` 方法。但此时 `Child` 类的 `message` 字段还未初始化，所以输出结果为 `null`，而不是预期的 `"Child message"`。 ##### 7.3 内联常量总是看起来已初始化 内联常量是指在编译时就确定其值的常量。例如： ```java class InlinedConstantExample { static final int CONSTANT = 10; static { System.out.println("Static block: " + CONSTANT); } } ``` 在这个例子中，`CONSTANT` 是一个内联常量，在编译时就确定了其值为 10。即使在静态初始化块中引用它，也不会出现未初始化的问题。内联常量的这种特性在编程中可以带来一些便利，但也需要理解其原理。 ##### 7.4 字段的变量初始化器总是执行 无论字段是否已经通过默认值初始化，其变量初始化器都会执行。例如： ```java class VariableInitializerExample { int count = 0; // 先默认初始化为 0，再执行变量初始化器赋值为 0 } ``` 虽然 `count` 会先被默认初始化为 0，但变量初始化器 `count = 0` 仍然会执行。这会带来轻微的性能损失，但可以提高代码的可读性，明确表示字段初始化没有延迟。 ##### 7.5 对象初始化期间的 StackOverflowError 在某些情况下，对象初始化过程可能会导致 `StackOverflowError`。例如： ```java class StackOverflowExample { StackOverflowExample() { this(); // 递归调用构造器 } } ``` 在这个例子中，构造器中递归调用了自身，会导致无限循环，最终引发 `StackOverflowError`。在编写构造器时，要避免这种递归调用的情况。 ##### 7.6 初始化期间抛出受检查异常 在初始化过程中，如果需要抛出受检查异常，需要特殊处理。如前面提到的，静态初始化块必须捕获并处理受检查异常，实例初始化块可以抛出受检查异常，但前提是该异常包含在类中每个构造器的 `throws` 子句中。例如： ```java class ExceptionInitializationExample { static final int x; static { try { x = initialize(); } catch (Exception e) { throw new RuntimeException(e); } } static int initialize() throws Exception { throw new Exception("Initialization error"); } } ``` 在这个例子中，静态初始化块中调用了可能抛出异常的方法 `initialize`，并进行了异常捕获和处理。 #### 8. 常量相关知识 常量在 Java 编程中非常重要，下面介绍几种不同类型的常量。 ##### 8.1 编译时常量表达式 编译时常量表达式是指在编译时就可以确定其值的表达式。例如： ```java final int COMPILE_TIME_CONSTANT = 1 + 2; ``` 在这个例子中，`COMPILE_TIME_CONSTANT` 是一个编译时常量，其值在编译时就确定为 3。编译时常量可以用于很多场景，如 `case` 语句中。 ##### 8.2 内联常量 内联常量是指在编译时将常量的值直接嵌入到使用它的代码中。例如： ```java class InlinedConstantClass { static final int INLINED_CONSTANT = 10; public static void main(String[] args) { int result = INLINED_CONSTANT * 2; } } ``` 在编译后，`result` 的计算会直接使用 10 进行，而不是在运行时再去查找 `INLINED_CONSTANT` 的值。但内联常量也有一个问题，就是可变内联常量的问题。 ##### 8.2.1 可变内联常量的问题 如果一个内联常量的值在运行时发生了改变，可能会导致一些意外的结果。例如： ```java class ChangeableInlinedConstant { static final int CONSTANT = getValue(); static int getValue() { return 10; } public static void main(String[] args) { // 假设这里修改了 CONSTANT 的值（实际上无法直接修改） // 如果代码依赖于 CONSTANT 的原始值，可能会出现问题 } } ``` 虽然 `final` 关键字表示常量不可变，但如果其初始化依赖于一个方法调用，可能会让人误以为它是可变的。在使用内联常量时，要确保其值在编译时是确定的。 ##### 8.3 将可变对象声明为 final 可以将可变对象声明为 `final`，但这只是意味着引用不可变，对象本身的状态仍然可以改变。例如： ```java import java.util.ArrayList; import java.util.List; class FinalMutableObject { final List<String> list = new ArrayList<>(); public void addElement(String element) { list.add(element); // 可以修改对象的状态 } } ``` 在这个例子中，`list` 被声明为 `final`，但可以向其中添加元素，因为 `final` 只限制了引用不能改变。 ##### 8.4 空白 final 空白 `final` 是指声明为 `final` 但没有立即初始化的字段，必须在构造器中进行初始化。例如： ```java class BlankFinalExample { final int blankFinal; BlankFinalExample(int value) { blankFinal = value; // 在构造器中初始化 } } ``` 空白 `final` 提供了一定的灵活性，可以在不同的构造器中根据需要进行初始化。 ##### 8.5 枚举类型 枚举类型是一种特殊的常量类型，用于定义一组固定的值。例如： ```java enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY } ``` 枚举类型可以提高代码的可读性和可维护性，避免使用硬编码的常量。 ##### 8.6 将局部变量和参数声明为 final 将局部变量和参数声明为 `final` 可以确保它们的值在初始化后不会改变，提高代码的安全性。例如： ```java class FinalLocalVariableExample { void method(final int param) { // param = 10; // 编译错误，不能修改 final 参数的值 final int localVariable = 5; // localVariable = 10; // 编译错误，不能修改 final 局部变量的值 } } ``` ##### 8.7 常量接口反模式 常量接口反模式是指在接口中定义常量，然后让类实现该接口来使用这些常量。例如： ```java interface ConstantInterface { int CONSTANT_1 = 1; int CONSTANT_2 = 2; } class ImplementingClass implements ConstantInterface { // 可以直接使用 CONSTANT_1 和 CONSTANT_2 } ``` 这种做法会导致接口的滥用，因为类实现接口通常是为了实现其方法，而不是为了使用常量。更好的做法是使用枚举类型或静态常量类来管理常量。 #### 9. 方法相关知识 方法是 Java 程序中的重要组成部分，下面介绍方法的一些关键特性。 ##### 9.1 抽象方法 抽象方法是在抽象类或接口中声明但没有实现的方法，必须在子类中实现。例如： ```java abstract class AbstractClass { abstract void abstractMethod(); } class ConcreteClass extends AbstractClass { @Override void abstractMethod() { System.out.println("Implemented abstract method"); } } ``` 抽象方法的存在使得代码具有更好的可扩展性和灵活性。 ##### 9.2 结果类型和 return 语句 方法的结果类型指定了方法返回值的类型，使用 `return` 语句返回结果。例如： ```java class ReturnExample { int add(int a, int b) { return a + b; } } ``` 在某些情况下，可以使用返回值来表示失败。例如： ```java class FailureReturnExample { int findIndex(int[] array, int target) { for (int i = 0; i < array.length; i++) { if (array[i] == target) { return i; } } return -1; // 表示未找到 } } ``` ##### 9.3 形式参数列表 形式参数列表定义了方法接受的参数。在方法调用时，需要传递相应的参数。例如： ```java class ParameterExample { void printMessage(String message) { System.out.println(message); } } ``` 在处理参数时，需要进行参数检查，确保传递的参数符合要求。例如： ```java class ArgumentCheckExample { void divide(int a, int b) { if (b == 0) { throw new IllegalArgumentException("Divisor cannot be zero"); } System.out.println(a / b); } } ``` 另外，在处理引用类型参数时，可能需要进行防御性复制，避免外部修改影响内部状态。例如： ```java import java.util.ArrayList; import java.util.List; class DefensiveCopyExample { private List<String> list; DefensiveCopyExample(List<String> inputList) { this.list = new ArrayList<>(inputList); // 防御性复制 } } ``` ##### 9.4 throws 子句 `throws` 子句用于声明方法可能抛出的受检查异常。例如： ```java class ThrowsClauseExample { void readFile() throws java.io.IOException { java.io.FileReader reader = new java.io.FileReader("file.txt"); // 读取文件操作 reader.close(); } } ``` 调用该方法的代码需要处理或继续抛出这些异常。 #### 10. 局部变量 局部变量是在方法、构造器或代码块中声明的变量，其作用域仅限于声明它的块。例如： ```java class LocalVariableExample { void method() { int localVariable = 5; // 局部变量 // 只能在 method 方法中使用 localVariable } } ``` 局部变量必须在使用前进行初始化，否则会导致编译错误。 #### 11. “一次编写，随处编译” “一次编写，随处编译” 是 Java 的重要特性，目前主要体现在确定赋值和不可达语句方面。确定赋值是指在使用变量之前，变量必须被明确赋值。例如： ```java class DefiniteAssignmentExample { void method() { int a; // a = 5; // 如果不赋值，下面的使用会导致编译错误 // System.out.println(a); } } ``` 不可达语句是指在程序中永远不会执行的语句，编译器会给出警告。例如： ```java class UnreachableStatementExample { void method() { return; System.out.println("This statement is unreachable"); // 编译错误 } } ``` #### 12. 类型限定与编译时声明 类型限定和编译时声明是 Java 编程中的重要概念。类型限定用于指定变量或表达式的类型，编译时声明则是在编译阶段确定变量的类型。例如： ```java class QualifyingTypeExample { Object obj = "Hello"; String str = (String) obj; // 类型限定 } ``` 在这个例子中，`obj` 是 `Object` 类型，但通过类型转换将其限定为 `String` 类型。 #### 13. 五种通用形式 五种通用形式是指在字段访问和方法调用表达式中的常见形式，它们有助于编译器确定要查找的类或接口。以下是五种通用形式的简要介绍： 1. 简单字段或方法名的含义：直接使用字段或方法名进行访问。 2. 方法调用链：连续调用多个方法。 3. 目标引用的类型转换：对引用进行类型转换后调用方法。 4. 使用主表达式访问静态成员：通过对象引用或类名访问静态成员。 5. 方法签名：方法的签名包括方法名、参数列表和返回类型，用于唯一标识一个方法。 这些通用形式在 Java 编程中经常使用，理解它们对于编写正确的代码非常重要。 #### 14. 方法签名 方法签名是方法的重要属性，它由方法名、参数列表和返回类型组成。编译器通过方法签名来确定要调用的方法。例如： ```java class MethodSignatureExample { void method(int param) { // 方法实现 } void method(String param) { // 方法重载，根据参数类型区分 } } ``` 在方法重载时，方法签名的不同可以让编译器区分不同的方法。同时，方法签名还涉及到一些规则，如 `throws` 子句冲突和协变结果类型等。 综上所述，Java 编程中的字段、方法和构造器等知识涵盖了很多方面，理解这些知识对于编写高质量的 Java 代码至关重要。在实际编程中，需要根据具体的需求和场景，合理运用这些概念，避免常见的错误和问题，提高代码的性能和可维护性。