Java编程基础与声明详解

### Java编程基础与声明详解 #### 1. 编程练习分析 首先来看一段代码示例： ```java public static void main(String[] args) { Init initMe = new Init(); double price; if (true) price = 100.00; System.out.println("|" + initMe.title + "|" + initMe.published + "|" + Init.total + "|" + Init.maxPrice + "|" + price+ "|"); } ``` 然后有一道选择题，问这段代码的运行结果。选项如下： (a) 程序将无法编译。 (b) 程序将编译，并在运行时打印 |null|false|0|0.0|0.0|。 (c) 程序将编译，并在运行时打印 |null|true|0|0.0|100.0|。 (d) 程序将编译，并在运行时打印 | |false|0|0.0|0.0|。 (e) 程序将编译，并在运行时打印 |null|false|0|0.0|100.0|。 这里，由于`if`语句为`true`，`price`被赋值为`100.00`，而`initMe`对象的属性如果未初始化，会使用默认值，所以正确答案是(e)。 #### 2. 章节内容总结 本部分涵盖了以下重要信息： - 基本语言元素：标识符、关键字、字面量、空白和注释。 - 基本数据类型：整数、浮点和布尔类型。 - 十进制、八进制和十六进制系统中数字的表示方法。 - 变量的声明和初始化，包括引用变量。 - 实例变量和静态变量默认值的使用。 - 实例变量、静态变量和局部变量的生命周期。 #### 3. 编程练习纠错 下面是一段有错误的代码： ```java // Filename: Temperature.java PUBLIC CLASS temperature { PUBLIC void main(string args) { double fahrenheit = 62.5; */ Convert /* double celsius = f2c(fahrenheit); System.out.println(fahrenheit + 'F' + " = " + Celsius + 'C'); } double f2c(float fahr) { RETURN (fahr - 32) * 5 / 9; } } ``` 需要对其进行修改以使其能编译和运行。修改步骤如下： 1. 将`PUBLIC`改为`public`，`CLASS`改为`class`，`string`改为`String`，`RETURN`改为`return`，因为Java是区分大小写的，关键字必须小写。 2. 修正注释`*/ Convert /*`为`/* Convert */`。 3. 将`Celsius`改为`celsius`，变量名要一致。 修改后的代码如下： ```java // Filename: Temperature.java public class Temperature { public static void main(String[] args) { double fahrenheit = 62.5; /* Convert */ double celsius = f2c(fahrenheit); System.out.println(fahrenheit + "F = " + celsius + "C"); } static double f2c(double fahr) { return (fahr - 32) * 5 / 9; } } ``` #### 4. 声明相关的考试目标 - **目标1.3**：开发声明、初始化和使用静态、实例和局部变量的代码，包括基本类型、数组、枚举和对象，同时使用合法的标识符作为变量名。 - **目标1.4**：开发声明静态和非静态方法的代码，若合适，使用符合JavaBeans命名标准的方法名，同时开发声明和使用可变长度参数列表的代码。 - **目标1.5**：根据代码示例，判断一个方法是否正确覆盖或重载另一个方法，并确定该方法的合法返回值（包括协变返回）。 - **目标1.6**：根据一组类和超类，为一个或多个类开发构造函数。根据类声明，确定是否会创建默认构造函数，若创建，确定该构造函数的行为。根据嵌套或非嵌套类列表，编写实例化类的代码。 - **目标7.2**：根据类和命令行的示例，确定预期的运行时行为。 - **目标7.3**：确定当对象引用和基本值被传递到对参数执行赋值或其他修改操作的方法时的影响。 #### 5. 类声明 类声明引入了一种新的引用类型，其一般语法如下： ```plaintext <class modifiers> class <class name><formal type parameter list> <extends clause> <implements clause> // Class header { // Class body <field declarations> <method declarations> <nested class declarations> <nested interface declarations> <nested enum declarations> <constructor declarations> <initializer blocks> } ``` 类头中，类名前有`class`关键字，还可以指定以下信息： - 访问修饰符 - 其他类修饰符 - 形式类型参数列表（如果类是泛型的） - 它继承的任何类 - 它实现的任何接口 类体可以包含成员声明，包括： - 字段声明 - 方法声明 - 嵌套类、枚举和接口声明 成员可以分为静态成员和实例成员，此外，类体中还可以声明构造函数和静态、实例初始化块。成员声明、构造函数声明和初始化块可以按任意顺序出现在类体中。 为了理解类中可以合法声明的代码，需要区分静态上下文和非静态上下文。静态上下文由静态方法、静态字段初始化器和静态初始化块定义，非静态上下文由实例方法、构造函数、非静态字段初始化器和实例初始化块定义。静态代码只能引用其他静态成员。 #### 6. JavaBeans标准 JavaBeans标准允许在Java中对可重用软件组件进行建模，以便这些组件可以组装成复杂的应用程序。构建工具可以利用这些组件的规范来构建新的应用程序。 - **属性命名模式**： - 属性通常是私有的，名称以小写字母开头。 - 为了检索和更改属性值，JavaBean提供了getter和setter方法。 - 对于属性，setter方法以`set`前缀开头，后面跟着属性名，属性名的首字母大写。 - 对于属性，getter方法以`get`前缀开头，对于布尔属性，也可以以`is`开头。 以下是一个JavaBean的示例： ```java public class Light { // Properties: private int noOfWatts; // wattage private String location; // placement private boolean indicator; // on or off // Setters public void setNoOfWatts(int noOfWatts) { this.noOfWatts = noOfWatts; } public void setLocation(String location) { this.location = location; } public void setIndicator(boolean indicator) { this.indicator = indicator; } // Getters public int getNoOfWatts() { return noOfWatts; } public String getLocation() { return location; } public boolean isIndicator() { return indicator; } } ``` - **事件模型命名模式**： - 事件类名为`XEvent`，继承自`java.util.EventObject`类。 - 监听器接口名为`XListener`，继承自`java.util.EventListener`接口，指定了事件发生时要调用的方法。 - 事件源实现`addXListener()`和`removeXListener()`方法，用于添加或移除对`XEvent`感兴趣的监听器。 以下是相关代码示例： ```java public class XEvent extends java.util.EventObject { public XEvent(Object source) { super(source); } } public interface XListener extends java.util.EventListener { public void methodAInXListener(XEvent ev); } public class ListenerObject implements XListener { public void methodAInXListener(XEvent e) { /* ... */ } } public class SourceObject { public synchronized void addXListener(XListener listener) { /* ... */ } public synchronized void removeXListener(XListener listener) { /* ... */ } } ``` #### 7. 方法声明 方法声明的一般语法如下： ```plaintext <method modifiers> <formal type parameter list> <return type> <method name> (<formal parameter list>) <throws clause> // Method header { // Method body <local variable declarations> <nested local class declarations> <statements> } ``` 方法头除了方法名外，还可以指定以下信息： - 作用域或访问修饰符 - 其他方法修饰符 - 形式类型参数列表（如果是泛型方法） - 返回值类型，若方法不返回值则为`void` - 形式参数列表 - 方法抛出的检查异常 形式参数列表是逗号分隔的参数列表，每个参数是一个简单的变量声明，由类型和名称组成。方法签名仅由方法名和形式参数列表组成。 方法体是一个包含局部声明和语句的块。成员方法可以分为实例方法和静态方法。 #### 8. 语句分类 Java中的语句可以分为以下几类： - **声明语句**：显式初始化变量的变量声明。 - **控制流语句**：用于控制程序的执行流程。 - **表达式语句**：以分号结尾的表达式，表达式被求值以产生副作用，其值被丢弃。有效的表达式语句包括赋值、增量和减量运算符、方法调用和对象创建表达式。 一个单独的分号表示空语句，不执行任何操作。块`{}`是一个复合语句，可以用来组合零个或多个局部声明和语句，块可以嵌套。 #### 9. 实例方法和`this`引用 实例方法属于类的每个对象，只能在对象上调用。在实例方法的上下文中，类中定义的所有成员（静态和非静态）都是可访问的，因为所有实例方法都传递了一个对当前对象的隐式引用，即`this`关键字。 `this`引用可用于访问对象的成员，在局部变量隐藏了同名字段的情况下特别有用。例如： ```java public class Light { // Fields: int noOfWatts; // wattage boolean indicator; // on or off String location; // placement // Constructor public Light(int noOfWatts, boolean indicator, String site) { String location; this.noOfWatts = noOfWatts; // (1) Assignment to field. indicator = indicator; // (2) Assignment to parameter. location = site; // (3) Assignment to local variable. this.superfluous(); // (4) superfluous(); // equivalent to call at (4) } public void superfluous() { System.out.println(this); } // (5) public static void main(String[] args) { Light light = new Light(100, true, "loft"); System.out.println("No. of watts: " + light.noOfWatts); System.out.println("Indicator: " + light.indicator); System.out.println("Location: " + light.location); } } ``` 如果成员没有被局部声明隐藏，简单的成员名被视为`this.member`的简写。注意，`this`引用不能在静态上下文中使用。 #### 10. 方法重载 每个方法都有一个签名，由方法名和形式参数列表的类型和顺序组成。只要方法签名不同，多个方法实现可以有相同的名称，这称为方法重载。 例如，`java.lang.Math`类中的`min()`方法就是重载的： ```java public static double min(double a, double b) public static float min(float a, float b) public static int min(int a, int b) public static long min(long a, long b) ``` 以下是`methodA`方法的一组示例： ```java void methodA(int a, double b) { /* ... */ } // (1) int methodA(int a) { return a; } // (2) int methodA() { return 1; } // (3) long methodA(double a, int b) { return b; } // (4) long methodA(int x, double y) { return x; } // (5) Not OK. ``` 前四个`methodA`方法的声明是正确的重载，因为它们的参数列表不同，而(5)的签名与(1)相同，不是有效的重载。 同样，仅改变返回类型不足以重载方法，例如： ```java int halfIt(int a) { return a/2; } double halfIt(int a) { return a/2.0; } // Not OK. Same signature. ``` 综上所述，通过对这些Java编程基础和声明相关内容的学习，我们可以更好地理解Java语言的特性和使用方法，编写出更加规范和高效的代码。在实际编程中，要注意变量的声明和初始化、方法的声明和重载、类的设计以及语句的正确使用等方面，以避免出现编译错误和逻辑错误。同时，遵循JavaBeans标准可以提高代码的可重用性和可维护性。 ### Java编程基础与声明详解（续） #### 11. 方法重载规则总结 为了更清晰地理解方法重载，我们可以总结以下规则： |规则|说明|示例| | ---- | ---- | ---- | |参数列表不同|参数的数量、类型或顺序不同|`void methodA(int a, double b)` 和 `int methodA(int a)`| |仅返回类型不同不构成重载|仅改变返回类型，参数列表相同，会导致编译错误|`int halfIt(int a)` 和 `double halfIt(int a)`| 下面我们通过一个 mermaid 流程图来展示方法重载的判断流程： ```mermaid graph TD; A[开始] --> B{方法名是否相同}; B -- 是 --> C{参数列表是否不同}; C -- 是 --> D[方法重载有效]; C -- 否 --> E{仅返回类型不同?}; E -- 是 --> F[编译错误，非有效重载]; E -- 否 --> F; B -- 否 --> G[非重载方法]; ``` #### 12. 静态上下文与非静态上下文的区别 静态上下文和非静态上下文在 Java 编程中有着重要的区别，我们可以通过表格来对比： |上下文类型|定义|可访问成员|`this` 引用|示例场景| | ---- | ---- | ---- | ---- | ---- | |静态上下文|由静态方法、静态字段初始化器和静态初始化块定义|只能引用其他静态成员|不可用|静态方法中访问静态变量| |非静态上下文|由实例方法、构造函数、非静态字段初始化器和实例初始化块定义|可以访问静态和非静态成员|可用|实例方法中访问对象的属性| 以下是一个简单的代码示例，展示静态上下文和非静态上下文的区别： ```java public class ContextExample { static int staticVar = 10; int instanceVar = 20; static void staticMethod() { // 可以访问静态变量 System.out.println("Static variable: " + staticVar); // 以下代码会报错，因为静态方法不能访问实例变量 // System.out.println("Instance variable: " + instanceVar); } void instanceMethod() { // 可以访问静态变量 System.out.println("Static variable: " + staticVar); // 可以访问实例变量 System.out.println("Instance variable: " + instanceVar); // 可以使用 this 引用 System.out.println("This instance variable: " + this.instanceVar); } public static void main(String[] args) { staticMethod(); ContextExample obj = new ContextExample(); obj.instanceMethod(); } } ``` #### 13. JavaBeans 标准的优势和应用场景 JavaBeans 标准在 Java 开发中具有诸多优势，并且适用于多种应用场景： - **优势**： - **可重用性**：JavaBeans 组件可以在不同的应用程序中重复使用，提高了开发效率。 - **可维护性**：遵循统一的命名模式和规范，使得代码更易于理解和维护。 - **集成性**：便于与构建工具集成，方便开发人员快速搭建复杂的应用程序。 - **应用场景**： - **图形用户界面（GUI）开发**：许多 GUI 构建工具依赖于 JavaBeans 标准来创建和管理组件。 - **企业级应用开发**：在企业级应用中，JavaBeans 可以作为数据传输对象（DTO）和业务逻辑组件。 #### 14. 变量生命周期的理解 变量的生命周期在 Java 编程中是一个重要的概念，不同类型的变量有不同的生命周期： - **实例变量**：随着对象的创建而创建，随着对象的销毁而销毁。例如： ```java public class InstanceVariableExample { int instanceVar; // 实例变量 public InstanceVariableExample() { instanceVar = 10; } public static void main(String[] args) { InstanceVariableExample obj = new InstanceVariableExample(); // 对象存在时，实例变量可用 System.out.println(obj.instanceVar); obj = null; // 对象被销毁，实例变量不再可用 } } ``` - **静态变量**：在类加载时创建，在类卸载时销毁。例如： ```java public class StaticVariableExample { static int staticVar = 20; // 静态变量 public static void main(String[] args) { // 不创建对象，也可访问静态变量 System.out.println(StaticVariableExample.staticVar); } } ``` - **局部变量**：在方法或块中声明，在方法或块执行结束后销毁。例如： ```java public class LocalVariableExample { public static void main(String[] args) { { int localVar = 30; // 局部变量 System.out.println(localVar); } // 以下代码会报错，因为局部变量已超出作用域 // System.out.println(localVar); } } ``` #### 15. 类声明的实际应用 类声明在 Java 编程中无处不在，我们可以通过一个简单的例子来展示类声明的实际应用： ```java // 定义一个简单的学生类 public class Student { // 字段声明 private String name; private int age; // 构造函数声明 public Student(String name, int age) { this.name = name; this.age = age; } // 方法声明 public String getName() { return name; } public int getAge() { return age; } public static void main(String[] args) { // 实例化类 Student student = new Student("Alice", 20); System.out.println("Name: " + student.getName()); System.out.println("Age: " + student.getAge()); } } ``` #### 16. 总结与实践建议 通过对 Java 编程基础和声明相关内容的深入学习，我们了解了类声明、方法声明、语句分类、实例方法和 `this` 引用、方法重载等重要概念，以及 JavaBeans 标准的应用。在实际编程中，我们可以遵循以下实践建议： - **变量声明与初始化**：明确变量的类型和作用域，及时进行初始化，避免使用未初始化的变量。 - **方法设计**：合理设计方法的参数和返回值，遵循方法重载的规则，提高代码的可读性和可维护性。 - **类设计**：遵循类声明的规范，区分静态成员和实例成员，合理使用静态上下文和非静态上下文。 - **遵循标准**：在开发中遵循 JavaBeans 标准，提高组件的可重用性和集成性。 总之，掌握这些基础知识和规范，能够帮助我们编写出更加健壮、高效和易于维护的 Java 代码。在后续的学习和实践中，我们可以不断加深对这些概念的理解和应用，提升自己的编程能力。