加州理工-CS158-软件设计与开发笔记-全-

加州理工 CS158 软件设计与开发笔记(全)

001:数据模型 📊

在本节课中,我们将要学习数据模型的核心概念。数据模型是任何计算机应用的基础,它定义了应用如何处理信息。我们将探讨什么是数据模型、其不同类型,以及如何在计算机中实现它们。


上一节我们提到了计算机应用是数据模型和算法的结合。本节中,我们来看看什么是数据模型。

数据建模是一种科学方法,用于将给定的问题领域用量化值来表达。简单来说,它是一种用定义好的测量单位(数据模型)来描述现实世界问题的方式。

例如,在烹饪食谱中,我们用量杯测量食材,用温度计测量热量,用计时器测量时间。这些测量单位(如“杯”、“摄氏度”、“分钟”)就是我们的数据模型。在计算机科学中,我们使用数据类型来实现这些模型。


数据模型的类型

数据模型可以根据决策问题的性质和类型,大致分为两类。

以下是两种主要的数据模型类型:

  • 确定性模型:这类模型没有内在的随机性。每次执行,只要输入相同,结果就相同。烹饪食谱就是一个典型的确定性模型。
  • 概率性模型:这类模型具有内在的随机性或不确定性。掷骰子或洗牌就是概率性模型的例子。在计算机科学中,这通常被称为随机模型。

确定性模型假设所有相关的输入数据值都是已知且确定的。概率性模型则假设某些输入数据值具有不确定性,因此需要将这种不确定性纳入模型考量。


定量数据与定性数据

任何建模过程都始于数据。将原始数据处理成对用户有价值的信息,是数据建模的核心。

在处理问题时,开发者可能需要同时考虑定性和定量因素。

  • 定量数据:是以数字表示的值或计数的度量。例如,年龄、温度、时间、GPA。在烹饪中,量化食材、热量和时间都属于定量数据。
  • 定性数据:是对类型的度量,可以用名称、符号或数字代码表示。例如,姓名、专业、食材标签(如“水果”、“蔬菜”)。在烹饪中,将食物分类为“蛋白质”、“蔬菜”属于定性数据。

有时,定性和定量数据可以相互转换。例如,字母等级(A, B, C)是定性数据,但它可以映射到一个数值范围(如90-100分对应A),从而转化为定量数据。这种抽象使我们能够以更灵活的方式表示信息。


计算机与数据建模

到目前为止,我们所讨论的建模概念都可以用纸笔或头脑完成。然而,计算机的强大之处在于能够自动执行我们定义的数学模型和算法。

数据建模的步骤可能非常详细,但通常可以概括为三个主要阶段,无论模型的规模或复杂性如何。

以下是数据建模的三个核心步骤:

  1. 问题表述:将问题的各个方面转化为数学模型。这是最关键也最具挑战性的一步。
  2. 求解:开发并执行算法,处理输入数据以产生输出结果,并测试解决方案的正确性。
  3. 解释:将形式化的输出结果翻译回现实世界,验证其是否解决了最初的问题。


步骤一:问题表述

问题表述是数据建模过程中最重要的一步。错误的问题表述几乎必然导致错误的结果。这就像写小说前需要先构思情节大纲一样。

问题表述本身可以进一步细分为三个部分。

以下是问题表述的三个子步骤:

  • 定义问题:对问题做出清晰、简洁的陈述。这需要超越表面症状,识别出问题的根本原因。有时,解决一个问题可能依赖于先解决其他相关问题(例如,制作鸡尾酒前需要先制作糖浆)。
  • 开发模型:为已定义的问题开发数学模型。数学模型通常是一组数学关系(如方程和不等式)。模型包含变量(其值可能改变)、参数(从外部输入到模型中的给定值)和常量(在模型执行过程中保持不变的值)。
  • 获取输入数据:确定模型所需的初始数据或起始状态。


步骤二:求解

求解步骤是指执行从表述过程中得出的数学表达式,以找到解决方案。

求解步骤包含两个部分。

以下是求解步骤的两个组成部分:

  • 开发解决方案:设计算法,即一步步的指令,说明如何将初始状态(输入)转化为期望的最终状态(输出)。在烹饪中,这就是食谱中的操作步骤。
  • 测试解决方案:在过程中不断验证结果。就像在烹饪中,你可能会在进入下一步前尝一下面糊,或者在装盘前检查食材是否切好。


步骤三:解释

假设问题表述正确且解决方案成功实施,解释步骤关注用户如何理解和使用结果。这涉及到将形式化的输出“翻译”回它所要代表的现实世界概念。

此外,确保模型的可读性至关重要。在编写代码或构建模型时,应使用描述性的标题、标签和注释,以便于未来理解和维护。


实例:构建应用模型

计算机应用由两部分组成:模型系统(通常不止一个)和处理信息的算法。

例如,制作一个蛋糕需要定义三种模型:数量模型(测量食材)、温度模型(测量热量)和时间模型(测量时长),再加上制作步骤的算法。

同样,在开发视频游戏时:

  • 我们可以用定性模型(如名字列表)来定义角色的身份。
  • 用定量模型(如X、Y坐标网格)来定义角色的移动。
  • 用另一个定量模型(如生命值)来定义角色的生存状态。
  • 然后,我们设计算法来处理这些模型,例如当角色受到伤害时减少生命值,当角色移动时更新坐标。


本节课中我们一起学习了数据模型的基本概念。我们了解了数据模型是应用的基础,区分了确定性模型与概率性模型、定量数据与定性数据。我们还探讨了在计算机中进行数据建模的三个核心步骤:问题表述、求解和解释。最后,我们通过蛋糕制作和游戏开发的例子,看到了如何将现实世界的问题转化为由模型和算法组成的软件应用。理解这些概念是后续学习具体编程语言和算法设计的关键第一步。

002:输出与存储

在本节课中,我们将学习算法设计的基础构建模块,特别是输出操作和存储操作。我们将了解如何将数据从程序中发送到外部世界,以及如何在程序内部保存数据以供后续使用。


输出操作

上一节我们介绍了数据建模的概念,本节中我们来看看如何将程序内部的数据呈现给外部世界。输出操作负责将数据从程序中发送出去,例如显示在终端上。

在Java中,我们通过 System.out 对象来访问输出流,它提供了几种打印数据的方法。

以下是三种主要的打印方法:

  1. print:将数据打印到控制台,但不自动换行。

    System.out.print("Hello");
    System.out.print("World");
    // 输出:HelloWorld
    
  2. println:将数据打印到控制台,并自动在末尾添加换行符。

    System.out.println("Hello");
    System.out.println("World");
    // 输出:
    // Hello
    // World
    
  3. printf:格式化打印,允许我们在字符串中嵌入占位符,并用变量值替换它们。

    String name = "Alice";
    int age = 25;
    System.out.printf("Hello, %s. You are %d years old.%n", name, age);
    // 输出:Hello, Alice. You are %d years old.
    

在格式化字符串中,%s 表示字符串占位符,%d 表示整数占位符,%f 表示浮点数占位符。%n 是平台无关的换行符。


存储操作

仅仅输出数据还不够,我们通常需要在程序运行过程中保存和操作数据。存储操作就是用来在内存中保留数据,以便后续使用的。

在Java中,我们通过变量来实现存储操作。声明一个变量需要指定数据类型和变量名。

Java中的基本数据类型主要分为三类:

  1. 数值型:用于存储数字。

    • 整数:int (例如:int count = 10;)
    • 浮点数:double (例如:double price = 19.99;)
  2. 文本型:用于存储字符或文本。

    • 单个字符:char (例如:char grade = 'A';)
    • 字符串:String (例如:String name = "Bob";)
  3. 布尔型:用于存储真/假值。

    • boolean (例如:boolean isLoggedIn = true;)

声明和初始化变量有三种方式:

  • 声明:仅保留内存空间,不赋值。
    int number; // 声明一个整数变量
    
  • 赋值:给已声明的变量赋予一个值。
    number = 5; // 给变量赋值
    
  • 初始化:在声明变量的同时进行赋值。
    int number = 5; // 声明并初始化变量
    double score = 95.5;
    boolean flag = false;
    String message = "Hello, World!";
    

注意:int, double, boolean, char 是基本数据类型(关键字为小写)。String 是引用数据类型(首字母大写),因为它可以表示无限种可能的文本组合,而非预定义的几个值。


本节课中我们一起学习了算法设计的两个核心构建模块:输出操作和存储操作。我们学会了如何使用 print, println, printf 将数据输出到控制台,以及如何声明和初始化不同类型的变量来在程序中存储数据。理解这些基础概念是编写更复杂程序的第一步。

003:输入与数据类型 📚

在本节课中,我们将深入学习数据建模的基础知识,并探讨如何在Java程序中获取用户输入。我们将从理解编程中最基本的数据类型开始,然后学习如何使用Scanner类从外部(如键盘)读取数据。掌握这些概念是构建有效算法和应用程序的关键第一步。


数据建模:基础构建模块 🧱

上一节我们讨论了算法和食谱的类比。然而,在开始编写算法(食谱)之前,我们必须先理解如何量化我们的“食材”。这就是数据建模的作用。

所有数据模型,无论是在Java中还是在任何编程领域,最终都可以归结为三种基本类型的数据:

  1. 数值数据:可以量化为数字的信息。
  2. 文本数据:无法用数字精确表示,需要用文字描述的信息。
  3. 布尔数据:表示“是/否”或“真/假”状态的信息。

这些是我们构建所有复杂数据模型的基础“积木”。

数值数据:精确与近似

数值数据(定量数据)可以进一步分为两种形式:

  • 精确数值:在Java中称为整数。例如,数字1、2、3都是精确的。
    • 公式:整数 ∈ {..., -2, -1, 0, 1, 2, ...}
  • 近似数值:在Java中称为浮点数。例如,0.1、3.14159。由于计算机内存和数学表示的限制,浮点数通常是近似值。
    • 核心概念:对于浮点数,不能直接使用==判断完全相等,通常需要定义一个误差范围(delta)。

文本与布尔数据

  • 文本数据:在Java中称为字符串。它是一系列字符的序列。
  • 布尔数据:只有两个可能的值:true(真)或false(假)。

Java中的原始数据类型 🔢

在Java中,上述基础类型有更具体的实现,称为“原始数据类型”。原始类型意味着Java虚拟机(JVM)预先知道所有可能的值,因此访问速度非常快。它们的特点是其类型名总是小写。

以下是Java中主要的原始数据类型及其关键信息:

抽象概念 Java 类型 内存占用 说明与示例
精确整数 byte 1 字节 (8位) 非常小的整数范围:-128 到 127
short 2 字节 (16位) 较小整数范围:-32,768 到 32,767
int 4 字节 (32位) 最常用:约 -21亿 到 21亿
long 8 字节 (64位) 极大整数,字面量需加L,如 10000000000L
近似浮点数 float 4 字节 (32位) 单精度浮点,精度约6-7位小数,字面量需加f
double 8 字节 (64位) 推荐使用:双精度浮点,精度约15-16位小数
字符 char 2 字节 (16位) 单个字符,用单引号,如 'A'
布尔值 boolean 1 位 (理论上) 只有 true 或 false 两个值
文本(非原始) String 可变(引用类型) 字符串序列,用双引号,如 "Hello"

重要说明:

  • String是引用类型(类型名大写),不是原始类型,因为可能的字符串组合是无限的,无法预先存储在JVM中。
  • 计算机底层将所有数据(整数、浮点数、文本)都编码为二进制位(0和1)。数据类型的作用就是告诉计算机如何解读这些二进制序列。

存储操作:变量声明与赋值 💾

理解了数据类型后,我们来看看如何存储数据。算法处理的数据如果不保存,就会被丢弃。我们使用变量来存储数据以备后用。

以下是三种基本的存储操作:

  1. 声明:在内存中为特定类型的数据预留空间,并给它一个名字(标签)。
    int age; // 声明一个名为age的整数变量
    
  2. 赋值:将一个值存入已声明的变量。
    age = 25; // 将值25赋给变量age
    
  3. 初始化:声明变量的同时进行赋值。
    int height = 180; // 声明并初始化height变量
    String name = "Alice"; // 声明并初始化name字符串
    

为什么需要先声明? 因为Java需要知道为变量分配多少内存以及如何解释存储的数据。


输入操作:从外部获取数据 🎯

现在我们已经知道如何存储数据,接下来看看如何从程序外部(如用户输入)获取数据。输入操作比输出操作更具挑战性,因为程序无法预知会收到什么数据以及何时收到。

在Java中,我们使用 System.in 代表标准输入流(如键盘),但直接使用它很复杂。因此,我们借助 Scanner 类来解析输入流。

使用 Scanner 类

Scanner 类可以将输入流中的原始字节数据,解析成我们需要的整数、浮点数或字符串等。

以下是使用 Scanner 的基本步骤:

  1. 导入类库:在Java文件顶部导入Scanner。
    import java.util.Scanner; // 必须的导入语句
    
  2. 创建 Scanner 对象:将其连接到输入流(如System.in)。
    Scanner input = new Scanner(System.in); // 创建一个从键盘读取的扫描器
    
  3. 读取数据:使用Scanner对象的方法读取特定类型的数据。
    • nextInt(): 读取下一个整数(以空格/制表符/换行符为分隔)。
    • nextDouble(): 读取下一个双精度浮点数。
    • next(): 读取下一个单词(字符串,到分隔符为止)。
    • nextLine(): 读取下一行文本(到换行符为止)。

一个完整的输入输出示例

让我们看一个结合了输入、存储和输出操作的例子:

import java.util.Scanner; // 1. 导入Scanner

public class InputDemo {
    public static void main(String[] args) {
        // 2. 创建Scanner对象
        Scanner keyboard = new Scanner(System.in);

        // 输入和存储一个字符串(整行)
        System.out.print("请输入您的全名: ");
        String fullName = keyboard.nextLine(); // 读取整行

        // 输入和存储一个整数
        System.out.print("请输入您的年龄: ");
        int age = keyboard.nextInt(); // 读取整数

        // 输入和存储一个浮点数
        System.out.print("请输入您的账户余额: ");
        double balance = keyboard.nextDouble(); // 读取双精度数

        // 输出存储的数据
        System.out.printf("您好,%s!%n", fullName); // 使用 %s 格式化字符串
        System.out.printf("年龄:%d 岁%n", age);       // 使用 %d 格式化整数
        System.out.printf("余额:$%.2f%n", balance);  // 使用 %.2f 格式化浮点数(保留两位小数)
    }
}

代码解析:

  • 程序依次提示用户输入姓名、年龄和余额。
  • keyboard.nextLine()、keyboard.nextInt()、keyboard.nextDouble() 分别从输入流中读取相应类型的数据。
  • 读取的数据被存储在变量 (fullName, age, balance) 中。
  • 最后,使用 System.out.printf 和格式化符号 (%s, %d, %.2f) 将结果美观地输出。

注意事项:

  • 混合使用 nextLine() 和其他 next...() 方法时需小心。例如,nextInt() 只读取数字,不会读取其后的换行符,如果紧接着调用 nextLine(),可能会读到空行。一个常见的解决方法是:在读取数字后,额外调用一次 nextLine() 来“消耗”掉残留的换行符。

总结 📝

本节课我们一起学习了软件构建的核心基础:

  1. 数据建模:我们认识到所有数据都可归结为数值、文本和布尔值这三种基本类型。数值又分为精确的整数和近似的浮点数。
  2. Java原始类型:我们详细了解了Java中对应的原始数据类型(如int, double, boolean, char)及其特性,并理解了String作为引用类型的特殊性。
  3. 存储操作:我们学会了如何使用声明、赋值和初始化来创建和管理变量,以保存程序中的数据。
  4. 输入操作:我们掌握了如何使用 Scanner 类从标准输入(如键盘)可靠地读取不同类型的数据,这是实现程序与用户交互的关键。

现在,我们已经掌握了算法的五个基本构建模块中的三个:输出、存储和输入。下一节课,我们将深入探讨最核心的处理操作(如算术运算、逻辑比较),学习如何转换和计算数据,从而让我们编写的程序真正开始“思考”和解决问题。

004:处理运算符 🧮

在本节课中,我们将要学习算法的核心组成部分之一:处理运算符。这是软件实现其功能、将数据转化为信息的关键所在。我们将探讨算术、关系、相等、逻辑和连接等不同类型的运算符,理解它们如何作用于数据,以及如何将它们组合成复杂的表达式。


概述

上一讲我们讨论了输入、输出和存储操作。本节中,我们来看看处理操作。这是算法中实现“魔法”的部分,它允许我们将数据从一种形式转换为另一种形式。处理操作本质上是数学运算,但我们可以将其概念应用于各种现实世界的问题。

算术运算符

算术运算符是我们最熟悉的运算符,用于对数值数据进行基本数学运算。它们是二元运算符,意味着需要两个操作数。

以下是Java中的基本算术运算符:

  • 加法:+
  • 减法:-
  • 乘法:*
  • 除法:/
  • 取模:%

算术运算要求输入和输出都是数值类型。一个重要的区别在于整数除法。当两个整数相除时,结果会被截断小数部分,只保留整数商。

例如:

  • 1 / 2 的结果是 0,而不是 0.5。
  • 3 / 2 的结果是 1。

取模运算符 % 用于计算除法后的余数。它对于识别模式(如判断奇偶性)非常有用。

例如:

  • 1 % 2 结果是 1
  • 2 % 2 结果是 0
  • 3 % 2 结果是 1
  • 5 % 3 结果是 2

任何具有循环或重复模式的现象(如时钟)都可以用取模运算来建模。


关系运算符与相等运算符

关系运算符用于比较两个数值的大小关系。它们也是二元运算符,输入必须是数值数据,但输出是布尔值(true 或 false)。

以下是关系运算符:

  • 小于:<
  • 大于:>
  • 小于或等于:<=
  • 大于或等于:>=

关系运算符将定量数据(数字)转换为定性判断(真或假),这对于后续的控制流程决策至关重要。

接下来我们看看相等运算符。虽然常与关系运算符归为一类,但相等运算符有本质区别:它可以用于任何数据类型,而不仅仅是数值。

以下是相等运算符:

  • 等于:==
  • 不等于:!=

重要提示:= 是赋值运算符,用于将值存入变量。== 才是用于比较是否相等的运算符。混淆两者是新开发者常见的错误。

与关系运算符一样,相等运算的结果也是布尔值。


逻辑运算符

逻辑运算符用于组合或修改布尔值,从而构建更复杂的条件判断。它们主要也是二元运算符。

以下是逻辑运算符:

  • 逻辑与:&& (AND) - 仅当两个操作数都为 true 时,结果才为 true。
  • 逻辑或:|| (OR) - 只要至少一个操作数为 true,结果就为 true。

此外,还有一元逻辑运算符:

  • 逻辑非:! (NOT) - 用于取反单个布尔值。!true 是 false,!false 是 true。

类似的,数值数据也有一元运算符,即负号 -,用于改变数值的正负。


连接运算符

连接运算符 + 用于将数据(尤其是文本)拼接在一起。有趣的是,它使用的符号与加法运算符相同。

Java如何区分 + 是加法还是连接呢?规则如下:

  • 如果 + 两边的操作数都是数值,则执行加法运算,结果为数值。
  • 如果 + 两边的操作数至少有一个是字符串,则执行连接运算,结果为字符串。在此过程中,非字符串的操作数会被转换为字符串形式。

例如:

  • 1 + 2 结果是数值 3。
  • "1" + 2 结果是字符串 "12"。
  • 1 + 2 + "3" 的运算顺序是从左到右:1 + 2 得 3(数值),然后 3 + "3" 进行连接,得字符串 "33"。

表达式的计算遵循标准的数学运算顺序(先乘除,后加减),可以使用括号 () 来改变优先级。


关于引用数据类型的相等性比较

之前讨论的 == 和 != 是基本运算符,设计用于比较基本数据类型(如 int, double, boolean)的值。

然而,对于引用数据类型(如 String),== 比较的是两个引用是否指向内存中的同一个对象(即内存地址是否相同),而不是比较对象的内容是否相同。

例如,两个内容相同的 String 对象,如果存储在内存的不同位置,用 == 比较会返回 false。

要比较两个 String 对象的内容是否相等,必须使用 String 类提供的 .equals() 方法:

String str1 = "hello";
String str2 = "hello";
// 错误的方式,比较内存地址
boolean isSameObject = (str1 == str2); // 结果可能为 true 或 false,取决于JVM优化
// 正确的方式,比较内容
boolean isSameContent = str1.equals(str2); // 结果为 true

引用数据类型(如 Scanner, System.out)通常都内置了各种方法(通过 . 操作符调用),用于执行特定操作。


表达式

将运算符和数据组合在一起,就构成了表达式。表达式是算法中实现计算和逻辑的核心单元。

我们可以将编程语言中的表达式类比为自然语言中的句子:

  • 数据(名词):是表达式中的主体。
  • 运算符(动词):是对数据执行的动作。

通过将现实世界的问题映射为数学表达式,我们就能用软件来解决它们。


总结

本节课中我们一起学习了处理运算符,这是构建算法逻辑的“动词”。我们详细探讨了:

  1. 算术运算符(+, -, *, /, %)用于数值计算,特别注意了整数除法和取模运算。
  2. 关系运算符(<, >, <=, >=)用于数值比较,并产生布尔结果。
  3. 相等运算符(==, !=)可用于任何数据类型进行比较,同样产生布尔结果,并强调了与赋值运算符 = 的区别。
  4. 逻辑运算符(&&, ||, !)用于组合和修改布尔值,构建复杂条件。
  5. 连接运算符(+)用于拼接字符串,其行为取决于操作数的类型。
  6. 理解了对于引用数据类型(如 String),应使用 .equals() 方法而非 == 来比较内容。
  7. 最后,我们认识了表达式的概念,它是将数据与运算符结合以产生新值或新判断的基本单元。

掌握这些运算符是设计有效算法和功能软件的基础。下一讲,我们将进入最后一个基本构建块:控制操作,学习如何让程序做出决策和重复执行任务。

005:选择结构 🧭

在本节课中,我们将学习算法构建的第五个核心模块:控制操作。我们将重点探讨选择结构,它允许程序根据条件决定执行哪一部分代码。我们将学习三种选择结构:单选择、双选择和多选择,并理解如何利用布尔值来做出决策。


复合赋值操作

在深入探讨控制操作之前,我们先回顾并扩展一下处理操作。我们可以将处理操作(如算术运算)与赋值操作结合,形成复合赋值语句。

复合赋值语句允许我们在单行代码中,既读取一个变量的当前值,对其进行处理,又将新值写回同一个变量。这是一种强大的能力,因为它允许我们基于变量的当前状态来更新它。

以下是复合赋值的一个基本示例:

int x = 2;
x = x * 10; // 读取x的值(2),乘以10,然后将结果(20)存回x
System.out.println(x); // 输出 20

我们可以使用更简洁的复合赋值运算符来达到相同效果:

int x = 2;
x *= 10; // 等同于 x = x * 10;
System.out.println(x); // 输出 20

对于字符串连接,同样适用:

String text = "Hello";
text += " World"; // 等同于 text = text + " World";
System.out.println(text); // 输出 Hello World

自增与自减操作

对于最常见的“加1”或“减1”操作,Java提供了更简短的自增(++)和自减(--)运算符。

这里有一个关键区别:前自增/自减与后自增/自减。

  • 前自增 (++x):先对变量进行加1操作,然后使用新值。
  • 后自增 (x++):先使用变量的当前值,然后再对其进行加1操作。

当在同一语句中涉及其他操作时,这个顺序差异就很重要了。

int x = 0;
// 前自增示例
System.out.println("前自增前: " + x); // 输出 0
System.out.println("执行 ++x: " + (++x)); // 输出 1 (先加1,后打印)
System.out.println("前自增后: " + x); // 输出 1

x = 0; // 重置x
// 后自增示例
System.out.println("后自增前: " + x); // 输出 0
System.out.println("执行 x++: " + (x++)); // 输出 0 (先打印,后加1)
System.out.println("后自增后: " + x); // 输出 1


控制操作:选择结构

现在,让我们进入本节课的核心——控制操作。选择结构是控制操作的第一种类型,它允许程序根据条件(布尔表达式)的真假,来决定执行哪一段代码块。

所有选择结构的决策都基于布尔值。这就是为什么在处理操作中,我们能够将各种数据类型转换为布尔格式如此重要。


单选择结构 (if)

单选择结构允许我们决定是执行一个代码块,还是完全跳过它。这就像在食谱中,如果选择做素食,就跳过加入肉类的步骤。

结构:

if (条件) {
    // 如果条件为 true,则执行这里的代码
    // 可以包含多条语句
}
// 如果条件为 false,则跳过整个代码块,继续执行后面的语句

示例:判断成绩是否及格
我们创建一个程序,提示用户输入成绩。如果成绩大于等于70分,则输出“你通过了”。

import java.util.Scanner; // 导入Scanner类用于获取输入

public class SingleSelection {
    public static void main(String[] args) {
        // 1. 提示用户输入
        System.out.print("请输入一个数字成绩: ");

        // 2. 获取用户输入并存储
        Scanner keyboard = new Scanner(System.in);
        double grade = keyboard.nextDouble();

        // 3. 单选择:判断是否及格
        if (grade >= 70) {
            // 只有条件为真时,才会执行这个代码块
            System.out.println("你通过了!");
            System.out.println("做得好!");
        }
        // 如果 grade < 70,则什么也不做,程序结束
    }
}

重要提示: 即使if后面只跟一条语句,也强烈建议始终使用花括号 {} 来定义代码块。这能避免未来添加语句时出现错误,并使代码结构更清晰。


双选择结构 (if-else)

双选择结构提供了两个互斥的代码块。程序会根据条件的真假,必定执行其中一个块。这就像在制作浓汤时,你必须在“鸡肉香肠浓汤”和“海鲜浓汤”两种食谱中选择一个。

结构:

if (条件) {
    // 条件为 true 时执行
} else {
    // 条件为 false 时执行
}
// 执行完其中一个块后,继续执行后面的语句

示例:判断通过或失败
我们改进之前的程序,使其不仅能告知通过,还能在不及格时输出“你失败了”。

import java.util.Scanner;

public class DoubleSelection {
    public static void main(String[] args) {
        System.out.print("请输入一个数字成绩: ");

        Scanner keyboard = new Scanner(System.in);
        double grade = keyboard.nextDouble();

        // 双选择:根据成绩输出不同结果
        if (grade >= 70) {
            System.out.println("你通过了!");
        } else {
            // 当 grade < 70 时执行
            System.out.println("你失败了。");
        }
    }
}

多选择结构 (if-else if-else)

多选择结构允许我们在多个(两个以上)代码块中选择一个执行。它通过将else和新的if语句嵌套在一起来实现。

结构:

if (条件1) {
    // 条件1为 true 时执行
} else if (条件2) {
    // 条件1为 false 且 条件2为 true 时执行
} else if (条件3) {
    // 条件1、2为 false 且 条件3为 true 时执行
} else {
    // 所有上述条件都为 false 时执行
}
// 注意:整个结构最终只会执行其中一个代码块

示例:根据成绩输出等级
我们创建一个程序,根据输入的成绩输出对应的字母等级(A, B, C, D, F)。

import java.util.Scanner;

public class MultiSelection {
    public static void main(String[] args) {
        System.out.print("请输入一个数字成绩: ");

        Scanner keyboard = new Scanner(System.in);
        double grade = keyboard.nextDouble();

        // 多选择:根据成绩范围输出等级
        if (grade >= 90) {
            System.out.println("你得到了 A");
        } else if (grade >= 80) { // 隐含了 grade < 90
            System.out.println("你得到了 B");
        } else if (grade >= 70) { // 隐含了 grade < 80
            System.out.println("你得到了 C");
        } else if (grade >= 50) { // 隐含了 grade < 70
            System.out.println("你得到了 D");
        } else { // grade < 50
            System.out.println("你得到了 F");
        }
    }
}

关键区别:独立 if 语句 vs. 多选择 if-else if 链

  • 多选择链 (if-else if):是一个整体决策结构。一旦某个条件为真,执行对应的块后就会跳过后面所有的else if和else块。它保证只执行一个分支。
  • 多个独立的 if 语句:每个if都是独立的单选择,会依次进行判断。多个条件可能同时为真,从而导致多个代码块都被执行。这适用于需要同时检查多个独立条件的情况(例如,在游戏中同时检测是否按下了“上”键和“左”键)。

错误示例(多个独立if):

if (grade >= 90) {
    System.out.println("A");
}
if (grade >= 80) { // 注意这里没有 else
    System.out.println("B");
}
if (grade >= 70) { // 注意这里没有 else
    System.out.println("C");
}
// 输入95会输出: A, B, C

总结

在本节课中,我们一起学习了算法构建的第五块基石:控制操作中的选择结构。

我们首先回顾了复合赋值操作,它让我们能高效地更新变量状态。接着,我们深入探讨了三种选择结构:

  1. 单选择 (if):根据条件决定是否执行一个代码块。
  2. 双选择 (if-else):根据条件在两个互斥的代码块中选择一个执行。
  3. 多选择 (if-else if-else):在多个互斥的代码块中选择一个执行。

我们理解了所有决策都基于布尔表达式,并学会了如何利用关系运算符(如 >=, <)来构建这些表达式。同时,我们强调了使用花括号定义代码块的良好习惯,以及区分多选择链与多个独立if语句的重要性。

选择结构为我们的程序引入了“决策”能力,使其能够根据不同情况做出反应。在下一节课中,我们将学习控制操作的另一个关键部分:重复结构(循环),它能让程序重复执行某些操作。

006:重复与循环 🔄

在本节课中,我们将学习算法设计中的第五个基本构建块:控制操作中的重复语句。我们将探讨如何使用循环结构来重复执行一段代码,直到满足特定条件为止。课程将涵盖两种主要的循环类型:计数器控制循环和哨兵控制循环,并详细介绍 while、for 和 do-while 循环的语法与用法。


循环基础:为何需要重复? 🔁

上一节我们介绍了选择语句,它允许程序根据条件决定执行哪部分代码。本节中,我们来看看如何让程序重复执行某段代码。

重复语句负责在程序中重复执行一组指令。一个生活中的例子是食谱中的“搅拌面糊直至没有结块”。这个指令意味着重复“搅拌”这个动作,直到终止条件(面糊没有结块)满足为止。

用伪代码表示如下:

while (面糊有结块) {
    搅拌面糊
}

所有控制操作(包括循环)都基于布尔值进行判断。只有当循环控制变量的条件为真时,才会执行循环体内的代码。


循环的两种主要类型 📊

循环通常分为两种主要类型,区别在于我们是否提前知道循环需要执行的次数。

  • 计数器控制循环:当我们提前知道需要循环的确切次数时使用。通常使用 for 循环结构。
  • 哨兵控制循环:当我们不知道需要循环多少次,循环依赖于运行时某个条件的变化时使用。通常使用 while 循环结构。

无论哪种循环,都必须包含三个基本要素:

  1. 初始化循环控制变量。
  2. 评估循环控制变量的条件(布尔表达式)。
  3. 更新循环控制变量,使其最终能使条件变为假,从而结束循环。

如果忘记更新循环控制变量,可能会导致无限循环。


计数器控制循环与 while 🧮

让我们通过一个计数器控制循环的例子,来看看 while 循环是如何工作的。

public class CounterLoop {
    public static void main(String[] args) {
        // 1. 初始化循环控制变量
        int counter = 0;

        // 2. 评估循环控制变量条件
        while (counter < 10) {
            // 循环体:要重复执行的代码
            System.out.println("Counter is: " + counter);
            // 3. 更新循环控制变量
            counter++; // 等同于 counter = counter + 1;
        }

        // 循环结束后执行
        System.out.println("Final counter value: " + counter);
    }
}

运行上述代码,输出将从 0 打印到 9,最后打印出 10。

关键点:

  • 如果初始条件为假(例如 counter 初始值为 10),则循环体可能一次也不执行。
  • 如果忘记更新变量(如注释掉 counter++),条件将永远为真,导致无限循环。

哨兵控制循环 🚨

与计数器循环不同,哨兵控制循环的次数取决于运行时的用户输入或其他动态条件。

以下是一个使用 while 循环的哨兵控制示例,它持续询问用户输入,直到输入 Q 为止:

import java.util.Scanner;

public class SentinelLoop {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        // 1. 初始化循环控制变量(布尔值)
        boolean repeat = true;

        // 2. 评估循环控制变量条件
        while (repeat == true) {
            System.out.print("Enter a letter (Q to quit): ");
            // 获取用户输入
            String response = input.next();

            // 3. 根据输入更新循环控制变量
            if (response.equals("Q")) {
                repeat = false; // 满足条件,改变状态以退出循环
            }
            // 如果不是 Q,则 repeat 仍为 true,循环继续
        }

        System.out.println("Loop ended.");
        input.close();
    }
}

在这个例子中,我们无法在运行程序前预知循环会执行多少次,它完全取决于用户何时输入 Q。


for 循环:更简洁的计数器循环 ✨

对于计数器控制循环,for 循环提供了更紧凑、更易读的语法。它将循环的三个要素(初始化、条件、更新)集中在一行。

让我们将之前的 while 计数器循环改写为 for 循环:

public class WhileFor {
    public static void main(String[] args) {
        // for 循环将三个要素集中在一行
        for (int count = 0; count < 10; count++) {
            System.out.println("Count is: " + count);
        }
        // 循环结束后,count 变量在此作用域不可见
    }
}

for 循环语法解析:

  • int count = 0;:初始化语句,在循环开始时执行一次。
  • count < 10;:循环条件,每次迭代前检查,为真则执行循环体。
  • count++:更新语句,每次循环体执行后执行。

for 与 while 的对比:

  • 行为完全相同:在性能上没有区别。
  • 可读性:对于计数器循环,for 循环更清晰,因为它把循环控制逻辑封装在一行,而不“污染”循环体周围的代码。
  • 原则:已知循环次数时,优先使用 for 循环;未知时,使用 while 循环。

do-while 循环:至少执行一次 🔄➡️

while 和 for 循环可能一次都不执行(如果初始条件为假)。但有时我们需要至少执行一次循环体,然后再判断条件。这时就需要 do-while 循环。

public class DoWhile {
    public static void main(String[] args) {
        int j = 11;

        System.out.println("Before do-while loop");
        do {
            // 循环体至少会执行一次
            System.out.println("j is: " + j);
            j++;
        } while (j < 10); // 注意结尾的分号
        System.out.println("After do-while loop, j is: " + j);
    }
}

运行结果会打印出 j is: 11,尽管 j 的初始值就不满足 j < 10 的条件。这是因为 do-while 先执行循环体,再检查条件。

重要语法提示:do-while 循环的 while 语句后面必须有一个分号。这是它与普通 while 循环的一个易错区别。


循环控制:break 与 continue ⏸️▶️

在循环内部,我们可以使用 break 和 continue 语句来更精细地控制流程。

break 语句

break 语句用于立即终止整个循环,并跳出到循环后面的语句。

public class BreakDemo {
    public static void main(String[] args) {
        for (int count = 0; count <= 10; count++) {
            if (count == 5) {
                break; // 当 count 等于 5 时,立即跳出循环
            }
            System.out.println("Count is: " + count);
        }
        System.out.println("Loop broke at count == 5");
    }
}

输出将只打印 0 到 4,当 count 为 5 时,break 使循环提前结束。

continue 语句

continue 语句用于跳过当前迭代中剩余的代码,直接进入循环的下一次迭代。

public class ContinueDemo {
    public static void main(String[] args) {
        for (int count = 0; count < 10; count++) {
            if (count == 5) {
                continue; // 跳过本次循环中后面的代码,直接开始下一次迭代
            }
            System.out.println("Count is: " + count);
        }
    }
}

输出将打印 0, 1, 2, 3, 4, 6, 7, 8, 9。注意,数字 5 被跳过了,因为当 count 为 5 时,continue 语句使得 System.out.println 没有被执行,程序直接开始了 count=6 的迭代。


补充:switch 选择语句 🔀

在结束所有控制结构之前,我们简要介绍另一种多路选择语句:switch。它类似于 if-else if-else 链,但基于单个表达式的精确匹配。

传统 switch 语法(易出错,不推荐):

switch (response) {
    case "A":
        selection = "Option A";
        break; // 必须使用 break 防止“贯穿”
    case "B":
        selection = "Option B";
        break;
    default: // 类似于 else
        selection = "None";
}

如果忘记写 break,程序会执行完匹配的 case 后,继续执行后面所有 case 的代码,直到遇到 break 或结束,这被称为“贯穿”,通常是错误来源。

Java 14+ 改进的 switch 表达式(推荐):

switch (response) {
    case "A" -> selection = "Option A"; // 使用箭头,无需 break
    case "B" -> selection = "Option B";
    default  -> selection = "None";
}

新语法使用 -> 箭头,更加简洁,并且不会发生贯穿,避免了因忘记 break 而导致的错误。


总结 📝

本节课中我们一起学习了算法设计的核心——重复语句(循环)。

我们掌握了以下内容:

  1. 循环的基本要素:初始化、条件判断、变量更新。
  2. 两种循环类型:计数器控制循环(使用 for)和哨兵控制循环(使用 while)。
  3. 三种循环结构:
    • while 循环:先判断,后执行,可能执行零次。
    • for 循环:专为计数器循环设计,语法紧凑。
    • do-while 循环:先执行,后判断,至少执行一次。
  4. 循环控制语句:break(终止循环)和 continue(跳过本次迭代)。
  5. switch 语句:一种基于精确匹配的多路选择结构,了解了其传统语法和更安全、更简洁的 Java 14+ 新语法。

至此,我们已经涵盖了构成算法的五个基本构建块:输入、输出、存储、处理和控制(选择与重复)。接下来,我们将开始运用这些基础来设计和构建更复杂的算法。

007:自顶向下逐步求精(第一部分)

在本节课中,我们将学习一种重要的算法设计策略——自顶向下逐步求精过程。我们将通过构建三个具体的应用程序来实践这一方法,从简单的概念开始,逐步细化,直到形成可以直接转换为Java代码的伪代码。

概述

到目前为止,我们已经学习了数据建模、算法的概念以及构建算法的五个基本构建块:输出操作、存储操作、输入操作、处理操作和控制操作。特别是控制操作,我们学习了选择语句和重复语句。本节课,我们将把这些知识整合起来,学习如何通过自顶向下逐步求精的过程,将一个抽象的想法发展成一个完整的、可实现的算法。

自顶向下逐步求精过程

自顶向下是一种设计方法,我们从非常抽象的概念开始,逐步增加细节,直到算法变得足够复杂和具体。这是一种让我们能够以非常直接的方式设计复杂算法的策略。

想象一下,在最高层,你只有一个关于应用程序的简单想法。这个过程就是教你如何迭代地完善这个想法,直到它足够完整,可以开始用Java实现。一个重要的启示是:在触碰键盘、在代码编辑器中输入任何内容之前,你应该始终预先规划好要编写的代码。你不应该在没有考虑算法如何操作、数据模型是什么以及如何遵循逐步指令的情况下就开始开发。

过程详解

我们通常将自顶向下逐步求精过程分解如下:从顶层语句开始,然后通过每次细化向下遍历。

  • 顶层语句:我们首先定义一个语句,作为应用程序的一行摘要。它定义了软件的规格,并明确了我们的目标。这本质上是软件的“电梯演讲”。
  • 第一次细化:这是一个迭代方法。我们查看之前创建的顶层语句,找出哪些部分是抽象的、定义不够清晰以至于无法直接翻译成Java语句。然后,我们添加更多细节来更好地定义如何完成这些任务。每次细化都定义了整个应用程序,但你在每次细化中所做的是逐步解释如何实现它。这就像一种“分而治之”的策略。
  • 后续细化:我们不断向细化后的语句集中添加更多细节,直到这组语句足够明确,可以作为我们的伪代码。伪代码类似于Java或Python代码,但它不编译,是人类可读、可解释的一组语句,用于定义你的“食谱”。
  • 最终细化:在最终细化阶段,即无法再添加更多细节的最后一步,我们伪代码算法的每一行现在都应该能映射到一个Java语句。一旦达到这个水平,你就可以将细化内容粘贴到源代码文档中,并以此为指导来实现你的应用程序。

从图形上看,这个过程就像一个金字塔。我们从顶部开始,信息很少,非常抽象。经过第一次细化,我们将其扩展了一些;经过第二次细化,扩展得更多;经过第三次细化,扩展得更多。最终,在过程的底部,我们拥有最扩展、最详细、最精细的算法,这将帮助我们直接将伪代码实现为Java。

应用实践:构建三个应用程序

现在,我们将使用自顶向下逐步求精方法来设计三个应用程序。

应用程序一:计数器控制循环的平均成绩计算器

这个应用程序将使用计数器控制循环来计算10个成绩的平均值。

步骤1:定义顶层语句

首先,我们定义顶层语句:确定学生10次测验的平均成绩。这个语句简洁明了,传达了应用程序的功能。它指定了具体的测验数量(10次),这让我们知道这是一个适合使用计数器控制循环的目标。

步骤2:第一次细化

接下来,我们进行第一次细化。我们需要思考完成“确定学生10次测验的平均成绩”这个目标至少需要哪些抽象步骤。

  1. 初始化所需的数据。
  2. 从用户那里获取成绩并求和。
  3. 计算平均值并打印。

步骤3:第二次细化

第一次细化后的语句仍然抽象,我们需要进一步细化。

  • 细化“初始化数据”:

    1. 将 sum 初始化为 0。
    2. 将 count 初始化为 0。
    3. 声明一个 average 变量以备后用。
    4. 初始化一个 Scanner 对象用于输入。
  • 细化“获取成绩并求和”:

    1. 当 count 小于 10 时重复执行。
      1. 提示用户输入一个成绩。
      2. 从用户那里获取并存储成绩。
      3. 将该成绩加到 sum 中。
      4. 将 count 加 1。
  • 细化“计算平均值并打印”:

    1. 将 average 设置为 sum 除以 count。
    2. 打印 average 的值。

现在,我们有了完整的伪代码,每一行都可以直接映射到Java语句。

步骤4:实现与测试

根据伪代码,我们可以在Java中实现这个算法。我们将顶层语句作为多行注释放在文件顶部,并将细化后的伪代码作为行内注释来指导实现。实现后,我们进行测试以确保其按预期工作。

核心代码结构示例:

// 初始化数据
double sum = 0;
int count = 0;
Scanner keyboard = new Scanner(System.in);
double average;

// 获取10个成绩并求和
while (count < 10) {
    System.out.printf("Enter grade %d: ", count + 1);
    double grade = keyboard.nextDouble();
    sum = sum + grade;
    count = count + 1;
}

// 计算并打印平均值
average = sum / count;
System.out.printf("Average is: %.2f%n", average);

应用程序二:哨兵控制循环的平均成绩计算器

这个应用程序将使用哨兵控制循环来计算任意数量成绩的平均值。顶层语句变为:确定学生任意次数测验的平均成绩。

关键区别与细化

主要区别在于第二次细化中的循环控制部分。

  • 选择哨兵值:我们选择 -1 作为哨兵值,因为成绩不应该为负数(最低为0)。
  • 调整循环逻辑:
    1. 提示用户输入一个成绩(或输入-1退出)。
    2. 从用户那里获取并存储成绩。
    3. 当成绩 >= 0 时重复执行:
      1. 将该成绩加到 sum 中。
      2. 将 count 加 1。
      3. 提示用户输入下一个成绩(或输入-1退出)。
      4. 从用户那里获取并存储成绩(更新循环控制变量)。

核心代码结构调整示例:

// ... 数据初始化与之前相同 ...

// 获取第一个成绩
System.out.print("Enter a grade (or -1 to quit): ");
double grade = keyboard.nextDouble();

// 当成绩非负时,持续获取并处理
while (grade >= 0) {
    sum = sum + grade;
    count = count + 1;
    System.out.print("Enter a grade (or -1 to quit): ");
    grade = keyboard.nextDouble(); // 更新循环控制变量
}

// ... 计算并打印平均值 ...

这个版本更加灵活,可以处理任意数量的成绩输入。

应用程序三:文本表达式计算器(课后练习)

我们将构建一个计算器,用于解析和计算文本格式的算术表达式(例如 "2 + 2", "5 * 3")。顶层语句是:求解来自文本的算术表达式。

任务说明

表达式格式为:一个数值(左操作数),一个空格,一个运算符符号,一个空格,另一个数值(右操作数)。运算符可能包括 +, -, *, /, %,并且可能考虑使用不同符号表示同一操作(例如 "add" 表示加法)。

挑战

请尝试运用自顶向下逐步求精方法,为这个计算器应用程序设计你自己的伪代码。思考如何从文本中解析出操作数和运算符,如何根据运算符执行正确的计算,以及如何处理可能的错误输入。

总结

本节课我们一起学习了自顶向下逐步求精这一强大的算法设计策略。我们了解到,软件开发不应从盲目编码开始,而应从清晰的规划入手。通过从抽象的顶层语句出发,经过多次细化迭代,逐步增加细节,我们最终能得到一份清晰的伪代码,从而轻松地将其转化为可工作的Java程序。

我们通过构建计数器控制循环和哨兵控制循环的两个平均成绩计算器,实践了这一过程。最后,我们留下了文本表达式计算器作为练习,鼓励大家亲自尝试应用这个方法。记住,这个过程是可扩展的,能够帮助你设计出成千上万行代码的复杂软件。在开始编码之前进行规划,是成为一名优秀开发者的关键习惯。

008:自顶向下逐步求精(第二部分)

在本节课中,我们将继续学习自顶向下逐步求精的设计方法,并将其应用于一个计算器程序的设计中。我们将从抽象的目标开始,通过多次细化,最终得到可以直接映射为Java代码的伪代码。


上一节我们介绍了自顶向下逐步求精作为一种设计策略。它允许我们从抽象的目标出发,逐步细化,最终形成可执行的伪代码。这对于初学者尤其重要,因为它提供了一种将想法转化为具体实现步骤的系统方法。

我们的起点是一个顶层的目标陈述,它非常抽象,不包含任何具体细节。这个陈述最终会成为我们Java类的头部注释。因此,从现在开始,提交作业时,请确保每个类文件都有一个多行注释,说明该类的职责和作者。

设计过程回顾

我们的顶层目标是:从文本中解析并计算数学表达式。

在开始细化之前,我们先定义一些具体的输入输出示例,这有助于明确程序的预期行为:

  • 输入:2 + 3 -> 输出:5
  • 输入:2 - 3 -> 输出:-1
  • 输入:2 * 3 -> 输出:6
  • 输入:2 x 3 -> 输出:6
  • 输入:2 X 3 -> 输出:6
  • 输入:2 \ 3 -> 输出:0
  • 输入:2 / 3 -> 输出:0

第一次细化

在第一次细化中,我们将顶层目标分解为几个主要的、但仍较抽象的步骤。

以下是第一次细化的步骤:

  1. 设置数据模型。
  2. 从用户处获取表达式。
  3. 解析表达式并打印结果。

第二次细化

现在,我们对第一次细化中的每个步骤进行进一步分解,使其更具体。

对于“设置数据模型”这一步,我们需要定义程序初始状态所需的变量。

以下是“设置数据模型”的细化内容:

  • 声明左操作数变量。
  • 声明右操作数变量。
  • 声明操作符变量。
  • 初始化Scanner对象以获取输入。
  • 声明结果变量。

对于“从用户处获取表达式”这一步,我们需要与用户交互以获取输入数据。

以下是“从用户处获取表达式”的细化内容:

  • 提示用户输入。
  • 获取左操作数。
  • 获取操作符。
  • 获取右操作数。

对于“解析表达式并打印结果”这一步,我们将其分解为两个子任务。

以下是“解析表达式并打印结果”的细化内容:

  • 计算结果。
  • 打印结果。

审视第二次细化,我们发现“计算结果”这一步仍然过于抽象,无法直接映射为代码,因此需要进一步细化。

第三次细化

本节中,我们将重点细化“计算结果”这一步骤。其核心是根据不同的操作符执行相应的算术运算。

以下是“计算结果”的细化内容(使用多分支选择逻辑):

  • 如果操作符是 +,则执行加法。
  • 如果操作符是 -,则执行减法。
  • 如果操作符是 *、x 或 X,则执行乘法。
  • 如果操作符是 / 或 \,则执行除法。
  • 否则,报告操作符无效。

至此,第三次细化已经达到了伪代码的级别,我们可以将其逐行转换为Java代码。

将伪代码转换为Java代码

现在,我们将最终的伪代码实现为Java程序。我们将使用伪代码作为行内注释,清晰地表明每行代码的意图。

首先,根据“设置数据模型”的伪代码,我们声明所有必要的变量。

// 设置数据模型
int leftOperand;        // 左操作数
int rightOperand;       // 右操作数
String operator;        // 操作符
Scanner input = new Scanner(System.in); // 输入扫描器
int result;             // 计算结果

接着,实现“从用户处获取表达式”的步骤。

// 从用户处获取表达式
String prompt = “请输入数学表达式(格式:左操作数 操作符 右操作数,用空格分隔):”;
System.out.print(prompt);
leftOperand = input.nextInt();   // 获取左操作数
operator = input.next();         // 获取操作符
rightOperand = input.nextInt();  // 获取右操作数

最后,实现最核心的“解析表达式并打印结果”逻辑。这里我们使用 switch 语句来实现多分支选择。

// 解析表达式并打印结果
// 根据操作符计算结果
switch (operator) {
    case “+” -> {
        result = leftOperand + rightOperand;
        System.out.printf(“%d %s %d = %d%n”, leftOperand, operator, rightOperand, result);
    }
    case “-” -> {
        result = leftOperand - rightOperand;
        System.out.printf(“%d %s %d = %d%n”, leftOperand, operator, rightOperand, result);
    }
    case “*”, “x”, “X” -> {
        result = leftOperand * rightOperand;
        System.out.printf(“%d %s %d = %d%n”, leftOperand, operator, rightOperand, result);
    }
    case “/”, “\\” -> {
        result = leftOperand / rightOperand; // 整数除法
        System.out.printf(“%d %s %d = %d%n”, leftOperand, operator, rightOperand, result);
    }
    default -> System.out.println(“错误:’” + operator + “’ 不是有效的操作符。”);
}

注意:在Java字符串中,反斜杠 \ 是转义字符。要表示一个真正的反斜杠,需要写成 \\。

选择结构:switch 与 if-else 的对比

switch 语句并非实现多分支选择的唯一方式。我们也可以用 if-else if 链达到同样的效果。两种结构各有优劣。

if-else if 链的优势在于其灵活性,它可以处理任何结果为布尔值的表达式(例如关系比较)。而 switch 语句传统上只能进行等值比较。

然而,现代Java中的 switch 表达式引入了一个强大功能:yield 关键字。它允许我们从 switch 的一个分支中返回一个值给外层的代码块,这是 if-else 结构难以简洁实现的。

下面的示例展示了如何使用 switch 表达式和 yield 来改进代码结构,将计算和输出分离。

// 使用switch表达式计算并生成结果字符串
String output = switch (operator) {
    case “+” -> {
        int r = leftOperand + rightOperand;
        yield String.format(“%d %s %d = %d%n”, leftOperand, operator, rightOperand, r);
    }
    case “-” -> {
        int r = leftOperand - rightOperand;
        yield String.format(“%d %s %d = %d%n”, leftOperand, operator, rightOperand, r);
    }
    case “*”, “x”, “X” -> {
        int r = leftOperand * rightOperand;
        yield String.format(“%d %s %d = %d%n”, leftOperand, operator, rightOperand, r);
    }
    case “/”, “\\” -> {
        int r = leftOperand / rightOperand;
        yield String.format(“%d %s %d = %d%n”, leftOperand, operator, rightOperand, r);
    }
    default -> “错误:’” + operator + “’ 不是有效的操作符。%n”;
};
// 统一打印结果
System.out.print(output);

单元总结

本节课中,我们一起完成了算法设计核心内容的学习。我们回顾了如何将现实世界的问题用数据(初始状态和最终状态)进行建模。接着,我们深入学习了自顶向下逐步求精这一强大工具,它帮助我们将抽象目标层层细化,直至得到可直接转换为代码的伪代码。

我们了解到,任何算法都可以由五种基本操作构建:输入、输出、存储、处理和控制。在控制结构中,我们重点对比了 switch 语句和 if-else 链,并介绍了现代 switch 表达式的 yield 特性。

掌握这些基础,意味着我们已经具备了设计并实现简单程序的能力。接下来的作业和测试将综合运用这些概念,请务必通过实践来巩固理解。

009:僵尸末日 🧟

在本节课中,我们将详细讲解“僵尸末日”作业的要求、设计思路和实现步骤。这是一个回合制生存游戏,我们将采用“先展示,后实践”的教学模式,逐步构建游戏的核心功能,并鼓励你在此基础上添加自己的创意功能。

概述

本次作业的目标是构建一个名为“僵尸末日”的ASCII或Unicode图形化游戏。作业分为两个主要部分:第一部分是跟随详细的步骤指南,完成游戏的基础版本;第二部分是要求你在此基础上,自主设计和实现额外的游戏功能,以展示你对核心编程概念的理解。


作业结构与评分标准

作业文档可能看起来篇幅较长,但这是一件好事。文档非常详尽,会一步步指导你完成作业的前半部分。

作业名称是“僵尸末日”,这是一个类似roguelike的生存游戏。文档中提供了完整应用程序的截图。你可以制作ASCII版本,也可以制作图形更精美的Unicode版本。使用Unicode版本并实现复杂输出操作,可以满足作业的一项要求。

System.out 的功能非常强大,你不仅可以嵌入Unicode字符,还可以使用ANSI转义码来改变终端中字体的颜色或背景颜色。例如,通过ANSI码可以将背景设置为绿色来模拟草地。此外,ANSI码还可以用于清屏,从而实现游戏状态的刷新,这与真实视频游戏的运行方式一致。

评分标准设定了10个目标(从0到9)。每个目标价值5分,完成所有基础目标可获得50分。作业的前半部分主要是跟随指导完成,旨在以学徒模式向你展示良好的编程实践,例如变量命名和如何分解复杂应用程序。

后半部分则需要你展示所学,并自主为游戏添加功能。你可以从建议列表中选择功能实现,也鼓励你发挥创造力,设计自己的功能。这样做的目的是通过开放式作业,让你早期就能开始构建作品集,每个人的游戏都会因此变得独特。

评分标准展示了每个目标及其对应的分值。仅完成基础部分无法获得及格分数,你必须添加额外功能才能完成整个作业。

快速回顾一下,这体现了“先展示,后实践”的方法。学生首先通过逐步迭代一个完整应用程序的设计过程,学习核心概念和良好编码实践。之后,学生被挑战去改进应用程序,添加自行设计的功能。自定义功能必须使用课程目标中的概念才能获得学分。

这些学习目标包括数据建模、算法设计、自顶向下逐步求精的迭代设计过程、测试驱动开发以及创建可读性强的自文档化代码。

我们将评估的编程实践,即我们希望看到你具备能力的方面,包括:展示如何使用处理操作来有意义地改变数据状态;使用重复操作来反复执行代码块,直到满足某个中断条件;以及使用选择操作来决定实际执行哪个(或哪些)代码块。


游戏规格与数据建模

接下来,我们明确什么是roguelike游戏。这为你提供了我们正在构建内容的背景信息。常见的roguelike游戏属性包括:回合制、基于网格(可上下左右移动)、存在永久失败、通常随机生成、具有随机结果等。这些信息主要是为了给你灵感,以便你在扩展游戏时,知道这类游戏通常包含哪些功能。

我们已经讨论了很多关于数据建模的内容。作业文档本身非常详细,没有遗漏任何内容。这里我们定义了数据模型:

  • 世界:一个基于网格的2D空间,可以想象成一个棋盘,每个单元格可以通过其行和列来标记。这样我们就可以标识玩家或僵尸的位置。
  • 玩家:具有数据属性。
  • 僵尸。
  • 出口。

在右侧的属性列表中,我定义了如何在游戏世界中建模每一个对象:

  • World:包含网格列大小(整数)、网格行大小(整数)、空瓷砖(字符串)、地板瓷砖(字符串)。
  • Player:包含X位置(整数)、Y位置(整数)、代表玩家的字符串字符。
  • Zombie:包含X位置(整数)、Y位置(整数)、代表僵尸的字符串。
  • Exit:包含X位置(整数)、Y位置(整数)、代表出口的字符串。
  • Scanner:用于获取玩家输入。

游戏目标是:玩家从世界中的某个坐标开始,必须移动到出口才能获胜。如果僵尸触碰到玩家,则玩家死亡。因此,存在获胜条件和失败条件。

在开始实现任何功能之前,我们首先要定义数据模型。与我们之前构建的其他算法或应用程序相比,这里的数据模型更复杂一些,因为每个实体、每个对象都有多个属性。


目标0:顶层伪代码与开发流程

一旦明确了数据模型,我们将从目标0开始,即编写顶层伪代码。每个目标代表软件开发过程中该步骤我想要实现的内容。我从不希望一次性尝试构建整个应用程序,因为那样复杂度会太高、太冗长、太庞大,难以一次性处理。我希望在构建应用程序时采取分而治之的方法,为自己设定能最终导向成品的微小步骤。

著名的格言是“千里之行,始于足下”。在设计应用程序时,我们不应考虑一次性构建整个应用程序并在完成前不进行测试或评估,而应该为自己设定一个小目标。我的第一个小目标就是创建伪代码,这就是目标0。

我将把每个目标分解为:

  1. 规划步骤:明确我想要实现什么。
  2. 实现步骤:如何在Java中编码实现。
  3. 测试步骤:验证该目标是否按预期工作。

我将对这个过程的10个目标(从0到9)中的每一个都重复此过程。

我的计划是:首先以非常宏观的方式定义整个应用程序的算法,忽略具体细节。这有助于将复杂的应用程序分解为一组类似的、更简单的任务。项目的后续部分将专注于迭代地实现这些任务,一次一个功能。这个过程我们称之为快速原型开发,在软件开发世界中非常常见。

我们的顶层游戏算法如下:

  1. 设置游戏数据。
  2. 运行主游戏循环:
    • 绘制游戏场景。
    • 获取玩家输入。
    • 执行玩家动作。
    • 检查是否满足获胜条件。
    • 如果游戏未获胜,则执行怪物动作。
    • 检查是否满足失败条件。

这表达了定义游戏玩法的指令集。为了完成这个应用程序,我需要用Java代码来表达所有这些语句。

在以一种非常类似伪代码的方式从算法上定义了游戏的功能之后,我将把它们转换成注释。这与我们学习的自顶向下逐步求精的过程相同。我已经定义了一个算法,现在我将把它们表示为逐行的注释,然后可以查看并思考如何实现。

在实现步骤中,我将定义一个类和一个方法,因为我的所有语句都必须放在方法中,所有方法都必须放在类中。然后,我将放入代表算法的注释。接着,我会测试以确保可以编译并运行到这一点。目前还没有实际实现的代码,所以它不应该做任何事情。但如果出现错误,意味着存在某种语法错误,我需要解决它。在进入下一个目标之前,始终要确保在每一个测试阶段都能编译你的代码,并且输出与指南中提供的输出相似。


目标1:定义并绘制游戏网格

完成目标0后,如果代码编译并执行,现在进入目标1。我给自己一个新的任务,当我完成这个任务时,就进入下一个目标。在这里,我一次只看小目标。我需要创建一个包含玩家、僵尸和出口的游戏世界。但在做任何这些之前,让我看看是否可以先定义和绘制游戏网格。这个小小的目标将使我离构建完整应用程序更近一步。

我为这个目标制定计划:如何定义和绘制网格?让我们专注于绘制一个空的游戏网格。建模网格所需的数据是:网格中的行数、网格中的列数以及地板瓷砖图形。

我的伪代码是:对于每一行,对于每一列,打印地板瓷砖。打印完一行后,执行换行符,下一行出现在其下方。

一旦我们理解了这一点,并且在你完成这个实验时,请确保理解每个伪代码在做什么以及对应的Java代码是什么样的。我不希望你只是复制粘贴,我希望你从根本上理解发生了什么,理解每一步背后的动机。

实现如下:注释“设置游戏数据”处的黄色代码是新增的代码,它应该放在你已有代码文件中的什么位置。一个常见的错误是反复复制粘贴相同的代码。你是在上一个目标的基础上进行编辑。新增的代码用黄色高亮显示,旧代码则不高亮。这意味着“设置游戏数据”这个注释已经存在。所以,在这个注释下面,我们将添加黄色的代码。

我们将添加:

  • columnSize = 10
  • rowSize = 10
  • floorTile = ". "

这是我们的第一步,初始化世界网格数据属性。这个目标的第二步是创建一个双重for循环,让我可以绘制行和列。

这里你可以看到一个双重for循环,一个用于绘制行,另一个用于绘制列。在双重for循环内部,我将打印出地板瓷砖。这完全遵循了我的规划步骤和伪代码。

同样,我只是遵循自顶向下逐步求精,一旦有了伪代码,我就在旁边匹配Java语句。右侧是我的逐行概念解释。

一旦实现了这一点,我就进行测试。实际编译我的Java代码并执行,然后说:在这个阶段,我是否得到了预期的输出?你应该做同样的事情。在确认这个特定目标工作正常之前,不要进入下一个目标。因为如果你得到一个错误,现在捕获错误并调试比等到作业结束时再处理要容易得多。等到最后可能会有100个不同的错误,而这些错误可能从目标1就开始了,那时调试和找出问题所在将变得非常困难。所以尽早捕获它们,这就是测试驱动开发的全部意义:我们做一点,然后测试;再做一点,再测试;不断添加复杂性,从简单开始,直到构建出复杂的东西。


目标2:定义并绘制玩家

一旦我得到了空的网格,我给自己一个新的目标:第二个目标,我想要定义并绘制玩家。同样,我的规划步骤讨论了如何在我的游戏算法中建模和定义它。

让我们专注于在网格中绘制玩家。建模玩家对象所需的数据是:玩家X位置、玩家Y位置和玩家瓷砖图形。

然后我给出伪代码:在我们进行for循环执行绘制逻辑时,我们不只是为每个实例绘制空瓷砖,我们想检查当前正在绘制的瓷砖是否与玩家位置相同。如果是玩家位置,我们将绘制玩家瓷砖;如果不是,则绘制空瓷砖。

现在你可以看到我们如何在绘制逻辑中做出决定,判断是玩家还是地板。一旦我们理解了它在伪代码和自然语言中如何工作,我们将在Java程序或Java应用程序中对它进行编码。

我将进入我的“设置游戏数据”部分,已有的代码不高亮,所以我将找到应用程序内部、类内部的那个空间,并在其后添加这段新代码。我将定义一个玩家位置 playerX, playerY,我将把他们放在 (0, 0) 位置,然后我将给出一个符号来定义玩家,例如“@”符号。

然后,我将进入之前已有的“绘制游戏场景”逻辑,并创建一个选择语句来确定是应该绘制玩家瓷砖还是地板瓷砖。一旦完成,我就进行测试。我编译、运行,这现在应该是我游戏应用程序的预期输出。如果我得到了这个,我可以给自己一个新的目标,让自己离完成这个游戏更近一步。


目标3:创建游戏循环

下一个目标是:好的,我可以绘制游戏世界,可以绘制玩家。让我们创建一个游戏循环,可以反复绘制游戏世界状态,一帧又一帧。这样我们就可以开始更新玩家的移动,开始实现用户交互性,并且基于用户提供给我们的输入,我们实际上可以改变玩家的位置。在我们能做到这一点之前,让我们将逻辑编码到一个循环中,以便拥有那个循环过程。

我们的计划是:主游戏循环负责重复执行每个游戏回合的事件和动作。游戏循环是哨兵控制的,因为游戏回合的数量取决于是否出现输赢条件。由于游戏循环不断重复单个回合的所有动作,因此完整回合的所有游戏逻辑都必须嵌套在while循环中。

一旦我们定义了逻辑并确定了游戏循环,我们就可以实现它。在这里,我将创建一个新的变量作为循环控制变量,我称之为 gameOver,并将其初始化为 false。然后,我将创建一个while循环,并将我之前的所有内容封装到我的while循环中。只要游戏没有结束,我就会执行所有这些动作:绘制动作、获取玩家输入动作、执行玩家动作、检查获胜条件、执行怪物动作和检查失败条件。

然后,我将进行测试,编译并运行。我们应该得到的是在控制台上无限打印出相同的游戏世界,一遍又一遍。


目标4:实现玩家移动输入

现在我们有了一个循环,如果我们然后查询或提示玩家给我们一个动作,我们可以接受那个动作,改变玩家的状态,当下一次我们打印出游戏世界的状态时,我们的玩家应该绘制在一个不同的位置。所以,现在我们有了一个无限游戏循环,下一个目标是继续更新玩家的状态。

在这里,我们最终将实现玩家的输入移动。我们的计划是:我们将使用多重选择来更新每个回合的玩家X和Y。来自Scanner对象的玩家输入用于确定玩家X或Y坐标是递增还是递减。玩家控制键是:W上移、S下移、A左移、D右移。需要注意的是,由于这是一个基于网格的世界,每个单元格都有X和Y坐标,你应该理解(0,0)位置在左上角。这意味着向上移动是Y递减,向下移动是Y递增,向左移动是X递减,向右移动是X递增。这定义了我们如何通过改变位置在世界上移动。这是我们的数据模型,这就是我们如何将空间视为定量数据,以及如何使用算术运算来改变我们在世界中的位置。

一旦我们理解了这一点,我们就继续实现。同样,我们将按照这些说明来更新玩家状态,然后进行测试和运行。当你这样做时,你应该能够输入W、S、A、D,并实际观察你的玩家移动。目前还没有更新循环控制变量,所以如果你想终止游戏,必须按Ctrl+C来中断逻辑。


目标5:定义并显示出口

第五个目标,我们将定义并显示出口。这与之前所做的非常相似。我们现在将创建 exitX、exitY 和 exitTile。我们将把显示出口的功能添加到绘制逻辑中。然后我们将测试,看看出口是否出现。

然后,我们将测试当玩家触碰到出口时是否能中断游戏循环。在检查获胜条件的注释内部,伪代码是:如果玩家坐标和出口坐标相同,那么我们将 gameOver 设置为 true,并打印胜利消息。

现在我们知道伪代码是什么了,我们将进入检查游戏获胜条件并实现它。然后我们将测试,移动玩家穿过出口瓷砖,看看游戏是否停止运行。


目标6:定义并绘制僵尸

如果那可行,我们将定义并绘制一个僵尸。我们将创建僵尸坐标,在定义该逻辑的游戏场景中绘制僵尸,然后进行测试,看看僵尸是否被绘制出来。


目标7:随机移动僵尸

然后我们将随机移动僵尸。这里我有我的伪代码,我们有一个执行怪物逻辑以随机移动的小算法。伪代码在这里给出,然后实现也在这里给出。这里发生的情况是:我们随机生成一个0到3之间的数字。如果数字是0,我们将僵尸向右移动;如果是1,则向左移动;如果是2,则向上移动;如果是3,则向下移动。我们编译它,测试以确保僵尸移动。


目标8:定义游戏结束条件

然后我们将定义游戏结束条件。游戏结束条件是:如果玩家坐标与僵尸坐标相同,那么我们将 gameOver 设置为 true,并打印失败消息。我们将此语句放在失败条件下,检查它们是否相同,并将循环控制变量 gameOver 设置为 true,然后打印出一条消息。我们将测试看看是否可行。

这就是作业的前半部分。之后,你将需要添加自己的自定义功能。


后半部分:添加自定义功能

现在,每个人都必须添加的一个功能是:你必须向算法添加规则,以将玩家限制在关卡内。在最初的实现中,玩家可以轻易走出关卡并作弊。因此,需要约束这一点,防止玩家能够退出世界的上、下、左、右边界。

之后,这里有一些选项,每个选项价值10分。每个你实现的功能(超出达到100分所需的部分)都可以算作加分。因此,如果你不断添加功能,你可以在这个作业中获得超过100分。

你可以添加的功能示例,以展示你理解游戏逻辑的工作原理,包括:

  • 添加更多僵尸。
  • 添加多个关卡。
  • 添加更聪明的僵尸(例如,让僵尸有模式或直接向玩家移动)。
  • 添加障碍物(如墙壁等)。
  • 添加随机放置的钥匙(出口在获得钥匙之前无法进入)。
  • 添加武器(允许你在拥有武器时杀死僵尸,而不是僵尸自动杀死你)。
  • 改进图形(默认图形是ASCII字符;如果你使用Unicode字符或ANSI码字符升级它,你可以获得加分。如果你不熟悉,可以查找相关资料。在Java中搜索“ANSI code Java”,你会找到如何渲染背景颜色和进行屏幕刷新的示例代码。这是一个容易添加的功能,建议你研究一下)。
  • 添加食物计数器(你有有限的移动次数,必须在前往出口的路上收集食物才能成功,如果路径选择不正确,你会饿死)。

这些都是选项,或者你可以发挥创意,添加我未指定的功能。同样,我给出了一个基础列表,但不要感到受其约束。

提交时,请提交你的 ZombieApocalypse.java 文件和 README.txt 文件。README.txt 应包括你添加的功能,并讨论你如何使游戏变得更好。

请记住,在这门课程中,你获得任何作业学分的唯一方式是与我预约审核,运行代码并展示给我看。我将一对一为你的实现提供反馈,因为我认为反馈是学习编码过程中非常重要的一部分。

如果你还没有开始,现在就开始。请注意,这需要一些时间。这些作业的范围比实验大得多,这是有意为之。实验是教你如何按照自己的设计进行编码,而作业则是向你展示如何构建更大的应用程序,但更像是引导你完成它。


总结

在本节课中,我们一起详细剖析了“僵尸末日”作业。我们学习了如何通过定义清晰的数据模型(世界、玩家、僵尸、出口)来构建游戏基础,并遵循自顶向下、逐步求精的迭代开发流程,从伪代码开始,分多个小目标(从绘制网格到实现完整游戏循环)逐一实现。我们强调了测试驱动开发的重要性,即每完成一小步就进行编译和测试。最后,我们探讨了作业的后半部分——如何发挥创造力,在基础版本上添加自定义功能(如更多敌人、更智能的AI、更好的图形等),从而将所学知识转化为个人作品。记住,完成作业的关键在于理解每一步背后的逻辑,而不仅仅是复制代码,并且最终需要通过一对一的代码审核来获得反馈和学分。

010:DRY与KISS原则入门

在本节课中,我们将正式从算法设计单元过渡到软件设计单元。我们将学习两个核心的软件设计原则:DRY原则和KISS原则。这些原则将帮助我们编写更简洁、更易维护的代码,并为后续学习方法、数组和类等新工具打下基础。

什么是DRY设计?

上一节我们介绍了算法设计的基本构建模块。本节中,我们来看看DRY设计原则。

DRY是“Don't Repeat Yourself”的缩写。在编程中,这意味着我们不应该重复编写相同的代码。如果相同的代码块出现在两个或更多地方,我们就应该将其提取到一个独立的方法中。同样,如果有一组相关的值,我们应该将它们放入数组或类实例中,以便将它们组织在一起。

DRY原则的核心表述是:系统中的每一段知识(数据或逻辑)都必须有单一、明确的表示。这意味着它应该只存在于一个地方,而不是像杂草一样散布在整个应用程序中。

为什么要在乎DRY代码?

遵循DRY原则能让你的代码更易于编写和阅读。违反DRY原则通常会导致代码库急剧膨胀,例如达到上千行代码。大量重复的代码会使阅读和理解变得困难,因为你必须费力地记住“这段代码是给僵尸1用的吗?还是给僵尸2或关卡3用的?”。这会增加大量的心智负担。

DRY代码还能让你的代码更易于维护。当逻辑需要修改时,你只需要在一个地方进行更改,这个更改会自动传播到所有使用该逻辑的地方。反之,如果逻辑被重复编写,你就必须找到每一个重复的实例并逐一修改,这很容易引入错误和漏洞,工作量也大得多。

如何实现DRY?

为了避免违反DRY原则,我们采用“分而治之”的策略,将系统划分为更小的部分。

以下是实现DRY的关键步骤:

  1. 将代码和逻辑划分为更小的、可复用的单元。可以将其想象为模块化,就像搭建乐高积木一样。
  2. 避免编写冗长的方法,而是将逻辑分解,并在方法内部使用这些现有的代码单元。
  3. 在需要的地方通过“调用”来使用这些代码单元。

我们已经讨论了DRY的好处:代码更少(少即是多)、节省时间和精力、易于维护以及减少出现bug的可能性。

什么是KISS原则?

除了DRY,我们还需要遵循另一个重要原则:KISS。

KISS代表“Keep It Simple, Stupid”(保持简单)。KISS原则要求我们保持代码简单明了,使其易于理解。毕竟,编程语言是给人看的,而不是给计算机看的。计算机只是无意识的二进制计算机器。我们花费精力格式化代码、选择好的变量名、将逻辑分解到多个方法中,都是为了我们人类自身的利益——为了创建一个易于回溯、重构、分享和理解的代码库。

如何实现KISS?

KISS原则在代码库中的一个常见体现是:每个方法应该只解决一个小问题,而不是处理许多用例。如果一个方法中有很多条件判断,就应该将它们分解成更小的方法。我们将在后续关于方法的课程中看到,这种“逐步求精”的过程将帮助我们进行所谓的“功能分解”。

以下是实现KISS的关键步骤:

  1. 尝试编写简单的代码。为你的问题构思多种解决方案,然后选择最好、最简单的一个来实现。
  2. 当你发现代码冗长时,将其分解为多个方法。
  3. 编写只完成单一任务的小代码块。一个经验法则是:当你查看一个方法时,问问自己“这个方法做得太多了吗?还是它只做一件事?”

KISS原则的好处我们已经讨论过:它能让一个开发者编写的功能,易于被其他所有人(包括未来的你自己)理解。最终目标是,将你的代码库视为一个不断演进、充满活力的文档集合。我们想要创建一个框架,能够轻松添加新功能,而不会破坏旧有的工作。

单元2的核心工具

为了实现DRY和KISS,我们将在单元2中重点学习三个核心工具:

  1. 方法:用于封装代码块。
  2. 数组:一种特殊的数据结构,可以容纳多个值,用于封装数据块。
  3. 类:允许我们将代码块和数据块封装在一起。

这些基础构件将帮助我们编写出符合DRY原则的代码,从而构建更健壮、更易扩展、易于添加、阅读和分享的软件。

总结

本节课中,我们一起学习了软件设计的两个基本原则:DRY(不要重复自己)和KISS(保持简单)。我们了解了为什么这些原则对于编写高质量代码至关重要,并探讨了实现它们的基本方法。最后,我们预览了在单元2中将用来实践这些原则的三个核心工具:方法、数组和类。掌握这些原则和工具,将使我们能够构建更清晰、更易维护的软件。

011:方法 🧩

在本节课中,我们将要学习软件开发中的一个核心概念:方法。我们将探讨什么是方法,它们与变量的区别,以及如何利用方法来编写更清晰、更易维护、更高效的代码。通过一个计算加权平均分的实例,我们将学习如何通过“自顶向下、逐步求精”的设计过程来分解问题,并最终用方法来实现我们的程序。


概述:什么是方法?

方法允许我们为一段代码块命名,这样我们就可以通过使用它的名字来调用它。方法非常有用,因为它们提高了代码的可读性和可靠性。

为了理解方法,我们可以将其与变量进行对比。

以下是变量与方法的对比:

  • 变量:一个命名的数据,我们将其存储起来以便后续使用。
  • 方法:一个命名的代码块,我们将其存储起来以便后续调用。

它们有些相似:变量让我们将一个具体的值存入内存,在程序后续需要时使用;方法则让我们为一段代码赋予一个名字,通过调用这个名字,就能执行那段代码。

通常,区别在于调用方式。当我们想要引用一个变量时,它看起来像这样:x + 5。这里,我们直接使用变量名 x。而当我们想要调用一个方法时,假设它也叫 x,那么调用方式会是 x()。无论是否需要传递输入参数,每次调用方法都必须使用括号 ()。

因此,在阅读代码时,你可以通过一个标识符是单独的名字,还是名字后跟了一组括号,来判断它代表的是一个命名变量还是一个命名方法。


方法与类

类可以包含方法,而方法内部可以包含代码。从一开始我们就知道这一点,但之前我们忽略了可以创建用户自定义方法的事实,以便专注于代码本身。现在,我们将开始专注于构建方法。

需要理解的是,当我们构建方法时,必须将所有方法都放在类的范围内。就像我们一直编码的方式一样,在开始构建应用程序时,我们会定义一个类。每个需要执行的应用程序都必须至少有一个 main 方法。如果一个类中没有 main 方法,那么这个类就不能独立运行,不能作为我们应用程序的入口。

但是,我们可以拥有不止一个方法。我们可以创建自己的方法,但每次创建时,都必须在类的范围内声明它。


方法声明 vs. 方法调用

声明是我们首次定义方法的时候。所有方法都必须在类的范围内声明。

调用是我们调用或使用那个方法的时候。我们通常在其他方法内部进行调用,以让它为我们执行任务。

理解这一点的方法是:方法之间通过相互传递数据来进行“交流”。一个方法可以通过两种方式传输数据:

  1. 向方法发送数据:我们可以通过将值放在方法名后的括号内,将数据从一个方法发送到另一个方法。这就是括号如此重要的原因,它代表了该代码块需要处理的数据。并非所有方法都需要输入值,但有些需要。
  2. 从方法返回数据:一个方法也可以将数据返回给调用它的方法。如果我们需要从一个方法返回数据给另一个方法,我们会使用 return 语句。return 语句通常是任何方法的最后一条语句。

在方法声明中,返回值类型的位置指明了这一点。如果你不需要返回任何数据,返回类型就是 void。但如果你确实想返回数据(一个方法只能返回一个数据),那么我们在通常写 void 的地方,写上要返回的数据类型。例如,如果一个方法要返回一个整数值,那么返回类型就是 int,并且我们必须将其写在方法头中。


方法的设计原则

方法头可以被视为我们代码实现与其他所有调用方法之间的一份契约。当我们开始创建方法时,目标是给方法起一个好名字,清晰地定义调用该方法时会发生什么。

在Java(以及大多数编程语言)中,通常的做法是选择一个好的动词,来传达将要执行的动作、事件或语句序列。方法名应该非常具有描述性,通常可以将其视为一个动作概念。通常,我们将变量名视为名词,将方法名视为动词。这样,我们就在代码库中构建起一种语言:我们拥有“事物”(名词),可以通过将这些“事物”发送给“动词”(方法)来对它们进行操作。

这些“动词”(方法)可以从另一个方法接收数据,也可以将数据返回。


方法如何帮助我们遵循DRY原则?

方法使我们能够避免重复,以下是六种主要方式:

  1. 定义一次,多次运行:方法允许我们定义一次算法,然后通过其名称多次运行它。这非常强大,尤其是在你已经完成的“僵尸启示录”游戏中,它让你可以编写一次代码,然后无限次重复使用,无需再次修改。
  2. 分解算法:方法允许我们将算法分解成更小的部分。将所有代码都放在 main 方法中会导致 main 方法非常难以阅读,这是糟糕的设计。我们的目标是通过将代码库分解到多个方法中,使其更易于管理。一个好的经验法则是:一个方法不应超过十几行代码。如果超过了,这可能是一个信号,提示你应该将其分解成更小的方法。另一个经验法则是:一个单一的方法应该只负责一项任务。
  3. 便于分步实现和测试:方法使我们的代码更容易分步实现和测试。你可以一次定义一个方法,然后测试其输入和输出,以确保其按预期工作,甚至在应用程序的其他部分完成之前就可以进行。这是进行单元测试的有效方式,代码库中最小的可定义单元就是方法。
  4. 分工合作:方法允许我们将项目分成多个部分,以便多人协作。我们可以分配任务,让不同的人负责编写不同的方法,而不是让一个人独自完成整个应用程序。
  5. 提高可读性:方法使我们的代码更容易阅读和跟踪。每个方法都有自己的职责,这使得维护、重构和调试变得容易得多。
  6. 保持主方法简洁:main 方法不应包含任何实现细节。我们之前严重违反了这一概念,因为我们不了解方法。但今后,我们希望 main 方法主要充当“委托者”的角色,其中唯一应该发生的事情就是调用其他方法。这使得 main 方法更具可读性,其目的应该是清晰地展示整个算法的总体逻辑。

所有这些概念共同作用,实现了我们所谓的自文档化代码。这些策略使得重新阅读代码以理解其逻辑变得尽可能容易。这不仅是为了他人,也是为了你自己。当你离开代码一段时间再回来看时,这些概念能帮助你快速回忆起关键的设计决策。


方法与功能分解

当我第一次讨论“自顶向下、逐步求精”过程时,我说过我们可以用它来做两件事。第一,我们可以从一个顶层语句开始,使用这种迭代的、逐步的方法,将这个简单的摘要扩展成一套完整的伪代码语句。伪代码的好处是它在概念上非常接近编程语言,使得我们可以将其一对一地映射到Java、Python或C++等具体语言。

除此之外,“自顶向下、逐步求精”过程还可以帮助我定义哪些部分应该成为方法。既然我们现在讨论方法,我们将再次演练这个过程,看看求精过程本身如何开始分解出应该被定义为方法的代码块。

我们将通过一个计算加权平均分的例子来具体看看功能分解和“自顶向下、逐步求精”过程是如何运作的。

顶层语句:确定一个学生基于任意数量的实验、作业和测试的加权平均分。

求精步骤1(主方法蓝图):

  1. 初始化所需数据。
  2. 从用户获取实验成绩并求和、计数。
  3. 从用户获取作业成绩并求和、计数。
  4. 从用户获取测试成绩并求和、计数。
  5. 计算并显示总加权平均分。

这个第一层求精仍然比较抽象,但它可以作为我们 main 方法的蓝图,代表需要调用的五个主要方法。

求精步骤2(方法内部逻辑):
当我们详细展开第二步(获取实验平均分)时,逻辑是:循环直到输入负数,将成绩加到总和,计数加一,提示用户输入,获取输入,最后计算平均分。

仔细观察会发现,步骤2、3、4(获取实验、作业、测试平均分)的逻辑几乎完全相同,唯一的区别是给用户的提示信息。这立即违反了DRY原则,提示我们应该将这些重复的逻辑合并到一个方法中。

通过这个设计过程,我们明确了:

  • 顶层语句成为类的头部注释。
  • 求精步骤1成为 main 方法中要调用的方法列表。
  • 求精步骤2及更深的求精定义了每个方法内部的具体实现。如果需要更多求精步骤,则表明某些方法可能需要进一步委托工作给其他辅助方法,从而形成一个方法调用树。

代码实现示例

基于上述设计,我们最终实现了一个程序。其核心是:

  1. 一个 getAverage 方法,它接收一个字符串参数作为提示信息,负责与用户交互,收集一系列成绩,计算并返回平均分。
  2. main 方法非常简洁,只包含几个方法调用和最终计算:
    double testAverage = getAverage("test");
    double homeworkAverage = getAverage("homework");
    double labAverage = getAverage("lab");
    double totalAverage = testAverage * 0.3 + homeworkAverage * 0.3 + labAverage * 0.4;
    System.out.printf("Your total average is: %.2f", totalAverage);
    

通过这种方式,main 方法变得高度可读,精确地反映了我们最初的求精步骤1。所有繁琐的实现细节都封装在了 getAverage 方法中。这种方法设计也避免了代码重复,完美遵循了DRY原则。


总结

本节课中,我们一起学习了软件开发中的核心构件——方法。我们理解了方法作为“命名的代码块”的本质,以及它如何通过提高可读性、可维护性和避免重复来提升代码质量。我们深入探讨了方法的声明与调用、参数传递与返回值。更重要的是,我们通过“自顶向下、逐步求精”的设计流程,实践了如何将复杂问题分解为多个方法,并最终实现了一个计算加权平均分的程序。记住,好的方法设计意味着单一职责、适当长度,以及一个清晰、可读的 main 方法作为程序的总指挥。

012:方法、类、包与应用程序接口 📚

在本节课中,我们将深入学习Java中的方法、类、包以及应用程序接口(API)。我们将探讨如何通过方法封装代码,如何将相关方法组织到类中,以及如何使用Java标准库中的API。课程内容将帮助初学者理解这些核心概念,并学会如何阅读和使用API文档。


上一节我们介绍了方法的基本概念和优势,本节中我们将详细拆解方法的构成部分。

方法详解 🔍

方法由两部分组成:方法头和方法体。方法头定义了方法的访问方式、返回类型、名称和参数。方法体包含了实现具体功能的代码块。

以下是方法头的四个组成部分:

  1. 访问修饰符:例如 public 或 private,决定其他类是否可以访问此方法。
  2. 静态修饰符:static 关键字表示该方法属于类本身,无需创建对象实例即可调用。
  3. 返回类型:方法执行后返回的数据类型。如果不返回任何值,则使用 void。
  4. 方法签名:由方法名和参数列表共同构成,用于唯一标识一个方法。

方法体是包含在一对大括号 {} 中的代码块,它包含了方法要执行的所有指令。


上一节我们了解了方法的构成,本节中我们来看看方法如何与输入输出交互。

方法的输入与输出 🔄

方法通过参数接收输入,并通过返回值提供输出。根据是否有输入和输出,方法可以分为四种类型。

以下是方法的四种类型:

  • 有输入,有输出:方法接收参数并返回一个值。例如,计算两个数之和的方法。
    public static int sum(int a, int b) {
        return a + b;
    }
    
  • 有输入,无输出:方法接收参数但不返回值(void)。例如,打印一条定制消息的方法。
    public static void printMessage(String msg) {
        System.out.println(msg);
    }
    
  • 无输入,有输出:方法不接收参数但返回一个值。例如,获取固定问候语的方法。
    public static String getGreeting() {
        return "Hello from Java!";
    }
    
  • 无输入,无输出:方法既不接收参数也不返回值。例如,执行一个固定任务的方法。
    public static void doTask() {
        System.out.println("Task completed.");
    }
    

调用方法时,必须按照方法签名中定义的顺序和类型传递参数。返回值可以被变量接收或在表达式中直接使用。


理解了方法的基本运作后,我们来看看如何将相关的方法组织在一起。

类与包 📦

类是一个容器,用于组织相关的方法和数据(字段)。例如,Java标准库中的 Math 类就包含了各种数学运算方法和常量(如 PI)。

包是用于组织相关的类的目录(文件夹)。Java使用包来管理庞大的类库,避免命名冲突。例如,java.lang 包包含了Java语言的核心类。

public 关键字使得一个类或方法可以被其他包中的类访问,这是代码可扩展性和重用的基础。


上一节我们讨论了如何组织代码,本节中我们来看看如何理解和使用他人编写的代码。

应用程序接口(API)文档 📖

API(应用程序编程接口)文档是软件组件的使用说明书。对于Java,API文档详细列出了每个包、类、方法和字段的说明。

阅读API文档时,每一行对应一个方法,其信息与方法头一一对应:

  • 修饰符和类型:如 public static。
  • 返回类型:方法返回的数据类型。
  • 方法签名:方法名和参数列表。
  • 描述:用自然语言解释方法的功能。

例如,Math 类中 abs(double a) 方法的API条目表示:这是一个公共静态方法,接收一个 double 类型参数,并返回一个 double 类型的绝对值。

只有 public 方法会出现在API文档中,因为只有它们才能被外部代码调用。


为了巩固对API的理解,让我们实际查看一下Java的标准API。

探索 java.lang 包 🧭

java.lang 包是Java语言的核心包,它会被自动导入到每一个Java程序中。我们无需编写 import 语句即可使用其中的类,如 System、String 和 Math。

以下是查看 Math 类API的步骤:

  1. 打开Java官方API文档(例如,搜索“Java 18 API”)。
  2. 找到 java.lang 包。
  3. 在类列表中点击 Math。
  4. 在 Math 类的页面中,你会看到两部分:
    • 字段:类中的常量数据,如 PI 和 E。
    • 方法:类中提供的所有静态方法列表,如 sqrt(平方根)、pow(幂运算)、max(最大值)等。

通过API文档,你可以快速了解有哪些现成的工具可以使用,从而避免“重复造轮子”。


本节课中我们一起学习了Java中方法、类、包和API的核心概念。我们拆解了方法的构成,区分了不同类型的方法,了解了如何通过类来组织代码,以及如何利用包来管理类库。最重要的是,我们掌握了阅读API文档这项关键技能,它能帮助我们高效地使用Java丰富的内置功能和他人的代码库。记住,优秀的开发者不仅善于编写代码,更善于利用现有的资源。

013:应用程序接口与数学类 📚

在本节课中,我们将继续探讨方法、类和包。我们将重点学习如何阅读和使用API文档,理解Java标准库中的Math类,并动手创建我们自己的工具类和方法。


概述

上一节我们介绍了方法的基本结构,包括方法头和方法体。本节中,我们来看看如何利用他人编写的方法,特别是通过Java的应用程序接口文档。我们将深入研究java.lang包中的Math类,学习如何使用其提供的数学方法,并最终创建我们自己的工具类来封装自定义功能。


解析API文档 📖

API文档为我们提供了关于他人编写的方法的宝贵信息。要使用这些方法,理解如何解析文档至关重要。

方法头向JVM提供了该方法的所有重要信息,包括:

  • 访问级别:例如public(所有代码可访问)、private(仅本类可访问)或static(可通过类名直接访问)。
  • 返回类型:可以是void(不返回值的过程方法)或任何数据类型(如int、double、String,这类方法称为函数方法,必须包含return语句)。
  • 方法名:方法名本身不必唯一。
  • 参数列表:定义在括号内,由数据类型和变量名组成,用于接收调用者提供的输入值。

方法的唯一标识是其签名,即方法名和参数列表的组合。

在API文档中,方法通常按以下格式列出:
修饰符 返回类型 方法名(参数类型 参数名)
例如,对于Math类中的绝对值方法:
public static double abs(double a)
这表示一个公开的、静态的方法,接收一个double类型参数a,并返回一个double值。


Java标准库与Math类 🔢

Java代码的组织结构是:语句存在于方法中,方法存在于类中,类存在于包中。java.lang包是核心包,会被自动导入到所有Java应用程序中。

算术运算符(+, -, *, /)的功能有限。Math类将一系列相关的数学方法(如计算绝对值、三角函数、平方根、幂运算)分组在一起,为我们提供了更复杂的数学运算能力。

以下是Math类中一些关键概念的描述:

  • 方法重载:Math类中有多个名为abs的方法,它们接收不同类型的参数(int, long, float, double)。Java虚拟机根据传入参数的数据类型自动选择正确的方法版本。这简化了我们的工作,我们只需记住一个方法名。
    Math.abs(-10);    // 调用 abs(int a)
    Math.abs(-3.14);  // 调用 abs(double a)
    
  • 常量字段:Math类还提供了两个有用的常量:
    Math.PI  // 圆周率 π
    Math.E   // 自然对数的底数 e
    
    它们被声明为public static final,意味着是公开的、静态的、不可更改的常量。
  • 其他实用方法:
    • Math.ceil(double a):返回大于等于参数的最小整数(向上取整)。
    • Math.floor(double a):返回小于等于参数的最大整数(向下取整)。
    • Math.round(double a):返回最接近参数的整数(四舍五入)。
    • Math.max(double a, double b):返回两个值中的较大者。
    • Math.min(double a, double b):返回两个值中的较小者。
    • Math.sqrt(double a):返回参数的平方根。
    • Math.pow(double a, double b):返回a的b次幂。
    • Math.random():返回一个[0.0, 1.0)范围内的随机小数。

使用Math类:代码示例 💻

让我们通过一个示例程序来演示如何使用Math类中的方法。

public class MathMethodsDemo {
    public static void main(String[] args) {
        double x = 100.6;
        double y = 3;
        double z = -345;

        // 1. 计算绝对值
        double absResult = Math.abs(z);
        System.out.printf("z的绝对值是:%.2f%n", absResult);

        // 2. 计算平方根
        double sqrtResult = Math.sqrt(9);
        System.out.printf("9的平方根是:%.2f%n", sqrtResult);

        // 3. 计算幂运算
        double powResult = Math.pow(2, 3);
        System.out.printf("2的3次方是:%.2f%n", powResult);

        // 4. 找出最大值
        double maxResult = Math.max(x, y);
        System.out.printf("x和y中的最大值是:%.2f%n", maxResult);

        // 5. 使用常量PI
        System.out.printf("π的值是:%.5f%n", Math.PI);
    }
}

运行此程序将输出:

z的绝对值是:345.00
9的平方根是:3.00
2的3次方是:8.00
x和y中的最大值是:100.60
π的值是:3.14159

创建自定义工具类 🛠️

理解了如何使用现有类之后,我们现在可以创建自己的工具类。工具类通常只包含静态方法,用于被其他类调用,其本身没有main方法。

我们将创建一个MaxGetter类,它包含一个能找出三个数中最大值的方法。

public class MaxGetter {
    // 一个“伪”常量(未用final修饰,演示问题)
    public static double PI = 3.14159;

    // 一个找出三个double数中最大值的方法
    public static double maxOfThree(double a, double b, double c) {
        double max = a; // 假设第一个数是最大的
        if (b > max) {
            max = b; // 如果b更大,则更新max
        }
        if (c > max) {
            max = c; // 如果c更大,则再次更新max
        }
        return max; // 返回最终的最大值
    }
}

现在,我们可以在主程序中使用这个自定义类:

public class MathMethodsDemo {
    public static void main(String[] args) {
        double x = 100.6, y = 3, z = -345;

        // 使用自定义的MaxGetter类
        double myMax = MaxGetter.maxOfThree(x, y, z);
        System.out.printf("使用MaxGetter,x, y, z中的最大值是:%.2f%n", myMax);

        // 访问自定义类的“常量”(目前不安全)
        System.out.printf("MaxGetter中的PI是:%.5f%n", MaxGetter.PI);
        // 危险操作:修改了“常量”的值
        MaxGetter.PI++;
        System.out.printf("修改后MaxGetter中的PI是:%.5f%n", MaxGetter.PI);
    }
}

输出将会是:

使用MaxGetter,x, y, z中的最大值是:100.60
MaxGetter中的PI是:3.14159
修改后MaxGetter中的PI是:4.14159

可以看到,我们成功创建并使用了自定义方法。但问题在于,我们定义的PI可以被其他类修改,这非常危险。为了将其变为真正的常量,需要添加final关键字:

public class MaxGetter {
    // 正确的常量定义
    public static final double PI = 3.14159;
    // ... 其他方法
}

添加final后,尝试MaxGetter.PI++会导致编译错误:“无法为最终变量PI分配值”。这保护了常量的值不被意外更改。

使用有意义的常量名(如PI)而非直接使用数字(如3.14159),可以避免代码中出现难以理解的“魔数”,使代码更易于阅读和维护。


总结

本节课中我们一起学习了:

  1. API文档的阅读:理解了方法签名、访问修饰符、返回类型和参数在文档中的表示方式。
  2. Java Math类的使用:探索了Math类提供的各种静态数学方法,并理解了方法重载带来的便利。
  3. 创建自定义工具类:动手创建了MaxGetter类,实现了多参数求最大值的方法,并学习了如何正确定义和使用public static final常量。
  4. 代码组织的重要性:通过将相关方法分组到类中,可以使代码库更模块化、更易于理解、调试和维护。

通过将功能封装在类和方法中,Java成为一种可扩展的语言,允许开发者不断添加新功能,并促进代码的共享与协作。

014:工具类与静态方法 🎲

在本节课中,我们将继续深入探讨方法。上一节我们介绍了方法的基本概念、与变量的区别、类与方法的交互方式,以及方法如何被包含在类中,类又如何被包含在包中。本节中,我们将聚焦于如何设计我们自己的工具类。

工具类通常只包含静态方法。我们将首先了解什么是工具类和静态方法,然后学习如何设计、实现和测试一个工具类,最后探讨如何改进它。

什么是工具类?🤔

工具类,也称为辅助类,是一种仅包含方法的类。它是无状态的,并且不能被实例化。它包含一系列相关的方法,以便在应用程序中重复使用。

工具类通常不是应用程序类,因此通常不包含 main 方法。它的设计目的是供其他类使用。工具类的价值在于它体现了Java作为一种可扩展编程语言的特点:我们可以不断向其添加代码,这样其他开发者就不必重复解决我已经解决的问题,或者我可以在多个应用程序中复用解决方案。

一个我们已经见过的工具类例子是 Math 类。Math 类只包含静态方法,这意味着它是无状态的。我们可以根据类名 Math 调用它,传入我们想要处理的数据,然后它返回一个结果。无论我们的应用程序是什么,我们都可以编写10个不同的应用程序,并在每个应用程序中依赖 Math 类来执行一些数学计算。

静态方法与静态字段 📊

字段是变量的另一个名称,通常在类作用域内。方法则是在类中定义的可执行代码块。

静态方法可以从类作用域直接调用,无需实例化类。静态方法应该是无状态的,这意味着它们具有单一的行为。

静态字段是在类作用域内定义的变量,对于整个类来说只有一个状态。字段或变量的状态就是它的值。当您有一个静态字段时,如果它是可变的(非只读),您可以改变它的值。在 Math 类中,PI 或 E 是只读的,但我们可以从 Math 类中调用这些值的状态。在作业中,您将创建可变的类字段来表示敌人位置或玩家位置,并且可以随时间改变它们。没有 final 关键字的字段是可变的、可写的,您可以改变它们的值。但当您改变它的值时,它是该单一值的变化,对整个类都有效,而无需实例化。

我们稍后会更多地讨论实例化,但在这里我们想区分静态方法和非静态方法。将来我们会学习实例方法,这是我们对非静态方法的另一种定义。如果我们省略 static 关键字,默认情况下它就是实例方法。

实例方法是有状态的。这意味着同一个方法可以根据调用它的实例产生不同的结果或处理方式。我们见过的一个实例方法是 String 类的 .equals 方法,其中字符串的状态会影响该方法的结果。例如,我有一个状态为 “foo” 的字符串,我可以对其调用 .equals 方法,并传入另一个字符串实例。如果我用 “foo” 调用 .equals(“bar”),它会返回 false。但如果我的字符串状态是 “bar”,并且我调用 .equals(“bar”),那么传入方法的参数值相同,但我得到了不同的结果。这是一个有状态的结果,它根据我的字符串状态(是 “foo” 还是 “bar”)而变化。这代表了一个非静态方法的实例。

而静态方法如果从类调用,它总是产生相同的结果。我们稍后在讨论构造函数和实例化时会更多地学习非静态方法。但现在,我们将把范围限定在类中定义的静态方法上,它们对所有事物都具有单一的无状态行为。

设计我们自己的工具类 🛠️

假设我们想要构建一个骰子工具类。这个骰子工具类应该包含所有相关方法或字段的概念。在我们的骰子工具类中,它将是一个包含许多骰子相关方法的类。例如,如果我们构建纸牌游戏、棋盘游戏或任何其他可能需要使用骰子的游戏,我们希望开发者可以导入我们的骰子工具类并使用它来掷骰子。掷骰子的想法本质上是无状态的:我们告诉类中的方法做某事,它返回给我们一个结果。这是设计工具类的一个完美例子。

在我们的实现目标中,我们将逐步完成以下步骤:

  1. 创建一个 Dice.java 文件,代表工具类。
  2. 为了验证它是否有效,我们将创建一个 DiceTester.java 文件。

我们将逐步讨论为了正确模拟掷骰子必须考虑的所有因素。我们将学习如何用随机性模拟骰子、均匀分布,并解释缩放和移位的工作原理。然后在测试器中,我们将更多地讨论什么是计算机模拟,并模拟多次掷骰子以获得准确的模拟结果。

数据建模过程 📐

在我们尝试在Java环境中构建任何东西之前,应该始终从数据建模过程开始。在实现骰子之前,让我们先谈谈一个六面骰子(我将其简称为D6)的物理对象是什么。它有六个面,每个面上都有一定数量的点(pip):一个面有一个点,一个面有两个点,一个面有三个点,一个面有四个点,一个面有五个点,一个面有六个点。它被设计成立方体形状,大概有锋利的边缘。

骰子的目的是什么?我们通常将其用作现实世界对象来生成随机数。从六面骰子可以得到的随机数范围是1到6。

模拟随机性 🎲

现在让我们谈谈如何模拟随机性。我们讨论了在现实世界中使用D6作为随机数生成器。每当我们开始讨论随机性时,重要的是要知道,在计算机科学、数学和科学领域,我们称之为随机或概率过程,另一个词是非确定性的。确定性过程是指我做某事时得到相同的结果,例如我按照食谱制作蛋糕,我可以无限次地执行该过程,每次都能产生非常相似或基本相同的蛋糕。但有些发生的事情您想要模拟,它们是非确定性的、概率性的,这是其行为本身固有的。掷骰子就是这样的事情。如果我创建一个掷骰子的模型,比如“3在范围内,我就放 rollD6 返回 3”,您可能会得到3,但这并不能完全捕捉骰子的实际行为。掷骰子现象的一个有趣之处在于它是随机的、非确定性的。没有确定的方法可以说当我掷这个骰子时会产生这个结果。没有一组 if-else 选择语句可以完全生成我想要的。因此,如果我想模拟它,我想用那种随机性来模拟。一旦我意识到我正在尝试模拟一个随机性问题,我就必须开始思考如何模拟那种随机性。

一个随机骰子的例子是掷六面骰子D6。这是一个随机事件,因为每次掷骰子时都存在固有的随机性,结果可能不同。事实上,我们希望每次都不一样。我们可以连续多次掷出相同的值,但它也必须有可能掷出其他值。

为了正确模拟随机属性,我们必须识别所有可能的结果以及每个结果发生的可能性。对于D6,您可以掷出1、2、3、4、5或6。接下来我们要问的是,存在哪些不同类型的随机性?在我们研究完这个之后,我们会讨论。

在单个D6上掷出任何特定值的可能性是多少?是六分之一。当我掷骰子时,掷出1、2、3、4、5或6的可能性是相等的,没有偏好。我们称之为均匀分布,因为从我可以随机获得的值的集合中,获得任何一个单一值的可能性都是相同的。

如果我将其绘制出来,x轴代表我的骰子面值(1, 2, 3, 4, 5, 6),y轴代表发生次数(可能性)。每个面值的发生次数都是1,除以所有可能结果的总和(6),每个值的可能性都是六分之一。结果的可能性等于该结果的数量除以所有可能结果的总和。

如果我们想正确模拟我们的D6,我们必须确保它遵循这种行为。您对随机数或某事发生的可能性有多熟悉?均匀分布只是众多分布中的一种,我们将来会看另一种您可能非常熟悉的分布。如果我们正确实现了骰子,当我们测试它时,我们应该测试以确保它表现出您期望的真实行为。在现实世界中测试时,您会去掷骰子,如果骰子没有加重,您不应该得到特定的偏好。

在Java中设计掷D6 🧮

那么我们如何在Java中设计掷D6呢?这是我们要做的核心原则。首先,我们应该查看一些我们可以访问的API。事实上,如果我们查看 Math 类,Math 类有一个 random 方法。从API中我们可以看到它是一个静态方法,因为 Math 是一个工具类。我们正在设计自己的工具类,我们的工具类实际上可以依赖其他工具类的方法。

这里我们有一个静态方法,它返回一个 double 数据类型。它是无参数的随机方法,因为这是方法签名(方法名和所需的输入)。描述是:返回一个带正号的 double 值,大于等于0.0且小于1.0。因此,Math.random() 有效地产生一个随机小数,范围包括0,但不包括1。我使用数学术语来表达两个值之间的范围:我们包括最小值,不包括最大值。并且在该范围内,没有任何值比其他值更有偏好,因此 random 方法表现出均匀分布,这正是我们在D6中寻找的。这似乎是一个理想的场景,但它只产生小数。

实际上,让我们看看它是什么样子。我们已经在第一次作业中见过这个。我将启动一个名为 jshell 的应用程序,它允许我在终端中运行Java代码。输入 Math.random(),我得到0.71...,注意它有大约15或16位精度。再次执行,得到0.4203...,我可以一次又一次地执行,它会给我不同的值。即使范围在0到1之间,该随机值的位数也非常多,因为它包含了所有精度点。

问题是我们如何思考使用这个范围在0到1之间的随机生成器来实际表示我们的骰子?我们如何建模?是否可以使用 Math.random() 来模拟掷D6的行为?

我们可以应用一个缩放因子。在数学中,我们可以做两件事来影响值的范围。值的范围是从某个最小值开始到某个最大值的连续值集合。缩放范围最常见的方法是乘以一个乘数。

假设我们从0到1开始。为了说明这对任何数字都有效,我将说明如果我们缩放随机值的范围会发生什么。乘以2、3、4、5和6,这样您可以看到会发生什么。如果我将小数点的每一位都乘以10,我从0.0、0.1、0.2...直到0.9。由于我们没有1,我将把我可以访问的末尾部分视为0.9。实际上,它会是0.999999...,直到我得到15或16位小数,但我们只看小数点后的前两位。

假设我想缩放范围,这样我就不只有0作为前导数字,我可以表示两个输出选项。想象一下,就我们想要的结果数量而言,小数点左边的部分将是实际整数,小数点前的整数部分。让我们看看,将整个范围乘以2。如果我们的数字是0.0,乘以2就是0.0;如果是0.1,乘以2就是0.2;0.2变成0.4;0.3变成0.6;0.4变成0.8;在0.5标记处变成1.0;然后0.6变成1.2;0.7变成1.4;0.8变成1.6;0.9变成1.8;0.99变成1.98。

现在,如果我取这些执行乘法后的小数,并将其强制转换为整数(即截断小数部分),您会注意到前导数字(我们将映射为结果数量的部分)的值将是0或1。这意味着,如果我将随机生成的数字缩放2倍,我可以映射两个可能的结果:一个结果映射为0,另一个结果映射为1。其可能性是均匀分布,所以得到0或1的结果是50%对50%。

让我们看看乘以3会发生什么。如果我的值大约到0.3,乘以3会产生一组前导值仍为0的值。如果我到达这个小数块并乘以3,它会给我一个前导值大约为1;然后突然,如果我到达这个块,它会给我一个前导值大约为2。如果我截断,只保留前导数字(整数值),它将给我机会得到0、1或2,即三种可能的结果。

您应该在这里看到,如果我们继续,在范围4上,前导值是0、1、2、3;在范围5上,是0、1、2、3、4;最后在范围6上,将是0、1、2、3、4、5。缩放因子的大小代表了我可以映射的可能结果的数量,如果我将结果随机数表示为从0开始一直到缩放值减1的整数。如果数字是2,我得到0、1;如果是3,得到0、1、2;如果是4,得到0、1、2、3;如果是5,得到0、1、2、3、4,因为仍然是五个数字,五个可能的结果,但我们从0开始计数。

这对大家来说清楚吗?回想一下僵尸游戏,我们想要四种可能的结果:向上、向下、向左、向右移动。我们确实映射了那个随机数,您可能还记得,我们将其乘以缩放因子4以产生四种结果之一,然后我们截断了小数部分,因为有16位数字。如果我们检查相等性,我们可能永远不会得到相同的随机数两次,或者发生的几率非常非常小。当我们知道结果数量时,我们截断小数部分,但我们会得到均匀分布,因为0.0到0.1之间、0.1到0.2之间等的数值数量是相等的。

这代表了我们可以如何获得六种不同的结果。对于D6,我们想要应用的缩放因子值是多少?是6。现在的问题是,当我们掷D6时,从范围6得到的值将是0、1、2、3、4或5。但当我们掷D6时,它将是1、2、3、4、5或6。

因此,处理随机数时的第二种方法是我们可以将整个值范围向左或向右移位。我们使用加法进行移位。如果我们想将值范围向右移动,我们会加上一个数。如果我的范围在0和1之间,并且我给该范围内的所有内容加1,那么我的新最小值将变为1,新最大值将变为2。如果我想将所有值范围向左移动,那么我的新最小值将变为-1,新最大值将变为0。

对于模拟D6的情况,如果我真的想表示1到6的掷骰结果,我只需要取从0到5的新缩放范围,然后给结果加1。如果随机得到的是0,它就变成1;如果是1,变成2;如果是2,变成3;如果是3,变成4;如果是4,变成5;如果是5,变成6。通过将所有结果向右移动一位,我仍然只有六种可能的结果,但现在所有这些结果都向右移动了一位。这清楚吗?但关键是我们必须先应用缩放因子来重新设定范围,从0到1重新设定到0到结果数量,然后截断小数部分,因为我们想将结果映射为从0开始到我们拥有的数字的整数计数。然后,如果我们需要实际值在数值上有意义(例如在僵尸游戏中,值并不重要,我们只是用它来表示向上、向下、向左、向右,我们表示特定结果发生的唯一ID),但对于模拟掷D6,我们实际上使用产生的值作为模型的一部分,所以我们将移位它,使其实际表示1到6之间的掷骰结果。

每个人都理解我们将用来表示掷D6随机过程的概念了吗?

数学表达式与实现 🧑‍💻

那么,模拟D6随机性的数学表达式将如下所示:我们将有一个0到1之间(不包括1)的随机数,缩放它,应用缩放因子,然后应用移位。

让我们使用自顶向下逐步求精的方法来实际开始构建这个类。我的顶层陈述是:我们将构建一个骰子库,一个包含掷骰子方法的工具类。就我们的目的而言,我们不会一次性尝试构建所有方法,我们从单一方法开始,并扩展我们的应用程序。我们想确保单一方法在测试后有效,然后可以向其添加另一个方法。对于我们的骰子工具类,让我们专注于掷单个D6。

我们将使用与求精过程一致的功能分解,掷单个D6的效果应该是:生成一个0到1之间的随机小数,乘以可能结果的数量,将该小数转换为整数以丢弃小数点,最后加1以将值范围从0到5移位到1到6。

好的,让我们实际开始构建。实际上,这已经完全构建好了。

这就是它的样子。我将有我的类 public class Dice。在里面创建一个静态方法,因为这些应该是无状态的方法,它们将返回一些数据,这里不需要任何输入。我们将产生0到1之间的随机数,乘以结果数量(六面骰子有六种可能结果),然后将其强制转换为整数以丢弃小数部分,之后我们将移位,加1,使我们的范围变为1到6。得到结果后,我们将其存储到一个 die 变量中,以便为其命名,然后返回它。

这段源代码有什么问题吗?让我们在这里创建,完美。只需创建一个代表我们正在设计的工具类的 Dice 类。保存。

测试工具类:模拟应用 🧪

即使我们不是从这个类构建应用程序,即使这是一个本身不设计为运行的工具类,我们仍然必须测试它,以确保我们的期望、数据模型以及我们在应用程序中综合模拟骰子行为的方式是一致的,即它模仿了实际掷骰子的行为。构建完工具类方法后,我不能直接执行和测试它,因为工具类很少有 main 方法,因为它们不是设计为应用程序的。所以我们要做的是创建一个模拟应用程序,一个D6模拟应用程序,这将是一个类,它将使用我们的工具类来掷D6一百万次。

模拟是软件世界中非常常见的应用程序。在这个例子中,模拟应用程序多次掷D6,记录每次掷骰以检查其概率是否与真实D6相似。模拟应该综合重现真实观察的行为。我们可能都看过很多关于最近袭击佛罗里达海岸的飓风的模拟,那是基于大量数值数据构建的综合模型,代表了海洋的所有有意义的测量,试图预测风暴将如何跨越时间和空间移动。但你看到的模型(预测)并不是真实的,它基于对现实世界现象的观察。如果它是一个好模型,那么模拟的合成路径将告诉我们实际现实世界中真实风暴会发生什么信息。并非所有模型都是正确的,事实上,很少有模型是完全完整的,但它们只需要足够好,以让您了解周围发生的现象。

因此,每当谈论模拟时,我们在计算机科学中所做的一个重要事情就是构建模拟,无论我们是否意识到。模拟是我们一直在做的事情,有时是想象的,有时是真实的。

如果我们想检查真实D6的数学概率是否为六分之一,您会怎么做?让我们谈谈您将如何实际测试它。如果您有一个D6,我说,通过行为证明这是六分之一,而不是通过数学。您会拿起骰子,掷出它,然后记录值是什么。您可能有六个不同的计数器,分别对应掷出1、2、3、4、5或6的情况。您可能会掷很多次,因为您试图观察概率行为。如果您只掷一次,那没有足够的信息。如果您掷一次,可能得到3,然后您说“是的,它给了我3”,没有其他。然后您再掷一次,可能得到另一个3,再掷一次,得到2。因此,为了观察可能性(因为它是随机的),您必须观察许多不同试验中的随机过程,然后它说明了一种行为,一种分布行为。我们寻找的是均匀分布行为。

假设我要求您掷D6六百万次,您应该掷出1多少次?大约一百万次,对吗?掷出2也应该大约一百万次,掷出3也应该大约出现一百万次,不完全是,因为它是随机的,但如果试验规模足够大且真正均匀,您应该得到每个面值大约一百万次。如果我在现实世界中要求您这样做,掷骰子六百万次可能需要多长时间?相当长一段时间。在计算机内模拟行为的一个优势是我们可以更快、更便宜地完成。如果这个骰子确实表现出我们期望的属性,那么进行计算机模拟可以让我们预测未来,进行这些实验更便宜,并且我们可以进行比实际中更大的试验运行。这就是为什么计算机模拟如此有用,即使在传统科学如化学、生物学和物理学中也是如此,因为运行模拟以缩小到最优结果更便宜,然后您取最优结果并实际投入生产。例如,如果是化合物,您可以在数字上缩小实际化合物应该是什么,然后尝试制造它。这只是说明计算机科学已经以非常积极的方式影响了每个专业的每个领域,它使开发更便宜、更快捷。

那么,我们的模拟应用程序将设置初始数据模型以计算每个骰子结果的出现次数,然后重复多次掷骰子并递增适当的计数器,最后打印每个骰子面的出现次数。这将是我用于模拟应用程序的自顶向下逐步求精。

实现模拟测试器 🖥️

有了这些,我们为什么不开始实现呢?我将把我的注释代码放入一个 DiceTester 类中,放入 main 方法中,这将是一个相当简单的类。在这里,我将设置我的初始数据:创建六个不同的计数器(counterOne 到 counterSix),用于计算每个结果发生的频率。我将这些值初始化为0。

然后,第二件事是创建一个 for 循环。我将重复这个过程很多次,这里很多次大约是六百万次,这似乎是一个足够大的样本量,我应该能看到每个计数器大约递增一百万次。从0到6,000,000(我可以用下划线作为数字内的分隔符),在循环内,我将从 Dice 类中调用 rollD6 方法。注意,为了测试这个,我实际上要访问 Dice 类本身的 rollD6 方法。保存结果,然后使用 switch 语句。我的 switch 语句将根据这个 dieRoll 的值来操作:如果是1的情况,递增 counterOne;如果是2,递增 counterTwo;依此类推,直到6。最后,我将打印出每个计数器的状态,打印骰子面值以及在那六百万次掷骰中实际出现的次数。

关于这个测试的定义或这段代码是否足够简单,有什么问题吗?好的,让我们执行这个。粘贴到这里,看看我们得到什么结果。编译并运行代码。

注意,运行六百万次掷骰模拟甚至不需要一秒钟,我的结果大约是每个面值一百万次。这告诉我,我确实有一个均匀分布,这意味着这实际上模拟了掷真实D6的情况。我可以在游戏中使用我的应用程序,而不是实际拥有物理骰子来掷,我应该得到与预期相同类型的结果。每次我运行这个,我应该得到一组不同的结果,有时略多于一百万,有时略少于一百万,但大致上大约是。

改进我们的工具类 🔧

现在,改进它的一种方法是讨论模拟多个D6,例如掷2个D6。目前我们的骰子工具类可能想添加另一个方法,因为假设我们想掷多个D6骰子。按照我们当前的实现方式,我们必须多次调用该方法。或者,假设我们想要获得不同的随机分布。现在当我们掷单个骰子时,我们得到均匀分布,但如果我们想要获得正态或高斯分布,我们的值实际出现的可能性不同呢?所以,我们将设计一个新方法,重载 D6 方法,该方法接受一个整数参数,表示我们想要掷的D6骰子的数量。

我们将有两个方法:无参数的 D6 和有单个参数的 D6,但它们将有两种不同的行为。

正态或高斯分布是什么?我相信每个人都听说过,我相信每个人都听说过钟形曲线。钟形曲线通常谈论的是正态或高斯分布。回想一下,在单个D6掷骰中,我的分布对于所有单个值是相等的,我掷出1、2、3、4、5或6的可能性相同。但有许多随机过程不具有均匀分布,它们具有高斯分布,您更有可能得到中间的值,而不太可能得到异常值或最小最大值。

如果我掷2个D6,那就是我们不再具有均匀分布的一个例证。因为如果我取两个值并将它们相加,例如,当我有2个D6时,可能的值的范围是多少?是2到12。最小值是2,最大值是12。让我们看看我在这里发布的图表。有多少种不同的方式可以掷出2?只有一种:两个骰子都掷出1。有多少种不同的方式可以掷出3?两种:掷出1和2,或2和1。掷出4有多少种方式?三种:1和3,2和2,3和1。掷出5有多少种方式?四种。掷出6有多少种方式?五种。掷出7有多少种方式?六种:1和6,2和5,3和4,4和3,5和2,6和1。然后8有五种方式,9有四种,10有三种,11有两种,12有一种(两个6)。所以,这里的想法是,当我掷两个六面骰子时,我最有可能得到的值是什么?是7,因为在所有可能的结果中,总共有多少种结果?如果我加上掷出2、3、4、5、6...的所有不同可能方式,我有36种不同的结果。在36种可能的结果中,我有可能得到7的方式有多少种?是6种。所以六分之三十六,大约是六分之一的机会。我得到7的可能性比任何其他值都大。然后您可以看到,我可以趋向于那个中点。我有三十六分之五的机会得到6或8,但我只有三十六分之一的机会得到2或12。所以我更有可能从中心得到一个值,这些是偏好,而不是在最小值和最大值上。有很多时候我们观察到随机过程,这就是我们想要的随机行为。

这很重要,这就是我介绍这个的原因。掷单个D6与掷2个D6背后的想法非常实用,您可能做过很多次,但是否考虑过这两种不同随机方法之间的可能性、分布、概率差异?这两种不同的随机分布,在模拟随机过程时,查看这些是很重要的。每个结果发生的可能性是什么,并确保您使用与现实一致或相似的行为。

如果我将此渲染成图表,请注意我的分布看起来非常不同,我更有可能得到这个峰值,而在这里我得到这些末端的可能性要小得多。所以,如果我有更大的样本量,这将开始呈现为看起来像钟形曲线的东西。我们只有少量的值,所以它看起来更像一个三角形。

设计重载的D6方法 📝

那么,让我们谈谈如何在我们的工具类中设计重载的D6方法。我们再次称之为 rollD6,这是重载方法的全部意义:我们使用相同的名称,这样就不强迫开发者记住更多东西。但现在,它不是没有输入(没有括号),而是接受一个整数输入,表示我们想要掷的D6骰子的数量。然后作为输出,我们将讨论返回骰子总和。

我们的初始数据是调用代码(客户端代码)给我们的数量,但对我们来说,我们将有一个代表0的骰子总和。为了测试这个,我们还将进行组合文本测试,我们不仅返回总和,还通过记录单个掷骰结果来确保总和正确。我们将有一个空的组合文本字符串。

我们的算法是:重复数量次以下操作:掷一个D6(调用我们实现的另一个方法来掷单个D6),将结果加到总和中,然后将该掷骰的特定值连接到我们的字符串组合文本中,这样我们可以确保它发生了X次,因为再次强调,随机过程您必须能够评估以确保它表现出您期望的行为。最后,我们还将总和连接到我们的组合文本,打印该组合文本,然后返回总和。这将是我们从自顶向下逐步求精过程开发的伪代码。

让我们将其付诸实践。这是我的新类示例,rollD6 方法同名,但接受一个参数,所以签名不同。我将创建那个组合文本字符串(空字符串)。我将有一个参数(给我的数量)。然后我将创建一个初始化为0的骰子总和。然后我将执行一个 for 循环,循环次数等于我们需要掷的骰子数量。在循环内部,我将调用 rollD6 方法(注意我在这里调用这个方法,所以在一个方法内部我可以调用另一个)。得到那个骰子值,将其加到我的总和中,然后也将其连接到我的组合字符串中。然后我将做一些有趣的事情:检查当前迭代器 i 的值是否不等于 quantity - 1(即,这不是最后一次迭代)。如果不是最后一次迭代,我将在组合文本中的数字之间添加一个加号;如果是最后一次,我将添加一个等号,以说明这是赋值给另一个东西。然后之后,我将连接我的总和,打印出来以便测试,然后我将实际返回骰子总和。

让我们去更新我们的 Dice 类。添加那个新方法,那个重载的方法。现在我们已经改进了我们的工具类,因为现在我们可以掷任意数量的骰子。

让我们创建一个新的测试类来实际测试这个。为此,我将说明我们仍然可以调用 Dice.rollD6() 来掷单个骰子,然后我将创建一个从0到20的 for 循环,并传入该数字,我们可以看到我们掷出的骰子有多大。我将转到我的 DiceTester 并更新那里的代码。

保存。如果这样做,注意我们在这里得到的是:我们的单个骰子掷出(这里是2),然后对于一个传入0的 for 循环,掷0个骰子没有意义,注意我们返回的结果是0,for 循环从未执行,我们初始化的骰子总和是0,所以实际上没有工作。这违反了掷X个骰子的条件,但说明这是一个边缘情况很重要,我们想测试我们的边缘情况,使其给出预期结果。如果我们告诉计算机掷0个D6骰子,这可能是预期结果。但如果我们掷1个D6,我们可以看到只得到2;如果我们掷2个D6,可以看到得到6+2=8,所以我们返回的结果是8,在我们的应用程序中,组合文本是“3+5=8”。这里是4个D6:6+5+6+1=18;5个D6:6+6+6+6+6=30;等等。这向我展示的是,我可以有7个D6、8个D6,一直到19个D6的组合,我得到了66。但这里我想强调的是我们拥有的灵活性:通过创建一个可以传入数量的重载方法,而不是仅仅创建一个掷2个D6或3个D6的方法,我们现在可以掷任意数量的D6,然后获得适当的结果,就像我们掷了一把骰子一样。

关于这个有什么问题吗?这实际上是我们将遵循的实现自己的工具类的过程。如果我想通过添加更多骰子类型或不同组合来进一步扩展,我可以这样做,并将它们全部添加到同一个工具类中。在这个例子中,我们一次处理一个方法,根据需要添加一个新方法,但我们可以将其扩展为拥有该类需要支持的尽可能多的方法。

没错,每个数字代表一个骰子掷骰的实际结果。如果我在这里做 Dice.rollD6(15),那是要求我的工具类掷15个D6,将它们全部相加,然后给我最终结果。猜猜任何两个或更多骰子的分布概率是什么?它实际上是正态分布。所以,唯一具有均匀分布的情况是当您只有一个骰子时。一旦您添加一个额外的骰子,整个分布概率就从均匀平坦变为高斯分布。随着您添加更多骰子,行为实际变化的方式是它变得更陡峭,所以您越来越趋向中心,而到达边缘的可能性越来越小。

如果这有道理,例如,如果我掷3个D6,得到3或得到18的机会比掷2个D6时要小得多,而我得到中间值的机会要高得多。所以,如果您想要高斯行为、正态行为,真正趋向中心并且很少达到标准偏差之外的最小最大值,那么您需要将多个组成部分加在一起。

还有其他问题吗?那么,这就是我们今天的讲座,这为我接下来将录制并让大家观看的讲座做好了很好的准备,在那里我们将围绕我们的骰子工具应用程序设计一个游戏:双骰子游戏。我将再次使用功能分解,从自顶向下逐步求精一直到实现,录制并发布在YouTube上。


本节课总结:在本节课中,我们一起学习了工具类和静态方法的概念。我们探讨了如何设计、实现和测试一个骰子工具类,包括模拟随机性、均匀分布、缩放和移位。我们还讨论了如何通过方法重载来改进工具类,以支持掷多个骰子,并了解了不同数量骰子产生的概率分布变化(从均匀分布到正态分布)。最后,我们通过构建模拟测试器来验证工具类的行为是否符合预期。

015:随机双骰子游戏 🎲

在本节课中,我们将要学习如何运用自顶向下、逐步求精的方法,结合方法分解,来构建我们之前在楼下实验室讨论过的“双骰子”游戏。本节课的目的是巩固数组之前的知识点,并回顾一些与方法相关的核心概念。

我们将进一步探讨魔数与命名常量的区别,区分局部变量、类变量和实例变量。实例变量是今天学习的重点,它将为我们下一讲开始讨论对象和创建自定义对象打下基础。我们还会学习枚举类型,这是一种我们可以自定义的数据类型,其特性与基本数据类型类似。枚举类型与switch语句结合使用时非常强大。此外,我们将讨论方法调用栈,理解方法调用的执行顺序。最后,我们将实际构建我们的“双骰子”游戏。

魔数与命名常量

在编程中,我们应始终追求代码的可读性。魔数是指直接硬编码在源代码逻辑中的数字。例如,在计算、选择或循环结构中直接使用数字。作为软件工程师,我们应该避免使用魔数。

真正的工程师和数学家都喜欢魔数,但在我看来,他们都不擅长为事物命名。因此,从编写自解释代码的一开始,我们就应努力让代码尽可能易读。

即使一个值永远不会改变,与其直接硬编码,不如为这个值赋予一个人类可读的名称,一个能提供上下文的名字,然后应用final关键字使其不可变。这样不仅防止了意外修改,也使代码更易理解。

例如,在计算圆面积的代码中:

// 使用魔数
double area = 3.14159 * 3.15 * 3.15;

这里的3.14159、3.15都是魔数。读者需要自己推断3.14159可能是圆周率π,而3.15可能是半径。这增加了理解成本。

相比之下,使用命名常量的代码虽然更长,但可读性大大增强:

// 使用命名常量
final double PI = 3.14159;
final double RADIUS = 3.15;
double area = PI * RADIUS * RADIUS;

这段代码清晰地表达了“圆的面积等于π乘以半径的平方”。有时,可读性是以代码的冗长为代价的,但这通常是值得的。

命名常量就是一个被命名的变量,但通过final关键字使其变为只读,因此我们称其为常量。

变量的类型:局部、类与实例

在Java中,变量主要分为三类:局部变量、类变量和实例变量。

局部变量是我们最早接触的变量类型。它定义在方法内部的代码块中。局部变量的作用域仅限于定义它的那对最内层花括号{}内。在方法中,如果你在if语句或while循环的代码块内定义了一个局部变量,那么它只存在于那个代码块中。尝试在作用域外访问局部变量会导致“符号未找到”的错误。在Java中,所有变量都必须先声明后使用。

类变量是我们学习的第二种变量类型。它们定义在类的范围内,与方法并列。类变量需要使用static关键字修饰。这使得我们可以通过类名来访问这个变量(或称为字段)。例如,ClassName.VARIABLE_NAME。

实例变量是第三种类型。它同样定义在类的范围内,但不使用static关键字。正因如此,它不是类本身的属性,而是类实例的属性。这意味着我们创建的每个类实例都可以拥有自己独立的实例变量值。我们将在下一讲深入讨论实例变量。

以下是一个示例代码,展示了三种变量的区别:

public class VariableExample {
    // 实例变量
    String instanceVariable = “instance variable”;
    // 类变量 (静态变量)
    static String classVariable = “class variable”;

    public static void main(String[] args) {
        // 局部变量
        String localVariable = “local variable”;
        System.out.println(localVariable);
        System.out.println(classVariable); // 直接访问
        System.out.println(VariableExample.classVariable); // 通过类名访问

        // 创建类的实例以访问实例变量
        VariableExample example = new VariableExample();
        System.out.println(example.instanceVariable);
    }
}

运行此代码,输出将依次为:local variable, class variable, class variable, instance variable。实例变量只有在使用new关键字创建类的实例后才会存在。

枚举类型

enum(枚举)是一个强大的关键字,用于创建自定义数据类型。它与class和interface一样,是Java源代码文件的顶级声明关键字。

枚举允许我们创建一个可枚举的集合,即一个具有明确定义、可计数值的集合。这与基本数据类型(如int, boolean, char)类似,它们都有固定的取值范围。例如,布尔值只有true和false。

通过枚举,我们可以创建自己的、类似于基本数据类型的自定义类型,其中包含一组预定义的常量(字面值)。按照命名规范,枚举中的常量名应全部使用大写字母,以表明它们是只读的。

枚举在以下场景中非常有用:

  • 指南针方向:NORTH, SOUTH, EAST, WEST
  • 星期:MONDAY, TUESDAY, ...
  • 月份:JANUARY, FEBRUARY, ...

创建一个枚举类型:

// 文件:Day.java
public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

使用枚举类型:

public class Main {
    public static void main(String[] args) {
        Day today = Day.FRIDAY; // 声明并赋值
        System.out.println(today); // 输出:FRIDAY
    }
}

枚举类型与switch语句是天作之合。以下示例展示了如何根据月份判断季节:

public class EnumSwitch {
    // 在类内部定义枚举
    public enum Month { JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE,
                        JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER, DECEMBER }

    public static void main(String[] args) {
        Month date = Month.JANUARY; // 这里可以替换为用户输入

        // 使用switch语句判断季节
        String season = switch(date) {
            case DECEMBER, JANUARY, FEBRUARY -> “Winter”;
            case MARCH, APRIL, MAY -> “Spring”;
            case JUNE, JULY, AUGUST -> “Summer”;
            case SEPTEMBER, OCTOBER, NOVEMBER -> “Fall”;
        };
        System.out.println(“The season is: “ + season);
    }
}

switch语句会检查date变量的值,并与各个case进行匹配。使用箭头->操作符可以避免忘记写break语句。当case对应的执行代码超过一行时,可以使用花括号{}将其括起来。

方法调用栈

理解方法如何执行,需要了解方法调用栈的概念。栈是一种“后进先出”的数据结构,就像一摞盘子,你总是把新的盘子放在最上面,取盘子时也从最上面开始拿。

Java虚拟机使用栈来管理方法的调用。当我们启动一个Java程序时,JVM会寻找main方法并将其压入调用栈,然后开始逐行执行其中的语句。

当执行到一个方法调用语句时(例如methodA()),JVM会暂停当前方法的执行,将新的方法(methodA)压入栈顶,并将执行指针跳转到这个新方法的开头。如果methodA内部又调用了methodB,那么methodB又会被压入栈顶。

当栈顶的方法执行完毕(遇到return或执行完所有语句),它会被弹出栈,执行指针会回到之前被暂停的方法(即新的栈顶方法),并从之前暂停的位置继续执行。这个过程一直持续到main方法也执行完毕并弹出栈,程序结束。

以下代码演示了方法调用栈的顺序:

public class MethodActivationStack {
    public static void main(String[] args) {
        String message = “Main”;
        String output = method1(message);
        output += “ -> Main”;
        System.out.println(output);
    }

    static String method1(String input) {
        input += “ -> Method1”;
        String output = method2(input);
        output += “ -> Method1”;
        return output;
    }

    static String method2(String input) {
        input += “ -> Method2”;
        String output = method3(input);
        output += “ -> Method2”;
        return output;
    }

    static String method3(String input) {
        String output = input + “ -> Method3”;
        return output;
    }
}

运行此程序,输出为:Main -> Method1 -> Method2 -> Method3 -> Method2 -> Method1 -> Main。这清晰地展示了方法调用“深入”再“返回”的栈式过程。

构建双骰子游戏 🎲

现在,我们将运用以上所有概念来设计并实现“双骰子”游戏。我们将使用命名常量替代魔数,使用枚举类型跟踪游戏状态,采用自顶向下逐步求精的方法设计算法,并通过方法分解来构建应用程序。

游戏规则回顾

  • 游戏开始时,玩家掷两个骰子。
  • 第一轮:
    • 若点数和为7或11,玩家获胜。
    • 若点数和为2, 3或12,玩家失败。
    • 若为其他点数(4,5,6,8,9,10),则该点数成为玩家的目标点数,游戏进入后续回合。
  • 后续回合:
    • 玩家继续掷骰子。
    • 若点数和等于目标点数,玩家获胜。
    • 若点数和为7,玩家失败。
    • 若为其他点数,则继续下一回合,直到获胜或失败。

第一步:自顶向下设计

顶层描述:双骰子游戏。这将成为我们Java文件的头部注释。

第一次求精:定义核心的数据模型和基本事件序列。这通常对应main方法的结构。

  1. 设置数据(数据模型)。
  2. 进行第一轮游戏。
  3. 报告游戏结果。
  4. 当没有获胜者或失败者时,继续下一轮游戏。
  5. 报告最终游戏结果。

第二次求精(功能分解):对第一次求精的每一步进行细化。

  • 设置数据:
    • 需要跟踪游戏状态(Status):赢、输、继续。
    • 需要记录玩家的目标点数(myPoint)。
    • 需要定义游戏规则中的特殊值(命名常量):SNAKE_EYES (2), TREY (3), SEVEN (7), YO (11), BOX_CARS (12)。
  • 进行第一轮游戏:
    • 掷两个骰子。
    • 如果点数和是7或11,更新游戏状态为WIN。
    • 如果点数和是2,3或12,更新游戏状态为LOSE。
    • 如果是其他点数,更新游戏状态为CONTINUE,并记住该点数作为myPoint。
  • 报告游戏结果:
    • 如果状态是WIN,打印胜利信息。
    • 如果状态是LOSE,打印失败信息。
    • 如果状态是CONTINUE,打印继续游戏信息。
  • 进行后续回合:
    • 掷两个骰子。
    • 如果点数和等于myPoint,更新状态为WIN。
    • 如果点数和等于7,更新状态为LOSE。
    • 否则,状态保持为CONTINUE,继续循环。

第二步:实现

首先,创建枚举类型Status来跟踪游戏状态。

// 文件:Status.java
public enum Status {
    CONTINUE, WIN, LOSE
}

接着,创建主游戏类Craps。

// 文件:Craps.java
/**
 * 双骰子游戏
 * 作者:[你的名字]
 */
public class Craps {
    // 命名常量 - 游戏规则
    private static final int SNAKE_EYES = 2;
    private static final int TREY = 3;
    private static final int SEVEN = 7;
    private static final int YO = 11;
    private static final int BOX_CARS = 12;

    // 类变量 - 玩家的目标点数
    private static int myPoint = 0;

    public static void main(String[] args) {
        // 1. 进行第一轮游戏,获取初始状态
        Status gameStatus = firstRound();
        // 2. 打印第一轮结果
        printResults(gameStatus);
        // 3. 当游戏状态为“继续”时,进行后续回合
        while (gameStatus == Status.CONTINUE) {
            gameStatus = nextRound(); // 玩下一轮,更新状态
            printResults(gameStatus); // 打印该轮结果
        }
        // 循环结束,游戏有了最终结果(赢或输)
    }

    // 方法存根(先声明,后实现)
    private static Status firstRound() { /* 待实现 */ }
    private static Status nextRound() { /* 待实现 */ }
    private static void printResults(Status status) { /* 待实现 */ }
}

现在,我们根据伪代码实现各个方法。

实现firstRound方法(使用switch语句):

private static Status firstRound() {
    int dieSum = rollDice(); // 假设有rollDice()方法返回2-12的随机数
    Status gameStatus;

    // 使用switch表达式,根据骰子点数决定状态
    gameStatus = switch (dieSum) {
        case SEVEN, YO -> Status.WIN;
        case SNAKE_EYES, TREY, BOX_CARS -> Status.LOSE;
        default -> { // 其他点数
            myPoint = dieSum; // 记住目标点数
            System.out.println(“Point is “ + myPoint);
            yield Status.CONTINUE; // 返回CONTINUE状态
        }
    };
    return gameStatus;
}

实现nextRound方法:

private static Status nextRound() {
    Status gameStatus = Status.CONTINUE; // 假设本轮开始状态为继续
    int dieSum = rollDice();

    if (dieSum == myPoint) {
        gameStatus = Status.WIN;
    } else if (dieSum == SEVEN) {
        gameStatus = Status.LOSE;
    }
    // 如果不是myPoint也不是7,则gameStatus保持为CONTINUE
    return gameStatus;
}

实现printResults方法:

private static void printResults(Status status) {
    if (status == Status.WIN) {
        System.out.println(“Player wins”);
    } else if (status == Status.LOSE) {
        System.out.println(“Player loses”);
    } else { // Status.CONTINUE
        System.out.println(“Continue to the next round”);
    }
}

辅助方法rollDice(模拟掷两个骰子):

private static int rollDice() {
    int die1 = (int)(Math.random() * 6) + 1; // 1-6
    int die2 = (int)(Math.random() * 6) + 1; // 1-6
    int sum = die1 + die2;
    System.out.printf(“Player rolled %d + %d = %d%n”, die1, die2, sum);
    return sum;
}

将rollDice()方法添加到Craps类中。现在,完整的游戏就可以运行了!每次运行都会根据随机生成的骰子点数,按照规则判断输赢,并打印出相应的游戏过程。

总结

本节课中,我们一起学习了多个重要的软件设计与开发概念。我们比较了魔数与命名常量,理解了使用命名常量如何提高代码的可读性和可维护性。我们区分了局部变量、类变量和实例变量这三种作用域不同的变量。我们深入探讨了枚举类型,学会了如何创建自定义的、具有固定值集合的数据类型,并发现它与switch语句结合使用时非常优雅和强大。我们还了解了方法调用栈的工作原理,明白了方法调用和返回的顺序是如何通过“后进先出”的栈来管理的。

最后,我们综合运用自顶向下、逐步求精的设计方法和功能分解的编程技巧,成功构建了一个完整的“双骰子”游戏。这个过程展示了如何将复杂的规则分解为可管理的模块(方法),如何使用恰当的数据结构(如枚举)来模拟状态,以及如何编写清晰、易于理解的代码。希望你能将这些技巧应用到未来的编程项目中。

016:数组变量与多值存储 📦

在本节课中,我们将要学习数组(Array)的概念。数组是编程中一种强大的存储机制,它允许我们在一个变量中存储多个相关的值。这与我们之前学习的“不要重复自己”(DRY)设计原则紧密相连,正如方法封装了代码一样,数组帮助我们更好地封装和组织数据。


数组简介与DRY设计

上一节我们介绍了方法,它让我们能够封装和重用代码块。本节中,我们来看看另一种实现DRY设计的重要机制:数组。

数组本质上是一种存储操作。在算法设计中,我们有五种基本构建块:存储、输入、输出、处理和控制操作。数组就属于存储操作。与我们之前学习的只能存储单个值的变量不同,数组允许一个变量存储多个值。

数组之所以契合DRY设计,是因为它允许我们更好地封装数据。方法封装了一组相关的代码语句,类封装了一组相关的方法和字段,而数组则封装了一组相关的数据。


数组的定义与Java实现

数组的核心概念是:它是一个可以包含多个值的变量。

在Java中,我们通过在数据类型后使用方括号 [] 来声明一个数组变量。实际上,我们一直在使用数组变量——每次创建 main 方法时:

public static void main(String[] args)

这里的 String[] args 就是一个字符串数组变量。

在计算机内部,声明数组时,会在内存中预留一块连续的空间来存储这些值。空间大小等于单个值所需字节数乘以要存储的值的数量。例如,一个 int 类型占4字节。要存储3个 int 值,数组就需要预留 4 * 3 = 12 字节的内存空间。


现实类比:购物清单 🛒

为了更好地理解数组,让我们看一个现实世界的例子:购物清单。

假设我的购物清单上有以下物品:

  • 鸡蛋
  • 牛奶
  • 面包
  • 冷切肉
  • 饼干
  • 冰淇淋

如果我想和朋友确认清单上的某样东西,一个很自然的方式是使用编号。我们会说“面包是清单上的第2项”。这种通过编号来访问列表中单个元素的方式,在编程中称为索引(Indexing)。

在Java中,我们做同样的事情,只是索引编号从 0 开始。

以下是购物清单的索引映射:

  • 索引 0: 鸡蛋
  • 索引 1: 牛奶
  • 索引 2: 面包
  • 索引 3: 冷切肉
  • 索引 4: 饼干
  • 索引 5: 冰淇淋

请注意,清单上有6个元素,但最大的索引号是5。这是因为我们从0开始计数,这是使用数组时必须牢记的重要规则。

数组由一组相同数据类型的相关数据值组成。这意味着,如果你声明了一个字符串数组,那么其中的每一个值都必须是字符串类型。


Java数组示例

现在,让我们将购物清单的例子转化为Java代码。

首先,我们可以声明并创建一个指定大小的空数组:

// 1. 声明一个字符串数组变量
String[] groceryArray;

// 2. 创建一个可以容纳6个字符串的空数组,并将其赋值给变量
groceryArray = new String[6];

创建数组时,我们使用 new 关键字,并必须在方括号中指定数组的长度(即能容纳多少个元素),因为Java需要知道要为它预留多少内存空间。

创建数组后,我们可以通过索引向其中写入值:

// 通过索引向数组写入值
groceryArray[0] = "鸡蛋";
groceryArray[1] = "牛奶";
groceryArray[2] = "面包";
groceryArray[3] = "冷切肉";
groceryArray[4] = "饼干";
groceryArray[5] = "冰淇淋";

要读取数组中的值,同样使用索引:

// 通过索引从数组读取值
String firstItem = groceryArray[0]; // 读取索引0的值:“鸡蛋”

由于我们经常需要遍历数组中的所有元素,for 循环是绝佳的搭档:

// 使用 for 循环遍历数组
for (int i = 0; i < groceryArray.length; i++) {
    String item = groceryArray[i];
    System.out.println("索引 " + i + ": " + item);
}

注意循环条件 i < groceryArray.length。length 是数组的一个只读字段,它告诉我们数组的长度。我们使用 < 而不是 <=,因为最大有效索引是 length - 1。


数组字面量(初始化列表)

如果我们已经提前知道数组的所有元素,可以使用更简洁的数组字面量或称为数组初始化列表的方式来创建并填充数组。

// 使用数组字面量声明并初始化数组
String[] groceryArray = {"鸡蛋", "牛奶", "面包", "冷切肉", "饼干", "冰淇淋"};

这种方式只能在初始化(即声明和赋值在同一行)时使用,不能用于已存在数组的重新赋值。使用数组字面量时,我们无需指定长度,Java会自动根据元素个数确定数组长度。


增强型 for 循环

遍历数组以读取所有值是非常常见的操作,因此Java提供了增强型 for 循环(也称为“for-each”循环)来简化语法。

// 使用增强型 for 循环读取数组
for (String item : groceryArray) {
    System.out.println(item);
}

语法是:for (数据类型 局部变量名 : 数组变量名)。在每次循环中,item 变量会被自动赋值为数组中的下一个元素。

重要限制:增强型 for 循环只能用于读取数组元素,不能用于写入或修改数组。因为它操作的是元素的副本(一个局部变量),修改这个副本不会影响原始数组。如果需要修改数组元素,必须使用传统的 for 循环和索引。


数组与DRY设计实践

数组通过将相关数据分组,帮助保持代码的DRY。让我们看两个例子。

示例1:计算平均分
假设我们要计算一组已知分数的平均值。

非DRY方式(不使用数组):

int grade1 = 90;
int grade2 = 85;
int grade3 = 92;
int count = 3;
int sum = grade1 + grade2 + grade3;
double average = (double) sum / count;

每增加一个分数,就需要多声明一个变量并手动更新求和计算。

DRY方式(使用数组):

int[] grades = {90, 85, 92};
int sum = 0;
for (int grade : grades) {
    sum += grade;
}
double average = (double) sum / grades.length;

使用数组后,无论有多少个分数,求和与计算的逻辑都保持不变,代码更简洁、更易扩展。

示例2:模拟骰子频率测试
回顾我们之前测试六面骰子均匀性的代码,当时我们为每个可能的点数(1到6)都声明了一个独立的计数器变量。

使用数组可以极大地改进这段代码:

// 创建一个长度为7的数组,索引0不使用,索引1-6对应骰子点数1-6
int[] frequency = new int[7];

// 模拟投掷骰子多次
for (int i = 0; i < 6_000_000; i++) {
    int dieRoll = d6.roll(); // 假设d6.roll()返回1-6
    frequency[dieRoll]++; // 直接使用骰子点数作为索引
}

// 输出结果
for (int face = 1; face < frequency.length; face++) {
    System.out.println("点数 " + face + " 出现了 " + frequency[face] + " 次");
}

这种方式的优势在于:

  1. 代码更简洁:无需为每个点数声明单独的变量。
  2. 更健壮和可扩展:如果想测试两个骰子之和的分布(结果范围是2到12),只需将数组长度改为13,并修改循环逻辑即可,而无需声明11个不同的计数器。这完美体现了DRY设计原则和避免使用“魔数”的好处。

总结

本节课中我们一起学习了数组这一核心概念。我们了解到数组是一种特殊的变量,可以存储多个相同类型的值。我们学习了如何在Java中声明、创建(使用 new 或字面量)、写入和读取数组元素,并理解了数组索引从0开始的规则。

我们探讨了如何使用传统的 for 循环和增强型 for 循环来遍历数组,并明确了后者仅用于读取。最后,我们通过计算平均分和优化骰子模拟器两个实例,看到了数组如何帮助我们实践DRY设计原则,使代码更简洁、更易维护和扩展。

数组是组织和管理相关数据集合的基础工具,在后续学习更复杂的数据结构时,你会不断用到它。

017:作为引用类型的数组

在本节课中,我们将深入学习数组,特别是它们作为引用类型的行为。我们将探讨“按值传递”与“按引用传递”的核心区别,并介绍多维数组的概念。理解这些概念对于编写高效且可预测的代码至关重要。

引用数据类型回顾

上一节我们介绍了数组的基础知识,本节中我们来看看数组作为引用类型的特性。

首先,我们需要明确什么是引用数据类型。在本学期初,我们花了很多时间讨论基本数据类型。基本数据类型的一个关键特征是,其所有值都是已知的,它们被编码为Java内部的字面值,不占用额外的内存空间。

而引用数据类型则没有在Java内部预定义的字面值。当我们为引用数据类型赋值时,该值被存储在内存中。我们通过一个内存地址来查找和访问这个值。例如,整数值 3 是一个基本值,Java已经编码了它。而字符串是引用数据类型,这就是为什么我们用大写 S 的 String。字符串之所以必须是引用类型,是因为其可能的组合数量无限,无法硬编码到Java中。每次我们创建一个字符串,它都是一个存储在内存中的独特对象,我们只在需要时检索它。

将数据存储到内存中的过程就是变量的本质。我们学到有一种特殊的变量——数组变量,它允许我们在内存中存储多个值。因此,数组本身是一种消耗内存空间的高级数据类型。它有一个指向内存中数组存储位置的初始指针。同时,索引或偏移量表示我们可以在该连续内存块中存储的额外值的数量。

当我们开始讨论如何共享数组变量的值,而不是基本数据类型的值时,内存地址与基本值之间的区别将变得非常重要。

引用与解引用

在深入讨论之前,我们先明确几个术语:引用和解引用。

  • 引用:指的是我们有一个值和一个变量名。这个变量名是一个别名。对人类可读的名称,在计算机层面会转换成一个十六进制数,即我们要访问的内存地址空间。
  • 解引用:当我们访问该内存位置并取出其中存储的值时,这个过程就叫做解引用。解引用一个值意味着查找它在内存中的存储位置,并取回实际存储在那里的值。

当我们提到引用数据类型时,指的是我们使用的值本身并不是实际值,而是用于在内存中查找实际值的引用。存储在内存中的值,我们可以通过分配给它的变量名进行解引用来引用它。

按值传递 vs. 按引用传递

接下来,我们要探讨的核心概念是“按值传递”和“按引用传递”。

当我们最初学习方法时,我们实际上是在进行“按值传递”。这意味着我们将字面值作为参数传递。该值被共享给另一个方法,那个方法可以随意改变这个值,但不会改变原始变量。

而“按引用传递”意味着我们将数据在内存中的实际地址传递给方法。任何使用该引用(内存地址)对该数据对象所做的更改,对于所有其他也能访问该值的方法来说,都会生效。

以下是两者的关键区别:

  • 基本值和字符串值是按值传递给其他方法的。这意味着如果我们使用变量作为参数,传递的是其值的副本。
  • 数组没有一个单一的值。传递给其他方法的是数组的内存地址,这样它们可以直接读取或写入。这被称为按引用传递。这可能存在风险,因为现在数组在多个方法之间共享,在一个方法中的更改会导致所有其他方法中的数组也发生改变。

让我们通过源代码来具体分析,确保大家都能理解这里发生的事情。

代码示例:传递数组

我们将创建一个名为 PassArray 的类来演示这些概念。

public class PassArray {
    public static void main(String[] args) {
        // 使用数组初始化列表创建一个整数数组
        int[] intArray = {73, 87, 57, 102};

        // 调用 printArray 方法,传递数组(按引用传递)
        printArray(intArray);
    }

    // 一个打印数组内容的辅助方法
    public static void printArray(int[] array) {
        String resultString = "{";
        // 使用增强for循环遍历数组
        for (int number : array) {
            resultString += number + " ";
        }
        resultString += "}";
        System.out.println(resultString);
    }
}

在这段代码中,printArray 方法接收一个整数数组作为参数。当我们从 main 方法调用 printArray(intArray) 时,我们传递的是 intArray 的内存地址,而不是数组中的各个值。该方法接收这个引用,并能够遍历和打印数组的内容。

修改数组元素(按引用传递)

现在,我们添加一个方法来修改数组,观察按引用传递的效果。

public class PassArray {
    public static void main(String[] args) {
        int[] intArray = {73, 87, 57, 102};

        System.out.println("调用 changeArray 前:");
        printArray(intArray); // 输出: {73 87 57 102 }

        // 调用 changeArray 方法,传递数组引用
        changeArray(intArray);

        System.out.println("调用 changeArray 后:");
        printArray(intArray); // 输出会改变!
    }

    public static void printArray(int[] array) { /* 同上 */ }

    // 一个修改数组每个元素的方法
    public static void changeArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] = array[i] * 10; // 解引用并修改值
        }
    }
}

运行这段代码,你会发现调用 changeArray 之后,main 方法中打印的数组内容也变成了 {730 870 570 1020}。这是因为 changeArray 方法通过接收到的内存地址,直接修改了原始数组内存位置中的值。所有持有该数组引用的方法都会看到这个变化。

修改单个元素(按值传递)

为了对比,我们看看如果只传递数组中的一个元素(一个基本类型值)会发生什么。

public class PassArray {
    public static void main(String[] args) {
        int[] intArray = {73, 87, 57, 102};
        changeArray(intArray); // 先乘以10,数组变为 {730, 870, 570, 1020}

        System.out.println("调用 changeElement 前:");
        printArray(intArray); // 输出: {730 870 570 1020 }

        // 尝试修改第一个元素,传递的是 array[0] 的值(730),而不是引用
        changeElement(intArray[0]);

        System.out.println("调用 changeElement 后:");
        printArray(intArray); // 输出会是什么? {730 870 570 1020 } 还是 {0 870 570 1020 }?
    }

    public static void printArray(int[] array) { /* 同上 */ }
    public static void changeArray(int[] array) { /* 同上 */ }

    // 一个试图修改单个整数元素的方法
    public static void changeElement(int element) {
        System.out.println("在 changeElement 中,接收到的值是: " + element);
        element = 0; // 这只修改了局部变量 `element` 的值
        System.out.println("在 changeElement 中,修改后的值是: " + element);
    }
}

运行代码后,你会发现数组的第一个元素在调用 changeElement 后仍然是 730,而不是 0。这是因为 intArray[0] 进行了解引用操作,取出了值 730。这个 730 作为一个基本类型值(按值传递)被传递给 changeElement 方法。方法内部的 element 是一个局部变量,存储了这个值 730 的副本。将 element 改为 0 只影响这个局部副本,而没有影响到原始数组 intArray 在内存中位置 0 的值。

多维数组

理解了数组是引用类型后,我们自然会想到一个问题:能否创建包含其他数组的数组?答案是肯定的,这就是多维数组,也称为数组的数组或嵌套数组。

我们将学习多维数组的字面量初始化、创建新的空多维数组以及如何访问其中的元素。

多维数组字面量

以下是一个字符串类型的二维数组(数组的数组)示例:

public class MultiDimArray {
    public static void main(String[] args) {
        // 声明并初始化一个二维字符串数组(锯齿状数组)
        String[][] names = {
            {"Dan"},                     // 第0行,1列
            {"Ted", "Alex", "Joe"},      // 第1行,3列
            {"Elsa", "Tim"},             // 第2行,2列
            {"Henry"}                    // 第3行,1列
        };

        // 遍历二维数组
        for (int i = 0; i < names.length; i++) {
            System.out.println("外层数组索引 " + i + " 指向的内存地址: " + names[i]);
            System.out.println("  该内层数组的长度为: " + names[i].length);

            // 遍历内层数组
            for (int j = 0; j < names[i].length; j++) {
                // 使用两个索引访问具体的字符串值
                System.out.println("  names[" + i + "][" + j + "] = " + names[i][j]);
            }
        }
    }
}

在这个例子中,names 是一个“锯齿状数组”,因为每一行(内层数组)的长度可以不同。我们使用嵌套的 for 循环来遍历它:外层循环 (i) 遍历外层数组(行),内层循环 (j) 遍历当前行所指向的内层数组(列)。

创建空的多维数组

我们也可以先声明数组,然后再为其分配内存空间。

public class MultiDimArray2 {
    public static void main(String[] args) {
        // 1. 声明一个二维整数数组,并创建外层数组(可容纳5个内层数组的引用)
        int[][] int2DArray = new int[5][]; // 只指定外层大小,内层数组暂为 null

        // 2. 手动创建两个内层数组(锯齿状)
        int2DArray[0] = new int[6]; // 第一个内层数组长度为6
        int2DArray[1] = new int[2]; // 第二个内层数组长度为2

        // 3. 为某个元素赋值
        int2DArray[0][3] = 5; // 设置 int2DArray[0] 这个数组的索引3处值为5

        // 4. 尝试遍历和打印(注意:未初始化的内层数组为 null)
        for (int i = 0; i < int2DArray.length; i++) {
            if (int2DArray[i] != null) {
                System.out.println("int2DArray[" + i + "] 的长度: " + int2DArray[i].length);
                for (int j = 0; j < int2DArray[i].length; j++) {
                    System.out.println("  int2DArray[" + i + "][" + j + "] = " + int2DArray[i][j]);
                }
            } else {
                System.out.println("int2DArray[" + i + "] 是 null,无法访问其长度或元素。");
            }
        }
    }
}

重要提示:当我们使用 new int[5][] 时,只创建了外层数组。这个数组有5个位置,每个位置可以存放一个对整数数组的引用,但初始时它们都是 null。如果我们试图在没有初始化内层数组(例如 int2DArray[2])的情况下就访问 int2DArray[2].length 或 int2DArray[2][0],将会抛出 NullPointerException。

规则的二维数组(表格数据)

如果数据是规则的表格形式(每行有相同的列数),我们可以在创建时同时指定内外层大小:

// 创建一个 5行 x 5列 的规则二维整数数组,所有元素初始化为0
int[][] table = new int[5][5];

这种方式一次性分配了所有内存,table[0] 到 table[4] 每个都是一个长度为5的整数数组,可以直接访问而无需担心 null 值。

总结

本节课中我们一起学习了数组作为引用类型的核心行为。

  1. 引用与解引用:我们明确了引用是内存地址的别名,解引用是通过地址获取实际值的过程。
  2. 按值传递 vs. 按引用传递:这是本节课的关键。基本类型按值传递,传递的是副本;数组等引用类型按引用传递,传递的是内存地址,导致数据在方法间共享。
  3. 多维数组:我们学习了如何创建和操作多维数组(数组的数组)。这包括使用字面量初始化锯齿状数组,以及使用 new 关键字动态创建规则或不规则的多维数组。访问多维数组中的元素需要使用多个索引。

理解按引用传递对于预测程序行为、避免意外修改共享数据至关重要。而多维数组是建模复杂数据(如网格、表格)的强大工具。在接下来的作业中,你将有机会应用这些概念,例如使用二维数组来构建一个游戏地图。

018:数组工具类 🧰

在本节课中,我们将继续深入学习数组,重点探讨可变长度参数、命令行参数、异常处理以及Java内置的Arrays工具类。我们将通过改进骰子游戏示例来理解这些概念,并学习如何编写更健壮、更高效的代码。


回顾骰子游戏 🎲

上一节我们介绍了多维数组以及按引用传递与按值传递的区别。本节中,我们来看看如何改进之前实现的骰子游戏。

上次我们修改了DiceTester类,使用数组来统计骰子各面出现的频率,这让我们能够方便地测试任意数量的骰子。现在,我们将进一步改进Dice类本身。

实现任意面数的骰子 🎯

假设我们想为Dice类添加一个方法,使其能够投掷任意面数的骰子(而不仅仅是六面骰子)。基于现有rollD6方法的逻辑,我们可以这样实现:

public static int rollDice(int faces) {
    // 生成一个 [0, 1) 之间的随机数
    double randomValue = Math.random();
    // 乘以面数,得到 [0, faces) 之间的浮点数
    double scaledValue = randomValue * faces;
    // 转换为整数,得到 [0, faces-1]
    int intValue = (int) scaledValue;
    // 加1偏移,得到 [1, faces]
    int result = intValue + 1;
    return result;
}

我们可以在DiceTester中测试这个方法,传入不同的面数(如6、12、2),观察输出结果是否符合预期。需要注意的是,通过加1进行偏移,我们确保了结果不会出现0,这模拟了真实骰子的行为。

关于随机值偏移的思考:偏移操作不仅限于向右(加正数)。有时,根据问题需要,我们可能希望将随机范围向左偏移(例如,生成包含负数的随机值)。这在模拟随机移动(如僵尸游戏中的移动方向)时非常有用。

引入可变长度参数(Varargs) 🔄

接下来,我们想添加一个能投掷多个任意面数骰子的方法。一个直接的想法是传入一个整数数组,数组的每个元素代表一个骰子的面数:

public static int rollDice(int[] diceFaces) {
    int sum = 0;
    for (int faces : diceFaces) {
        sum += rollDice(faces); // 调用单骰子方法
    }
    return sum;
}

这种方法可行,但调用者必须事先构建一个数组,这增加了使用复杂度。Java提供了更优雅的解决方案:可变长度参数。

我们可以将方法签名改为:

public static int rollDice(int... diceFaces) {
    int sum = 0;
    for (int faces : diceFaces) {
        sum += rollDice(faces);
    }
    return sum;
}

使用...(三个点)表示这是一个可变长度参数。现在,调用者可以直接传入逗号分隔的值,而无需显式创建数组:

// 之前:需要创建数组
int[] facesArray = {6, 8, 10, 12};
int result = Dice.rollDice(facesArray);

// 现在:直接传入值
int result = Dice.rollDice(6, 8, 10, 12);

Java会在内部自动将这些值打包成一个数组。这大大简化了客户端代码。

使用可变长度参数的重要规则:

  1. 可变长度参数必须是方法参数列表中的最后一个参数。
  2. 不能同时定义使用数组参数和可变长度参数的重载方法,因为它们的内部表示相同,会导致签名冲突。
  3. 你仍然可以将一个现有的数组传递给可变长度参数。

理解命令行参数 🖥️

我们一直在使用的main方法包含一个String[] args参数。这个数组用于接收从命令行传递给Java应用程序的参数。

例如,假设有一个对文件内容进行排序的应用程序Sort,我们可以这样调用:

java Sort friends.txt

其中"friends.txt"就是命令行参数,它会作为字符串存入args数组。

让我们创建一个简单的CommandArgs类来演示:

public class CommandArgs {
    public static void main(String[] args) {
        System.out.println("Number of arguments: " + args.length);
        for (String arg : args) {
            System.out.println("Argument: " + arg);
        }
    }
}

编译并运行:

javac CommandArgs.java
java CommandArgs
java CommandArgs hello
java CommandArgs hello world 123 true 3.14159

关键点:所有命令行参数都以字符串形式传入。如果需要在程序中将它们用作其他类型(如整数、布尔值),必须进行显式转换。

处理数组异常:越界访问 🚨

数组操作中一个常见的风险是数组索引越界。当我们尝试使用负数索引,或大于等于数组长度的索引访问数组时,就会发生ArrayIndexOutOfBoundsException。

考虑一个学生食堂质量调查的程序,评分范围为1-5分:

public class StudentPoll {
    public static void main(String[] args) {
        int[] responses = {1, 2, 5, 4, 3, 5, 2, 1, 3, 3, 1, 4, 3, 3, 3, 5, 2};
        int[] frequency = new int[6]; // 索引0不用,索引1-5对应评分

        for (int response : responses) {
            frequency[response]++; // 用评分作为索引
        }

        for (int rating = 1; rating < frequency.length; rating++) {
            System.out.printf("%d: %d%n", rating, frequency[rating]);
        }
    }
}

如果数据录入错误,例如responses数组中本应是3, 5,但漏掉了逗号变成了35,程序在运行到frequency[35]++时就会抛出ArrayIndexOutOfBoundsException,导致程序崩溃。

使用 try-catch 处理异常 🛡️

为了防止这类异常导致整个程序终止,我们可以使用try-catch块来捕获并处理异常。

public class StudentPoll {
    public static void main(String[] args) {
        int[] responses = {1, 2, 5, 4, 3, 5, 2, 1, 3, 3, 1, 4, 3, 3, 35, 5, 2}; // 包含错误数据35
        int[] frequency = new int[6];

        for (int response : responses) {
            try {
                frequency[response]++; // 风险操作放在try块中
            } catch (ArrayIndexOutOfBoundsException e) {
                // 捕获到异常后执行的处理逻辑
                System.out.println("Invalid response: " + response + " - " + e.getMessage());
                // 可以选择忽略该数据、记录日志、尝试修复等
            }
        }

        for (int rating = 1; rating < frequency.length; rating++) {
            System.out.printf("%d: %d%n", rating, frequency[rating]);
        }
    }
}

现在,当遇到无效数据35时,程序会捕获异常,打印错误信息,然后继续执行后续循环和输出,而不是直接崩溃。这大大增强了程序的健壮性。

探索 Java Arrays 工具类 🧰

Java在java.util包中提供了一个Arrays工具类,它包含许多用于操作数组的静态方法,如排序、搜索、比较、填充等。使用这些方法可以避免重复造轮子,提高开发效率。

首先需要导入:

import java.util.Arrays;

以下是Arrays类的一些常用方法:

1. 转换为字符串 (toString)
方便地打印数组内容,无需手动写循环。

String[] words = {"Hello", "World", "Java"};
System.out.println(Arrays.toString(words)); // 输出: [Hello, World, Java]

2. 比较数组 (equals, compare)
equals方法比较两个数组的内容是否完全相同(长度相同,对应元素相等)。

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
int[] c = {1, 2, 4};
System.out.println(Arrays.equals(a, b)); // true
System.out.println(Arrays.equals(a, c)); // false
// 注意:使用 == 比较的是引用地址,不是内容。

3. 查找第一个不匹配项 (mismatch)
返回两个数组第一个不相等元素的索引。如果完全相同,返回-1。

int[] d = {1, 2, 6};
System.out.println(Arrays.mismatch(a, d)); // 2 (索引2的元素不同:3 vs 6)

4. 复制数组 (copyOf)
创建原数组的副本,可以指定新数组的长度。

int[] original = {10, 20, 30, 40, 50};
int[] copy = Arrays.copyOf(original, 3); // 复制前3个元素
System.out.println(Arrays.toString(copy)); // [10, 20, 30]

5. 填充数组 (fill)
用指定值填充整个数组或数组的某个范围。

int[] arr = new int[5];
Arrays.fill(arr, 7);
System.out.println(Arrays.toString(arr)); // [7, 7, 7, 7, 7]

6. 排序 (sort)
对数组进行升序排序(原地修改)。

int[] numbers = {10, 30, 20, 15, 45, 23};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers)); // [10, 15, 20, 23, 30, 45]
// 也支持负数排序

7. 二分查找 (binarySearch)
在已排序的数组中快速查找指定元素,返回其索引(如果找到),否则返回一个负值。

int index = Arrays.binarySearch(numbers, 23);
System.out.println(index); // 3
index = Arrays.binarySearch(numbers, 100);
System.out.println(index); // 负数,表示未找到

总结 📝

本节课中我们一起学习了数组相关的高级主题和实用工具:

  1. 可变长度参数:使用...语法定义方法参数,允许传入任意数量的同类型参数,简化了调用方式。
  2. 命令行参数:通过main方法的String[] args接收外部输入,用于程序启动时的配置。
  3. 异常处理:使用try-catch块捕获并处理ArrayIndexOutOfBoundsException等运行时异常,使程序更加健壮。
  4. Arrays工具类:利用java.util.Arrays提供的静态方法(如toString, sort, binarySearch, fill等)高效地操作数组,避免重复编码。

掌握这些知识后,你将能够编写出更灵活、更安全、更易于维护的使用数组的Java程序。下一讲,我们将介绍另一种更灵活的集合类型——ArrayList。

019:ArrayList 类 📚

在本节课中,我们将要学习 Java 中的 ArrayList 类。ArrayList 是一个基于数组构建但功能更强大的类,它提供了动态调整大小、便捷的元素增删等能力,是处理数据集合的有力工具。我们将通过对比普通数组,来理解 ArrayList 的优势和基本用法。

概述

之前我们已经学习了数组的基础知识、多维数组、数组作为引用类型以及 Arrays 工具类。本节课程将作为数组主题的最后一讲,介绍 ArrayList 类。ArrayList 是 Java 集合框架的一部分,它封装了数组,并提供了更丰富、更易用的方法来管理数据集合,特别适合在程序运行时需要动态增减元素的场景。

ArrayList 与标准数组的对比

上一节我们介绍了数组的各种特性,本节中我们来看看 ArrayList 与标准数组的主要区别。理解这些区别有助于我们在不同场景下做出合适的选择。

标准数组在创建时必须声明其固定长度。这在某些情况下可能带来不便,例如,当无法预知需要存储多少数据,或者数据量在程序运行期间会增长时。

ArrayList 则无需在创建时声明大小。它可以初始化为空,然后动态地添加元素,其内部容量会自动增长。此外,你还可以从中移除元素,从而减小其大小。以下是 ArrayList 的一些核心优势:

  • 动态扩容:无需预先指定大小,随元素添加自动增长。
  • 灵活增删:提供了 add 和 remove 等方法,可以方便地插入或删除元素,并自动调整后续元素的位置。
  • 丰富功能:内置了搜索、比较、遍历等多种实用方法。

使用 ArrayList

要使用 ArrayList,首先需要导入它所在的包。与 Scanner 类似,ArrayList 属于 java.util 包。

import java.util.ArrayList;

创建 ArrayList 实例

创建 ArrayList 实例需要使用 new 关键字,并指定其将要存储的元素类型。注意,ArrayList 只能存储引用类型。对于基本数据类型(如 int, double),需要使用其对应的包装类(如 Integer, Double)。

// 创建一个存储字符串的 ArrayList
ArrayList<String> stringList = new ArrayList<>();
// 创建一个存储整数的 ArrayList
ArrayList<Integer> integerList = new ArrayList<>();

添加元素

我们可以使用 add 方法向 ArrayList 中添加元素。add 方法有两个重载版本:一个在列表末尾添加元素,另一个在指定索引处插入元素(原有元素会后移)。

以下是 add 方法的使用示例:

  • list.add("Apple"):在列表末尾添加 “Apple”。
  • list.add(0, "Banana"):在索引 0 处插入 “Banana”,原索引 0 及之后的元素依次后移。

访问与查询元素

与数组使用方括号 [] 访问元素不同,ArrayList 使用 get 方法根据索引获取元素。

String fruit = list.get(1); // 获取索引为1的元素

ArrayList 还提供了便捷的查询方法:

  • contains(Object):检查列表是否包含某个元素。
  • indexOf(Object):返回指定元素首次出现的索引,未找到则返回 -1。
  • lastIndexOf(Object):返回指定元素最后一次出现的索引。

移除元素

我们可以使用 remove 方法移除元素。它也有两个重载版本:按索引移除和按对象值移除。

list.remove(1); // 移除索引为1的元素,并返回该元素
list.remove("Banana"); // 移除首次出现的 “Banana”,成功返回 true,否则返回 false

其他常用操作

ArrayList 包含许多其他实用方法,以下是其中一部分:

  • set(int index, E element):替换指定索引处的元素。
  • clear():清空列表中的所有元素。
  • size():返回列表中当前元素的数量(相当于数组的 length,但是可变的)。
  • isEmpty():检查列表是否为空。
  • toArray():将 ArrayList 转换为一个标准数组。
  • subList(int fromIndex, int toIndex):获取原列表的一个子列表视图。

遍历 ArrayList

除了使用标准的 for 循环或增强型 for 循环,ArrayList 还可以通过迭代器进行遍历。迭代器提供了顺序访问集合中每个元素的方法。

// 获取一个迭代器
Iterator<String> it = list.iterator();
while (it.hasNext()) { // 检查是否还有下一个元素
    String item = it.next(); // 获取下一个元素
    System.out.println(item);
}

此外,ListIterator 提供了双向遍历的能力,可以向前或向后移动。

总结

本节课中我们一起学习了 ArrayList 类。作为对标准数组的增强,ArrayList 通过封装动态数组的实现,提供了自动扩容、便捷的元素增删查改以及丰富的工具方法,极大地简化了集合数据的管理。虽然它在某些性能极端敏感的场景下可能不如原始数组高效,但对于大多数日常编程任务而言,ArrayList 因其灵活性和强大的功能而成为更受欢迎的选择。记住,当你的数据集合大小需要动态变化时,ArrayList 是一个非常得力的工具。

020:实例与类 🧱

在本节课中,我们将学习面向对象编程中的一个核心概念:实例与类。我们将通过编写代码,对比使用static关键字和移除static关键字的不同,来理解为什么需要创建类的多个独立实例,以及如何通过构造函数来实现这一点。


概述

到目前为止,我们主要使用static关键字来定义类中的字段和方法。这意味着这些字段和方法属于类本身,而不是类的任何特定对象。这种方法在只需要一个共享状态时有效,但在需要创建多个独立对象(例如游戏中的多个敌人)时,就会遇到限制。本节课,我们将探索如何通过定义实例字段和构造函数来创建类的多个独立副本,从而实现真正的面向对象设计。


静态方法的局限性

上一节我们介绍了如何使用static关键字组织代码。本节中,我们来看看当我们需要多个相似对象时,仅使用静态方法会遇到什么问题。

假设我们正在构建一个游戏,其中包含Player(玩家)和Enemy(敌人)类。最初,我们可能这样定义Enemy类:

public class Enemy {
    public static String name;
    public static int x;
    public static int y;

    public static void start(String enemyName, int xPos, int yPos) {
        name = enemyName;
        x = xPos;
        y = yPos;
    }

    public static String toText() {
        return String.format("Enemy %s at %d, %d", name, x, y);
    }
}

在游戏的Game类中,我们可以这样使用:

public class Game {
    public static void main(String[] args) {
        Enemy.start("Goblin", 1, 2);
        System.out.println(Enemy.toText()); // 输出: Enemy Goblin at 1, 2
    }
}

问题在于:如果我们想创建第二个敌人,比如一个“Dragon”,并调用Enemy.start("Dragon", 7, 7),那么Enemy类中的name、x、y字段的值就会被覆盖。因为静态字段属于类本身,整个程序中只有一份。这意味着我们无法同时拥有一个在(1,2)的哥布林和一个在(7,7)的龙。

一种笨拙的解决方法是创建多个类,如Enemy1、Enemy2,但这严重违反了DRY(Don‘t Repeat Yourself)原则,且无法应对成百上千个敌人的情况。


引入实例:从蓝图到对象

为了解决上述问题,我们需要一种方法,能够根据一个“蓝图”(类)制造出多个独立的“产品”(实例)。每个产品都有自己的属性值,互不干扰。这就是实例化。

在Java中,我们通过移除static关键字并将字段和方法变为实例成员,然后使用new关键字和构造函数来创建实例。

以下是重构后的Enemy类:

public class Enemy {
    // 实例字段:每个Enemy对象都有自己的这些变量副本
    public String name;
    public int x;
    public int y;

    // 构造函数:用于初始化一个新Enemy对象
    public Enemy(String enemyName, int xPos, int yPos) {
        this.name = enemyName; // ‘this‘指代当前正在创建的对象实例
        this.x = xPos;
        this.y = yPos;
    }

    // 实例方法:操作特定实例的数据
    public String toString() {
        return String.format("Enemy %s at %d, %d", this.name, this.x, this.y);
    }
}

关键变化:

  1. 移除了static关键字:name, x, y现在属于每个Enemy对象。
  2. 添加了构造函数:它是一个与类同名的方法,用于在创建对象时初始化其状态。
  3. 使用this关键字:在实例方法中,this引用当前调用该方法的对象实例。
  4. 实例方法:toString方法现在可以访问并返回特定实例的name、x、y。

使用实例:创建和操作多个对象

现在,我们可以在Game类中轻松创建多个独立的敌人。

public class Game {
    // 声明一个静态数组来存放多个Enemy实例,便于全局访问
    public static Enemy[] enemies;

    public static void start() {
        // 使用‘new‘关键字调用构造函数,创建三个独立的Enemy实例
        Enemy goblin = new Enemy("Goblin", 1, 2);
        Enemy dragon = new Enemy("Dragon", 7, 7);
        Enemy orc = new Enemy("Orc", 5, 1);

        // 将实例存入数组
        enemies = new Enemy[]{goblin, dragon, orc};
    }

    public static void show() {
        // 使用增强for循环遍历并打印所有敌人
        for (Enemy monster : enemies) {
            System.out.println(monster.toString());
        }
        /* 等价于传统的for循环:
        for (int i = 0; i < enemies.length; i++) {
            System.out.println(enemies[i].toString());
        }
        */
    }

    public static void main(String[] args) {
        start();
        show();
    }
}

运行Game.main()方法,输出将是:

Enemy Goblin at 1, 2
Enemy Dragon at 7, 7
Enemy Orc at 5, 1

优势:

  • DRY原则:只需一个Enemy类定义,就能创建无数个敌人。
  • 状态独立:每个敌人对象(哥布林、龙、兽人)都有自己的name、x、y,修改其中一个不会影响其他。
  • 可组合性:可以将实例放入数组或集合中,便于进行批量操作,如遍历所有敌人检查碰撞、统一绘制等。这在开发游戏(如需要大量敌人的“太空入侵者”)或任何涉及多个实体的应用时至关重要。

核心概念总结

  • 类 (Class):对象的蓝图或模板,定义了该类对象共有的属性(字段)和行为(方法)。
  • 实例 (Instance) / 对象 (Object):根据类创建的具体个体。每个实例都拥有类中定义的字段的独立副本。
  • 构造函数 (Constructor):一个特殊的方法,名称与类名相同。用于在创建对象时(使用new关键字)初始化该对象的状态。
  • this关键字:在实例方法或构造函数中,this引用当前对象实例,用于区分实例字段和局部变量。
  • static vs 非static:
    • static成员属于类本身,在内存中只有一份,通过类名访问(如Enemy.start())。
    • 非static成员(实例成员)属于每个对象实例,每个实例都有一份,通过对象引用访问(如goblin.toString())。
    • 静态方法不能直接访问实例字段和方法,因为它不知道操作哪个实例的数据。

总结

本节课中我们一起学习了面向对象编程的基石:实例与类。我们通过一个游戏开发的例子,演示了仅使用静态成员的局限性——无法高效创建和管理多个独立对象。接着,我们移除了static关键字,引入了实例字段、实例方法和构造函数,从而能够从一个类定义中创建出任意数量的、状态独立的对象实例。最后,我们还看到了如何将这些实例组合到数组中进行统一管理,这为构建更复杂、更真实的应用程序(如包含多个实体的游戏)奠定了坚实的基础。理解实例与类的区别,是掌握Java及大多数现代编程语言的关键一步。

021:面向对象建模 🧱

在本节课中,我们将学习面向对象建模的核心概念。我们将从回顾上一讲的内容开始,然后深入探讨如何将软件系统设计为一系列相互协作的对象,而不是一系列独立的方法或语句。我们将学习如何使用UML类图来规划和设计对象,理解对象的属性(状态)和行为,并探讨封装和抽象的重要性。


上一讲我们介绍了实例的概念,并移除了static关键字,从而能够从类中创建多个副本。这标志着第二单元的结束,该单元主要讨论了方法和数组。现在,我们将进入第三单元:面向对象编程设计。

从过程式编程到面向对象编程 🔄

到目前为止,我们主要进行的是过程式编程,即将算法分解为一系列更小的方法或过程。现在,我们将“升级”我们的代码设计方式,开始将代码视为一系列对象的集合。

面向对象编程的核心思想是,我们倾向于将事物和概念本身视为对象。这非常符合人类的认知方式,因为我们生活在一个由对象组成的世界中。例如,机械工程师设计时钟时,会考虑齿轮、表盘、指针、马达等各个物理部件,每个部件都有其特定功能,共同协作以实现“报时”的整体目标。

同样,在软件开发中,我们希望将软件的所有组成部分视为软件对象。在规划应用程序时,我们需要找出构成该应用程序所需的最少数量的软件对象,每个对象在应用程序中扮演自己的角色,共同协作以实现整体功能。

面向对象设计概述 📋

本单元将涵盖以下核心内容:

  • OOP设计:比较过程式编程与面向对象编程。
  • 软件由对象类型构建:学习如何将事物建模为对象类型。
  • 抽象、封装与模块化:探讨采用面向对象方法的五大驱动概念。
  • 对象建模:在数据建模的基础上,学习如何将数据封装到对象模型中。
  • 对象间交互:对象通过方法与其他对象共享代码和交互。
  • 构建复杂对象:后续将学习通过组合(has-a关系)和继承(is-a关系)从现有对象构建更复杂的对象。
  • 根类Object:了解所有对象都继承自的Object类。
  • 继承、抽象类与接口:学习如何构建具体类、抽象类和接口,以构建复杂的软件系统。

面向对象设计允许我们抽象掉问题域中不属于该对象本身的所有细节,并将数据封装到这些对象模型中。

如何开始对象建模:UML类图 📐

当我们开始设计对象时,通常从创建UML类图开始。UML(统一建模语言)提供了一套图表工具,用于表达软件系统中多个事物之间的关系。在面向对象设计中,我们使用类图来规划每个对象的职责。

一个UML类图通常包含三个部分:

  1. 类名:位于顶部,表示要建模的对象的类型。
  2. 属性:中间部分,列出定义该对象的属性或字段。
  3. 方法:底部部分,列出该对象可以执行的行为或操作。

让我们通过一个例子来具体说明。

示例:设计一个Player类 🎮

假设我们正在设计一个游戏,需要一个Player(玩家)类。

1. 确定类名
首先,在UML图的顶部写上类名:Player。

2. 定义属性(状态)
接下来,思考哪些属性定义了一个玩家。属性是对象的特征,在代码中表现为实例变量。

以下是Player可能具有的一些属性:

  • x (int): 玩家在游戏世界中的X坐标。
  • y (int): 玩家在游戏世界中的Y坐标。
  • width (double): 玩家的宽度。
  • height (double): 玩家的高度。
  • imagePath (String): 玩家图像的路径。
  • hitPoints (int): 玩家的生命值。
  • attackPower (int): 玩家的攻击力。
  • name (String): 玩家的名字。

在UML中,我们这样表示:

Player
-------------------
- x: int
- y: int
- width: double
- height: double
- imagePath: String
- hitPoints: int
- attackPower: int
- name: String

- 符号表示该属性是私有的。

3. 定义方法(行为)
最后,定义玩家可以执行哪些操作。行为是对象的动作,在代码中表现为方法。

以下是Player可能具有的一些行为:

  • move(newX: int, newY: int): void:移动到新位置。
  • attack(): int:执行攻击,返回造成的伤害值。
  • jump(): void:跳跃。
  • heal(amount: int): void:治疗,恢复一定生命值。
  • takeDamage(damage: int): void:承受伤害。

在UML中,我们这样表示:

Player
-------------------
- x: int
- y: int
- width: double
- height: double
- imagePath: String
- hitPoints: int
- attackPower: int
- name: String
-------------------
+ move(newX: int, newY: int): void
+ attack(): int
+ jump(): void
+ heal(amount: int): void
+ takeDamage(damage: int): void

+ 符号表示该方法是公有的。

为什么使用私有属性和公有方法? 🔒

这是一个关键概念:封装。

  • 私有属性:我们将所有实例变量(属性)设为private。这意味着其他类不能直接访问或修改玩家的内部状态(如hitPoints或x坐标)。这可以防止外部代码意外或恶意地将玩家置于无效状态(例如,将生命值设为负数)。
  • 公有方法:我们通过public方法(如move()、heal())来提供与对象交互的接口。这些方法内部可以包含逻辑来确保状态更改是有效的。例如,在move()方法中,我们可以检查新坐标是否在有效范围内。

这种方式确保了对象的责任明确。如果玩家的状态出现问题,我们只需要检查Player类内部的方法,而不是在整个代码库中搜索。这提高了代码的可维护性和健壮性。

处理复杂属性:对象中的对象 🧩

有时,一个属性本身过于复杂,无法用基本数据类型(int, double, String, boolean)表示。这时,我们需要将其建模为另一个对象。

示例:设计一个UnoStudent类 🎓

考虑为UNO学生建模一个UnoStudent类。

可能的属性:

  • studentId: String - 学号(用String而非int,以保留前导零)。
  • firstName: String - 名。
  • lastName: String - 姓。
  • gpa: double - 平均绩点。
  • isEnrolled: boolean - 是否在读。
  • transcript: ??? - 成绩单。

成绩单transcript包含课程列表和对应成绩,它不是一个简单的值。因此,更好的做法是创建一个单独的Transcript类,其中包含courses: String[]和grades: double[]等属性。然后,UnoStudent类可以拥有一个transcript: Transcript类型的属性。

UnoStudent
-------------------
- studentId: String
- firstName: String
- lastName: String
- gpa: double
- isEnrolled: boolean
- transcript: Transcript
Transcript
-------------------
- courses: String[]
- grades: double[]

这种“对象包含对象”的关系就是组合(has-a关系)。它帮助我们更好地组织复杂数据,并将相关逻辑封装在合适的类中(例如,计算GPA的逻辑可能在Transcript类中)。

总结 📝

本节课我们一起学习了面向对象建模的基础。

  • 我们了解了从过程式编程转向面向对象编程的动机:将软件视为由具有特定职责的对象组成的集合。
  • 我们学习了使用UML类图作为设计工具,它包含类名、属性(状态)和方法(行为)三个部分。
  • 我们深入探讨了封装的原则:将属性设为private以保护对象内部状态,通过public方法提供可控的交互接口,从而确保对象始终保持有效状态并明确责任。
  • 我们认识到,当属性过于复杂时,应将其建模为另一个对象,从而通过组合来构建更复杂的系统。

下一讲,我们将把这里的UML设计付诸实践,开始编写代码来构建一个使用面向对象方法的应用程序。

022:账户对象的设计与测试

在本节课中,我们将继续学习面向对象编程原则。我们将通过一个具体的例子——设计一个银行账户类,来实践如何从UML图建模到代码实现,并学习如何通过单元测试来验证我们的代码。

上一节我们介绍了面向对象编程的基本动机和UML建模的三个核心概念:类名、属性和行为。本节中,我们来看看如何将这些概念应用到一个具体的“账户”对象的设计与实现中。

账户类的UML设计

首先,我们来看一下为银行账户设计的UML图。这个账户类模拟了ATM机中的账户。

以下是该类的核心组成部分:

  • 类名:Account
  • 属性(私有):
    • - name: String:账户持有者姓名。
    • - pin: String:账户访问密码(PIN)。
    • - id: int:账户的唯一标识符(ID)。
    • - balance: double:账户余额。
    • - count: static int:一个静态变量,用于记录已创建的账户总数,以便为每个新账户生成唯一的ID。
  • 方法(公有):
    • + Account(name: String, pin: String):构造函数,用于创建新账户。
    • + getName(): String:获取账户姓名。
    • + getId(): int:获取账户ID。
    • + getBalance(): double:获取账户余额。
    • + equalsPin(attempt: String): boolean:验证输入的PIN码是否正确。
    • + toString(): String:返回账户信息的字符串表示。
    • + deposit(amount: double): void:向账户存款。
    • + withdraw(amount: double): void:从账户取款。

设计决策解析

以下是关于上述设计的一些关键思考:

  • 属性为何私有(private)? 将实例字段设为私有是封装的核心。这确保了对象状态的完整性和安全性,所有对数据的修改都必须通过我们精心设计的方法(如deposit、withdraw)来进行,从而可以在方法内部添加验证逻辑,防止对象进入无效状态。
  • 为何需要ID和姓名两个字段? 姓名可能重复,不能作为唯一标识。ID由系统内部生成(如通过静态变量count递增),可以确保每个账户实例的唯一性。
  • 为何用double表示余额? 在本教学示例中,我们使用double是为了简化。但在真实金融应用中,应使用long类型以美分为单位存储金额,以避免浮点数精度问题(如电影《上班一条虫》中的情节)。
  • 为何没有getPin()方法? 出于安全考虑,密码(PIN)不应被直接获取。我们提供了equalsPin方法,允许外部代码验证密码是否正确,而不暴露密码本身。
  • 静态变量count的作用:它属于类本身,而非任何实例。用于跟踪创建的账户总数,并为每个新账户分配一个递增的、唯一的ID。

实现账户类

现在,我们开始根据UML图实现Account类。一个好的实践是首先“存根化”所有方法。

步骤1:创建类框架和存根方法

我们首先创建类,声明所有属性,并为所有方法创建空实现(存根)。这有助于在添加复杂逻辑前确保语法正确。

public class Account {
    // 属性声明
    private static int count = 0;
    private String name;
    private String pin;
    private int id;
    private double balance;

    // 构造函数存根
    public Account(String name, String pin) { }

    // 方法存根
    public String getName() { return null; }
    public int getId() { return 0; }
    public double getBalance() { return 0.0; }
    public boolean equalsPin(String attempt) { return false; }
    public String toString() { return null; }
    public void deposit(double amount) { }
    public void withdraw(double amount) { }
}

编译这个存根类可以及早发现拼写错误等简单问题。

步骤2:实现构造函数和toString方法

构造函数负责初始化新对象的状态。toString方法对于调试和测试至关重要,它能以文本形式展示对象的当前状态。

public Account(String name, String pin) {
    this.name = name; // 设置账户姓名
    this.pin = pin;   // 设置账户PIN码
    this.balance = 0.0; // 初始余额为0
    this.id = ++count; // 递增静态计数,并赋值给当前账户ID
}

public String toString() {
    // 格式化输出账户信息
    return String.format("%s, account ID: %d, balance: $%.2f", name, id, balance);
}
  • this关键字用于区分实例变量和局部变量(参数)。
  • ++count是前置递增运算符,先将count加1,然后将其值赋给id。

步骤3:实现Getter方法和equalsPin

Getter方法很简单,直接返回对应的私有字段值。equalsPin方法使用字符串的equals方法进行比较。

public String getName() { return this.name; }
public int getId() { return this.id; }
public double getBalance() { return this.balance; }

public boolean equalsPin(String attempt) {
    // 比较输入的attempt与存储的pin是否一致
    return this.pin.equals(attempt);
}

步骤4:实现deposit和withdraw方法(初始版本)

我们首先实现一个基础版本,直接修改余额。

public void deposit(double amount) {
    this.balance += amount; // 存款:余额增加
}

public void withdraw(double amount) {
    this.balance -= amount; // 取款:余额减少
}

注意:这个初始实现存在明显问题,例如取款时未检查余额是否充足,存款时未检查金额是否为负数。我们将在测试后讨论如何改进。

单元测试:验证代码行为

为了确保我们的类按预期工作,我们创建一个单独的测试类AccountTester。单元测试允许我们独立地验证每个方法的功能。

测试类结构

public class AccountTester {
    public static void main(String[] args) {
        boolean testResult;

        testResult = testNew(); // 测试构造函数
        System.out.println("testNew: " + testResult);

        testResult = testEqualsPin(); // 测试PIN验证
        System.out.println("testEqualsPin: " + testResult);

        testResult = testDeposit(); // 测试存款
        System.out.println("testDeposit: " + testResult);

        testResult = testWithdraw(); // 测试取款
        System.out.println("testWithdraw: " + testResult);
    }

    // 各个测试方法(初始返回false)
    public static boolean testNew() { return false; }
    public static boolean testEqualsPin() { return false; }
    public static boolean testDeposit() { return false; }
    public static boolean testWithdraw() { return false; }
}

实现测试方法:以testNew和testDeposit为例

以下是testNew和testDeposit测试方法的实现示例:

public static boolean testNew() {
    boolean testerPass = false;
    // 创建两个账户实例
    Account acct1 = new Account("Joejoy", "0060");
    Account acct2 = new Account("Sue Susie", "1234");

    // 定义期望的toString输出
    String expected1 = "Joejoy, account ID: 1, balance: $0.00";
    String expected2 = "Sue Susie, account ID: 2, balance: $0.00";

    // 验证实际输出与期望是否匹配
    testerPass = expected1.equals(acct1.toString());
    testerPass = testerPass && expected2.equals(acct2.toString()); // 使用&&=复合赋值

    return testerPass;
}

public static boolean testDeposit() {
    boolean testerPass = false;
    Account acct1 = new Account("Test", "1111");

    // 第一次存款并测试
    acct1.deposit(100.00);
    double expected1 = 100.00;
    testerPass = (expected1 == acct1.getBalance());

    // 第二次存款并测试(验证余额是累加的)
    acct1.deposit(100.00);
    double expected2 = 200.00;
    testerPass = testerPass && (expected2 == acct1.getBalance()); // 复合赋值

    return testerPass;
}
  • 复合赋值运算符&&=:它用于将当前testerPass的值与新的测试结果进行逻辑与(AND)操作。这确保了必须所有测试条件都通过,最终结果才为true。

运行这些测试,我们可以验证构造函数、toString和deposit方法在当前实现下是否工作正常。对于withdraw方法,我们需要设计更全面的测试来暴露其缺陷(例如透支、负金额取款)。

总结与下节预告

本节课中我们一起学习了如何将一个UML设计转化为具体的Java类。我们实现了Account类,包括其属性、构造函数、访问器方法以及核心的deposit和withdraw方法。更重要的是,我们引入了单元测试的概念,并创建了AccountTester类来系统化地验证我们代码的正确性。

目前我们的deposit和withdraw方法还非常基础,缺乏必要的业务规则检查(例如防止透支、处理负值)。在下一节课中,我们将重点关注如何改进这些方法,通过添加条件逻辑来增强我们类的健壮性,并讨论如何通过测试来驱动这些改进。请大家提前思考:我们的当前实现可能被哪些“边界情况”或无效输入破坏?

023:ATM账户与异常处理

在本节课中,我们将学习如何完善一个ATM账户类,重点是使用异常处理来保护对象的状态,防止其进入无效状态。我们将通过实现存款和取款方法,并加入防御性检查,来确保账户数据的完整性。


账户类的回顾与状态保护

上一节我们介绍了如何设计一个Account类,并定义了其实例字段(如姓名、PIN码、ID和余额)。本节中,我们来看看如何通过方法控制对这些字段的修改,以确保对象始终处于有效状态。

实例字段被设为私有(private),这意味着外部代码不能直接读取或修改它们。我们通过公共的“getter”方法(如getName())来提供读取访问。然而,我们仍然没有提供直接的写入访问。这是因为我们使用基础数据类型(如int、double、String)来表示对象的特性,而这些类型允许的值范围可能比我们模型所要求的有效范围更广。

例如,账户的balance(余额)理论上可以是任何double数值,但对于一个真实的ATM账户,余额不应为负数。这就是“合法值”(技术上允许)与“有效值”(符合业务逻辑)的区别。我们的目标是确保对象的状态(即所有实例字段值的集合)始终有效。


实现存款与取款方法

我们为Account类定义了deposit(存款)和withdraw(取款)方法。这些方法是改变余额状态的主要途径。

最初的简单实现可能如下:

public void deposit(double amount) {
    balance = balance + amount;
}

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/caltech-cs158-sw-dsn-dev/img/e8cce61e2a25e12f97838016387638a0_2.png)

![](https://github.com/OpenDocCN/cs-notes-zh/raw/master/docs/caltech-cs158-sw-dsn-dev/img/e8cce61e2a25e12f97838016387638a0_4.png)

public void withdraw(double amount) {
    balance = balance - amount;
}

然而,这种方法存在风险。如果amount参数为负数,存款操作会减少余额,而取款操作反而会增加余额,这违背了业务逻辑。同样,如果取款金额大于当前余额,会导致余额变为负数,这也是无效状态。


识别并防御无效状态

我们需要识别哪些输入值会导致无效状态,并在方法中主动检查这些“异常情况”。

对于deposit方法:

  • 无效情况:存款金额 amount < 0。
  • 有效情况:存款金额 amount >= 0。

对于withdraw方法:

  • 无效情况1:取款金额 amount < 0。
  • 无效情况2:取款金额 amount > balance(当前余额)。
  • 有效情况:取款金额 0 <= amount <= balance。

一种初级的防御方式是忽略无效操作:

public void deposit(double amount) {
    if (amount < 0) {
        return; // 什么也不做,直接返回
    }
    balance = balance + amount;
}

但这种设计很糟糕,因为它静默失败。调用者不知道操作未执行,可能误以为操作成功,导致程序出现难以察觉的错误。


抛出异常:正确的错误报告机制

更好的设计是当检测到无效参数时,抛出异常。这能明确告知客户端代码其操作违反了规则。

在Java中,我们使用throw关键字抛出一个异常对象。throw的作用类似于return,但它将控制权交还给调用方时,传递的是一个异常对象,而不是普通返回值。

以下是改进后的deposit方法:

public void deposit(double amount) {
    if (amount < 0) {
        throw new IllegalArgumentException("存款金额必须大于或等于零。");
    }
    balance = balance + amount;
}
  • IllegalArgumentException 是Java标准库中的一个异常类,非常适合表示“参数不合法”的情况。
  • 在创建异常对象时,我们可以传入一个字符串消息,清晰地说明错误原因。

同样地,我们可以实现withdraw方法:

public void withdraw(double amount) {
    if (amount < 0 || amount > balance) {
        throw new IllegalArgumentException("取款金额必须大于等于零且不超过当前余额。");
    }
    balance = balance - amount;
}

在测试类中处理异常

当我们编写测试类来验证Account类的功能时,也需要测试这些异常情况。我们可以使用try-catch块来捕获预期会抛出的异常,并验证异常信息是否符合预期。

以下是测试存款无效操作的示例:

// 在测试方法中
boolean testPass = true;
String expectedMessage = "存款金额必须大于或等于零。";
String actualMessage = "";

try {
    account1.deposit(-20.0); // 预期会抛出异常
    testPass = false; // 如果没抛出异常,测试失败
} catch (IllegalArgumentException e) {
    actualMessage = e.getMessage(); // 获取异常信息
}
// 验证捕获到的异常信息是否与预期一致
testPass = testPass && expectedMessage.equals(actualMessage);

通过这种方式,我们的测试不仅覆盖了正常流程,也覆盖了错误处理流程,实现了更全面的代码验证。


总结与下节预告

本节课中我们一起学习了:

  1. 防御性编程的重要性:通过将字段设为私有,并通过公共方法控制状态变更,可以保护对象数据的有效性。
  2. 异常处理:使用throw关键字抛出IllegalArgumentException等异常,是报告无效操作、防止静默失败的标准做法。
  3. 全面的测试:在测试类中使用try-catch块来验证方法在无效输入下是否能正确抛出异常。

通过为Account类实现带有异常检查的deposit和withdraw方法,我们创建了一个更健壮、更可靠的软件组件。

在下一讲中,我们将开始设计一个新的类——Time(时间)类。我们将重复类似的设计过程:定义属性(时、分、秒)、规划方法(构造器、设置器、字符串表示),并思考类似的问题:对于setHour、setMinute和setSecond这些方法,哪些值是有效的?哪些会导致无效状态并需要抛出异常?请提前思考这些问题,我们将在下节课一起实现。

024:单元测试的时间类

概述

在本节课中,我们将学习如何应用面向对象设计原则来建模一个“时间”类。我们将从设计UML类图开始,逐步实现这个类,并采用测试驱动开发的方法,为每个方法编写单元测试,以确保代码的正确性和健壮性。


从UML设计到代码实现

上一节我们介绍了面向对象设计的基本概念。本节中,我们来看看如何为一个具体的“时间”对象设计UML图并实现它。

我们决定,Time类将包含三个核心属性:小时、分钟和秒。其UML类图设计如下:

+-------------------+
|      Time         |
+-------------------+
| - hour: int       |
| - minute: int     |
| - second: int     |
+-------------------+
| + Time()          |
| + setTime(...)    |
| + toString(): String|
| + toMeridian(): String|
| - setHour(...)    |
| - setMinute(...)  |
| - setSecond(...)  |
+-------------------+

基于这个设计,我们可以开始创建类的框架。

public class Time {
    private int hour;
    private int minute;
    private int second;

    // 公共方法(API)存根
    public void setTime(int hour, int minute, int second) {}
    public String toString() { return null; }
    public String toMeridian() { return null; }

    // 私有设置方法存根
    private void setHour(int hour) {}
    private void setMinute(int minute) {}
    private void setSecond(int second) {}
}

测试驱动开发简介

在深入实现每个方法之前,我们必须理解测试驱动开发的重要性。这种方法要求我们先编写测试代码,再实现功能,以确保每一步都符合预期。

我们将创建一个对应的测试类 TimeTester,其结构如下:

public class TimeTester {
    public static void main(String[] args) {
        testToString();
        testSetHour();
        testSetMinute();
        testSetSecond();
        testToMeridian();
    }

    private static void testToString() { /* 测试代码 */ }
    private static void testSetHour() { /* 测试代码 */ }
    private static void testSetMinute() { /* 测试代码 */ }
    private static void testSetSecond() { /* 测试代码 */ }
    private static void testToMeridian() { /* 测试代码 */ }
}

实现并测试 toString 方法

首先,我们实现 toString 方法,它将时间状态转换为“HH:MM:SS”格式的字符串。我们使用 String.format 来控制格式,确保分钟和秒总是两位数字。

public String toString() {
    return String.format("%d:%02d:%02d", hour, minute, second);
}

以下是测试该方法是否有效的代码:

private static void testToString() {
    String actual;
    String expected;
    Time t1 = new Time(); // 使用默认构造函数
    actual = t1.toString();
    expected = "0:00:00"; // 预期默认时间为 0:00:00
    boolean testPassed = expected.equals(actual);
    System.out.println("[testToString] Test 1: " + testPassed);
}

运行测试后,如果输出为 true,则证明方法实现正确。


实现并测试设置器方法

接下来,我们实现私有的设置器方法(如 setHour)和公共的 setTime 方法。关键在于验证输入值的合法性。

1. 实现 setHour 方法

小时的有效范围是 0 到 23。对于非法输入,我们抛出异常。

private void setHour(int hour) {
    if (hour < 0 || hour > 23) {
        throw new IllegalArgumentException("Hour must be between 0 and 23");
    }
    this.hour = hour;
}

公共的 setTime 方法则调用这些私有设置器:

public void setTime(int hour, int minute, int second) {
    setHour(hour);
    setMinute(minute);
    setSecond(second);
}

2. 测试 setHour 方法

我们需要测试常规情况和异常情况。

以下是测试代码示例:

private static void testSetHour() {
    String actual;
    String expected;
    boolean testResult;

    // 测试1:常规情况(设置小时为12)
    Time t1 = new Time();
    t1.setTime(12, 0, 0);
    actual = t1.toString();
    expected = "12:00:00";
    testResult = expected.equals(actual);
    System.out.println("[testSetHour] Test 1: " + testResult);

    // 测试2:异常情况(小时为 -1)
    try {
        t1.setTime(-1, 0, 0);
        System.out.println("[testSetHour] Test 2: false"); // 不应执行到此
    } catch (IllegalArgumentException e) {
        actual = e.getMessage();
        expected = "Hour must be between 0 and 23";
        testResult = expected.equals(actual);
        System.out.println("[testSetHour] Test 2: " + testResult);
    }

    // 测试3:异常情况(小时为 24)
    try {
        t1.setTime(24, 0, 0);
        System.out.println("[testSetHour] Test 3: false");
    } catch (IllegalArgumentException e) {
        actual = e.getMessage();
        expected = "Hour must be between 0 and 23";
        testResult = expected.equals(actual);
        System.out.println("[testSetHour] Test 3: " + testResult);
    }
}

我们以同样的模式实现并测试了 setMinute(范围 0-59)和 setSecond(范围 0-59)方法。


实现并测试 toMeridian 方法

最后,我们实现 toMeridian 方法,将时间转换为12小时制(AM/PM)格式。

转换逻辑如下:

  • 小时部分通过 hour % 12 计算,但需处理 0 和 12 的情况。
  • 通过判断 hour < 12 来决定是 “AM” 还是 “PM”。
public String toMeridian() {
    int displayHour = hour % 12;
    if (displayHour == 0) {
        displayHour = 12; // 将 0 或 12 显示为 12
    }
    String meridian = (hour < 12) ? "AM" : "PM";
    return String.format("%d:%02d:%02d %s", displayHour, minute, second, meridian);
}

测试该方法:

private static void testToMeridian() {
    String actual;
    String expected;
    boolean testResult;
    Time t1 = new Time();

    // 测试1:午夜 00:00:00 应显示为 12:00:00 AM
    t1.setTime(0, 0, 0);
    actual = t1.toMeridian();
    expected = "12:00:00 AM";
    testResult = expected.equals(actual);
    System.out.println("[testToMeridian] Test 1: " + testResult);

    // 测试2:晚上 23:00:00 应显示为 11:00:00 PM
    t1.setTime(23, 0, 0);
    actual = t1.toMeridian();
    expected = "11:00:00 PM";
    testResult = expected.equals(actual);
    System.out.println("[testToMeridian] Test 2: " + testResult);
}

总结

本节课中我们一起学习了如何完整地设计、实现并测试一个 Time 类。我们遵循了以下关键步骤:

  1. 设计:使用UML图规划类的属性和方法。
  2. 存根:创建类和方法框架。
  3. 测试驱动开发:为每个功能先编写测试用例。
  4. 实现与验证:逐步实现方法,并运行测试确保其正确性,同时处理了常规情况和异常情况。

通过这个过程,我们不仅构建了一个功能完善的类,还创建了完整的测试套件,这既是正确性的保证,也是给其他开发者使用的绝佳示例。下一讲,我们将探讨如何为这个类添加显式构造函数。

025:构造函数的时间类 🕐

在本节课中,我们将深入学习构造函数,特别是如何为之前创建的 Time 类设计和实现多个构造函数。我们将探讨构造函数重载、使用 this 关键字调用其他构造函数,以及如何通过构造函数进行数据验证。最后,我们还会为 Time 类添加一个实用的静态工厂方法,用于获取当前系统时间。


概述与回顾

上一节我们共同实现了一个 Time 类,它包含小时、分钟和秒三个私有属性,以及一系列用于设置和获取时间、格式化输出的公共方法。我们还创建了一个 TimeTester 类来验证每个方法的功能。

然而,我们注意到,目前创建 Time 实例时,只能使用默认构造函数(即 new Time()),这会将所有属性初始化为0。为了提供更大的灵活性,我们需要定义显式构造函数,允许在创建对象时就指定初始时间。


定义显式构造函数

构造函数是一种特殊的方法,用于在创建对象时初始化其状态。它的名称必须与类名完全相同,并且没有返回类型。

基本的三参数构造函数

首先,我们创建一个可以接收小时、分钟、秒三个参数的构造函数。

public Time(int hour, int minute, int second) {
    this.hour = hour;
    this.minute = minute;
    this.second = second;
}

但是,这个实现存在一个严重问题。 我们之前精心编写的 setHour、setMinute、setSecond 方法包含了数据验证逻辑(例如,检查小时是否在0-23之间)。在构造函数中直接赋值,绕过了这些验证,可能导致对象处于无效状态。

正确的做法是复用这些设置方法:

public Time(int hour, int minute, int second) {
    setTime(hour, minute, second); // 复用已有的设置方法,内部会调用验证逻辑
}

这样,任何无效的输入(如 25 小时)都会在构造函数中抛出 IllegalArgumentException,确保创建的对象从一开始就是有效的。


构造函数重载与 this() 调用

一旦我们定义了一个显式构造函数,Java 就不再提供默认的无参构造函数。这意味着之前的测试代码 new Time() 会编译失败。为了解决这个问题,并提供更多创建时间对象的选项,我们可以使用构造函数重载。

构造函数重载允许一个类拥有多个构造函数,只要它们的参数列表(参数类型、数量或顺序)不同即可。

我们可以创建一系列构造函数,为未提供的参数设置默认值(通常为0)。

// 三参数构造函数(最完整)
public Time(int hour, int minute, int second) {
    setTime(hour, minute, second);
}

// 两参数构造函数,秒默认为0
public Time(int hour, int minute) {
    this(hour, minute, 0); // 使用 this() 调用三参数构造函数
}

// 单参数构造函数,分钟和秒默认为0
public Time(int hour) {
    this(hour, 0, 0); // 使用 this() 调用三参数构造函数
}

// 无参构造函数,所有值默认为0(午夜)
public Time() {
    this(0, 0, 0); // 使用 this() 调用三参数构造函数
}

关键点: this(...) 语法用于在同一个类的另一个构造函数中调用当前类的其他构造函数。这有助于减少代码重复,并确保初始化逻辑集中在一个地方(这里是三参数构造函数)。


测试构造函数

定义了多个构造函数后,我们需要在 TimeTester 中验证它们都能正确工作。以下是测试的核心思路:

  1. 使用不同的参数组合创建 Time 对象。
  2. 调用其 toString() 方法获取实际字符串表示。
  3. 与预期的字符串进行比较。
  4. 对于无效输入,测试是否按预期抛出异常。

以下是测试代码示例:

public static void testConstructors() {
    // 测试无参构造函数
    Time t1 = new Time();
    String actual = t1.toString();
    String expected = “00:00:00”;
    boolean testResult = expected.equals(actual);
    System.out.printf(“Constructor (no args): %s%n”, testResult);

    // 测试单参数构造函数
    Time t2 = new Time(13);
    actual = t2.toString();
    expected = “13:00:00”;
    testResult = expected.equals(actual);
    System.out.printf(“Constructor (hour=13): %s%n”, testResult);

    // 测试两参数构造函数
    Time t3 = new Time(3, 33);
    actual = t3.toString();
    expected = “03:33:00”;
    testResult = expected.equals(actual);
    System.out.printf(“Constructor (3, 33): %s%n”, testResult);

    // 测试三参数构造函数
    Time t4 = new Time(12, 34, 56);
    actual = t4.toString();
    expected = “12:34:56”;
    testResult = expected.equals(actual);
    System.out.printf(“Constructor (12,34,56): %s%n”, testResult);

    // 测试无效输入应抛出异常
    try {
        Time t5 = new Time(99, 99, 99); // 无效值
        System.out.println(“Constructor (invalid): FAIL - Should have thrown exception.”);
    } catch (IllegalArgumentException e) {
        System.out.println(“Constructor (invalid): PASS - Exception caught as expected.”);
    }
}

运行这些测试,确保所有构造函数都按预期工作,并且验证逻辑生效。


扩展:接收字符串的构造函数

有时,时间信息是以字符串形式提供的(例如,从文件或用户输入中读取)。为了方便,我们可以添加一个接收字符串的构造函数。假设字符串格式与我们 toString() 的输出格式一致,即 “HH:MM:SS”。

实现思路:

  1. 使用 String.split(“:”) 方法,以冒号为分隔符将字符串分割成子字符串数组。
  2. 将子字符串(“HH”, “MM”, “SS”)使用 Integer.parseInt() 转换为整数。
  3. 使用已有的三参数构造函数来创建对象。
public Time(String timeString) {
    // 按冒号分割字符串
    String[] parts = timeString.split(“:”);
    final int HOUR_INDEX = 0;
    final int MINUTE_INDEX = 1;
    final int SECOND_INDEX = 2;

    // 将字符串部分解析为整数
    int hour = Integer.parseInt(parts[HOUR_INDEX]);
    int minute = Integer.parseInt(parts[MINUTE_INDEX]);
    int second = Integer.parseInt(parts[SECOND_INDEX]);

    // 使用已有的构造函数(会进行验证)
    this(hour, minute, second);
}

现在,我们可以这样创建对象:Time t = new Time(“14:30:15”);,这大大提升了类的易用性。


静态工厂方法:获取当前时间

Java 提供了 System.currentTimeMillis() 来获取自 Unix 纪元(1970年1月1日)以来的毫秒数,但这对于表示“当前时刻”并不直观。我们可以为 Time 类添加一个静态工厂方法,直接返回一个表示当前时间的 Time 对象。

静态工厂方法是一个 static 方法,它返回该类的一个实例。它的优势在于不需要先创建对象就能调用。

实现思路:

  1. 获取当前系统时间的毫秒表示。
  2. 使用 String.format 和特定的格式符将其格式化为 “HH:MM:SS” 字符串。
  3. 利用我们刚创建的字符串构造函数来生成 Time 对象。
public static Time getCurrentTime() {
    // 获取当前时间戳,并格式化为 HH:MM:SS 字符串
    long currentMillis = System.currentTimeMillis();
    String timeString = String.format(“%1$tH:%1$tM:%1$tS”, currentMillis);

    // 使用字符串构造函数创建 Time 实例
    Time now = new Time(timeString);
    return now;
}

现在,任何代码都可以通过 Time.getCurrentTime() 轻松获得一个表示“此刻”的 Time 对象,并可以使用其所有方法(如 toMeridian() 转换为12小时制)。

// 使用示例
Time now = Time.getCurrentTime();
System.out.println(“Current time (24h): ” + now);
System.out.println(“Current time (12h): ” + now.toMeridian());

总结

本节课中,我们一起深入探讨了构造函数:

  1. 显式构造函数的作用:用于在创建对象时进行初始化,并可执行关键的数据验证。
  2. 构造函数重载:通过提供不同参数列表的多个构造函数,为类的使用者提供灵活的初始化选项。
  3. this() 的用法:在一个构造函数中调用同类其他构造函数,避免代码重复,集中初始化逻辑。
  4. 字符串构造函数:增强了类的实用性,允许从符合格式的字符串直接创建对象。
  5. 静态工厂方法:提供了一种不通过 new 关键字来获取类实例的替代方式,常用于执行更复杂的对象创建逻辑(如 getCurrentTime)。

通过为 Time 类完善这些构造函数和方法,我们构建了一个健壮、灵活且实用的工具类。在下一讲中,我们将学习组合,并利用这个 Time 类作为基础组件,来构建更复杂的对象,例如一个闹钟或计时器。

026:组合与闹钟演示 🕰️

在本节课中,我们将要学习一个重要的面向对象编程概念:组合。我们将探讨如何利用已有的类来构建新的、更复杂的类,并通过创建一个闹钟应用来实践这一概念。

概述

到目前为止,我们主要学习了如何从基本数据类型(如字符串、整数)构建对象。然而,在构建更复杂的类时,有时使用其他类作为其属性会更有意义。这种关系被称为“拥有”关系,是组合的核心思想。本节课我们将通过设计一个闹钟类来深入理解组合,并完善我们的时间类以支持对象间的比较操作。

什么是组合?

组合是一种概念,它允许我们使用预先存在的对象来构建新的对象。

我们之前主要关注的是从基本数据类型构建对象。例如,当我们构建一个账户类时,我们使用了字符串来表示文本数据,使用了双精度浮点数来表示账户中的货币金额。这些都是在课程初期讨论的基本数据类型。

但很多时候,在构建一个类时,使用另一个类作为其属性之一是有意义的。这是完全可行的。我们的类可以拥有任意数量的实例字段,这些实例变量可以是任何数据类型。它不必只是基本数据类型,也可以是引用数据类型。我们已经见过字符串形式的引用数据类型,它甚至可以是用户定义的引用数据类型,例如我们构建的账户类、玩家类或坐标类。

当我们开始讨论使用另一个类来构建一个类时,特别是当那个类是我们新类的属性之一时,我们通常将这种关系称为“拥有”关系。这意味着我们的新类拥有一个由我们试图使用的其他类定义的属性。

让我们看一个更具体的例子。假设我们正在设计一个玩家类。在玩家类中,我们确定玩家在游戏世界中应该有一个坐标。但这个坐标不应该仅仅是两个数值X和Y,它本身就应该是一个对象,用于建模坐标是什么。

那么,使用另一个对象作为我们的实例属性有什么优势呢?复用性绝对是关键。它实际上有助于我们减少玩家类需要关注的问题。

当我们开始为玩家建模时,首先想到的是坐标可以用X和Y值表示。但一旦我们开始思考这个问题,我们就应该考虑下一步。坐标有有效或无效的状态。当我们说玩家应该有一个坐标时,我不应该深入思考这个问题。我应该把它当作一个对象,然后使用它。但如果我在玩家类内部展开坐标的概念,说它是X和Y,那么我还需要展开什么?我刚刚打开了潘多拉魔盒。现在,我必须在玩家类内部处理什么是有效坐标与无效坐标的考虑。问题是,在设计玩家类时,我是否应该承担这些考虑?答案是否定的。玩家类不应该负责知道什么是有效和无效的坐标。因为如果我在玩家类中处理了这些逻辑,然后我去设计怪物类,并决定怪物也需要一个坐标,我就必须在怪物类中再次展开所有坐标逻辑。实际上,任何需要坐标的东西现在都必须负责检查坐标的有效性。这些都不应该是玩家、怪物或物品等类的职责。事实上,你会开始得到大量重复的知识和检查,违反了DRY原则。

因此,将这些逻辑封装起来是有意义的。封装意味着隐藏逻辑,将这些职责从玩家和怪物等类中抽离出来,放入一个坐标类中,让它负责维护X坐标、Y坐标以及检查其是否有效。然后,其他所有类都可以只拥有一个坐标实例,而无需担心任何细节,它们只需要知道“我有一个坐标”。

这就是动机所在。玩家拥有一个坐标,坐标本身不是基本类型,而是我们建模的一个事物。我们花费了大量精力思考它的实例字段以及我们可以如何改变它,这可能导致有效状态,也可能导致无效状态,然后我们进行检查和保护。一旦我们创建了一个我们对其有信心的坐标对象,我们就可以在玩家、怪物、物品中使用它。现在,这些类都不需要关心它是如何工作的,它们只知道“我有一个坐标”。如果玩家试图违反坐标的规则,坐标就会向玩家抛出异常。这样我们就有了一个健壮的软件生态系统,没有脆弱性,也不容易出现导致错误行为的大规模故障。

所以,“拥有”关系指的是组合。组合意味着我们可以使用更小、更简单的类来构建更复杂的类。在这个例子中,坐标是一个更小、更简单的类,而玩家类更高级,但它恰好需要一个坐标作为其建模的一部分。因此,我们说玩家拥有一个坐标,怪物拥有一个坐标,游戏世界中的物品拥有一个坐标。

“拥有”关系的概念很重要,因为下一节课我将介绍继承的概念,即“是一个”关系。在单元三的测试中,肯定会有问题让你识别和区分“是一个”关系和“拥有”关系。

从时间类到闹钟类

现在,让我们将组合的概念应用到我们一直在解决的问题上。在过去的几节课中,我们一直在设计一个完整、定义良好的时间类。我们终于到了认为它足够好,可以开始使用的阶段。我们将通过尝试将时间类用作一个组件类,放入一个组合类中来测试它。

组合类是由其他类或其他类的实例组成的类。

我们已经介绍了什么是“拥有”关系,以及为什么我们可以用其他对象作为其实例属性来构建对象。

设计我们类的一个美妙之处在于,一旦它被设计成可以实例化和使用,你就可以开始用它构建各种东西。例如,我们现在可以使用时间类来构建一个秒表或一个闹钟。在今天的讲座中,我只构建一个,但秒表和闹钟之间的功能区别是什么?闹钟在某个时间点会以警报结束,而秒表只在你决定时结束,并能够给出两者之间的时间差。闹钟是你设置一个警报时间,当到达那个时间时,它会发出哔哔声提醒你。两者都至关重要,它们都依赖于时间作为其下的基本模型。

所以,在今天的课上,我想设计一个闹钟。

设计闹钟类

在开始编码之前,我将按照传统设计我的UML类图。它由三行组成:第一行是类的名称,让我知道我在建模什么;第二行是这个特定类的属性;第三行是方法。

对于闹钟,你可能需要建模两个东西:当前时间和警报时间。这里我只列了一个,因为我要“作弊”:我将从时间类获取当前时间,因为我们创建了那个静态方法。但如果我想让它更通用,你可能会有类似“now”的属性,它也代表一个时间元素,这样闹钟总是知道当前时间是什么,以及警报时间是什么。但我要利用我总能从时间类获取当前时间这一事实,因为这是我们定义它的方式。这意味着在任何时候,我只需要知道我要在什么时间发出警报。

我们需要从闹钟中获得的东西包括:一个构造函数、设置警报的能力(可能有两种方式:传递一个时间对象,或者传递一个字符串,因为时间对象的构造函数之一允许我们传入字符串)、检查当前是否是警报时间(真或假,即是否该叫醒了),以及为了测试,我将创建一个主方法来实际运行我的闹钟,这样我们就可以看到如果它是一个应用程序会是什么样子。

实现闹钟类

让我们开始搭建闹钟类。

首先,定义类并创建实例变量:一个私有时间类型变量 alarm。

然后,创建方法存根:一个无参数的构造函数、两个 setAlarm 方法(一个接收时间对象,一个接收字符串)、一个返回布尔值的 isAlarmTime 方法,以及一个 main 方法。

在构造函数中,我们将 alarm 初始化为 null,这样新创建的闹钟没有设置警报,用户必须手动设置。

在接收时间对象的 setAlarm 方法中,我们直接将传入的时间对象赋值给 alarm。这就是组合在行动中的体现:我们花费了所有时间设计时间类,现在在这里将其设置到我们的组合类——闹钟类中。

在接收字符串的 setAlarm 方法中,我们使用该字符串创建一个新的时间对象,然后将其保存到 alarm 实例变量中。这里有一个问题:这个字符串可能不代表一个有效的时间字符串。但幸运的是,我们已经在时间类中设计了异常处理。闹钟类不需要担心什么是安全的,它只是将字符串传递给时间类,并说“尝试用这个构建时间”。如果时间类无法构建,由于我们已经设计了时间类来检查有效性,它会向这个方法抛出一个异常,然后这个方法会立即将该异常抛出。将所有这些异常处理放在时间类中的美妙之处在于,现在每个在其上构建的类都不必担心什么是有效的时间字符串或有效的时间管理器,它只是盲目地尝试。如果不起作用,它会抛出你已经设计好的异常。这再次证明了使用基本类构建然后在其上构建的好处,因为你得到了这种级联的骨牌效应。这意味着我在闹钟中的实现要简单得多,我不必像在设计底层时间类时那样做所有的考虑。

接下来,实现 isAlarmTime 方法。如何知道是否是警报时间?我可以获取当前时间,也可以获取警报时间。如何用这两个时间实例来做出有意义的决定?我们需要能够比较两个时间实例。回顾我们设计的时间类,除非我们在其中定义这些操作,否则它们不存在。关系运算符、相等运算符只适用于基本数据类型,因为它们在JVM中预定义。对于其他一切,它取决于开发人员来定义相等意味着什么,或者比较一个实例与另一个实例意味着什么。我们以为我们设计了一个非常好的时间类,它建模了小时、分钟、秒,有一组很好的构造函数,允许我们以多种方式构建时间实例,有能力在时间实例中设置时间,并能够以两种不同的方式将时间表示为字符串。但我们没有添加任何实际比较时间的功能。所以,我们实际上缺少一些方法。开始构建软件的一个美妙之处在于,当你看到这些可能存在于我们开始构建的基本组件类中的漏洞时。你真的需要深入思考这些类将如何被使用,并思考应该允许对它执行什么样的操作。

因此,我实际上想在这个类中扩展我的时间类,赋予它闹钟需要执行其任务的功能,因为我们可以创建两个不同的时间,但无法将它们相互关联。我们希望能够开始一起处理时间实例以获得有意义的结果,找出两个时间是否相等,或者一个时间是否大于另一个时间。

完善时间类:相等与比较

这给我们带来了缺失的方法:equals 方法和 compareTo 方法应该被包含在时间类中,以及它们意味着什么。

首先,equals 方法:对于时间来说,相等意味着什么?每个时间实例的状态由三部分组成:小时、分钟、秒。如果我想说时间实例一等于时间实例二,我在评估什么?由于我必须决定相等意味着什么,那么在比较两个时间实例时,什么对评估相等很重要?所有属性都必须相等。确定相等性是在类的设计步骤中必须做的事情,你必须选择哪些属性对于区分两个不同的实例是关键的。

equals 方法是一个我们实际继承的方法,有一种特定的写法。它接收一个 Object 类型的参数,因为 Object 是Java中所有引用类型中最通用的。首先检查传入的对象是否是时间实例,然后将其转换为时间对象,接着比较小时、分钟和秒是否全部相等。为了访问另一个时间实例的数据,我们需要获取方法。获取方法不仅对其他对象访问类内的实例变量有用,对于同一类的其他实例访问另一个实例的数据也至关重要,特别是当我们开始定义像相等操作或比较操作这样的关键方法时。

其次,compareTo 方法:这相当于关系运算符(大于、小于、等于)。比较方法通常返回一个整数值。如果两个值相同,则返回0;如果当前值小于另一个值,则返回负值(如-1);如果当前值大于另一个值,则返回正值(如1)。这样,我们就可以对时间实例进行排序。

实现策略:由于时间实例内的所有数据本质上都是整数,我们可以将小时、分钟、秒连接成一个大整数,然后使用基本的关系运算符进行比较。这样,我们就可以判断一个时间是否在另一个时间之前或之后。

创建这个方法的一个好处是,如果我现在使用我们在第二单元学过的数组类来排序时间实例,我们现在已经定义了一种比较方式。compareTo 是Java在可比较事物中寻找的内置方法,所以现在我们可以开始排序时间实例了。

现在,我们有了一个功能更丰富的时间类:我们不仅可以构建时间实例,还可以请求每个时间属性的状态,可以评估一个时间实例是否等于另一个时间实例,还可以比较一个时间实例是在另一个之前还是之后。

完成闹钟逻辑

回到我们的闹钟实例,我们之前在这里卡住了。在 isAlarmTime 方法中,我们可以这样思考:从时间类获取当前时间,然后将其与警报时间进行比较。如果当前时间大于或等于警报时间,则应该唤醒。

因此,我们可以创建一个布尔局部变量 isWakeUp,获取当前时间并与警报时间比较。如果结果大于或等于0(根据我们的设计,compareTo 返回0表示相等,正数表示当前时间晚于警报时间),则将 isWakeUp 设置为真。

现在我们能做到这一点,是因为我们已经实现了开始关联时间实例的能力。

构建闹钟应用

让我们在 main 方法中实际构建这个应用。你会看到我们的 main 方法将非常小,因为这么多工作都被编码到我们的基本时间类中了。

在 main 方法中,我们将创建一个新的闹钟实例,设置警报(例如,设置为“12:15”),然后运行一个 while 循环,不断检查是否是警报时间。当 isAlarmTime 返回真时,我们退出循环并打印“Wake up!”。

运行这个程序,当系统时间到达12:15:01时,它就会输出“Wake up!”。如果我们再次运行它,由于已经过了12:15,它会立即输出。我们可以扩展这个应用,例如在唤醒后让闹钟持续响铃,直到用户提供某种输入。

总结

本节课我们一起学习了组合的概念。我们看到了使用更简单的对象构建更复杂对象的价值,同时也看到了为什么我们希望严格测试简单对象,以便它们能够扩展而不增加太多复杂性。我们通过设计一个闹钟类来实践组合,并完善了时间类以支持对象间的比较操作。

下一节课,我们将进入继承的学习,然后是接下来的多态、抽象类和接口。希望你们都能看到基于我们过去三节课设计的时间类,实际上可以制作出一个真正的闹钟应用程序的潜力。

027:继承与多态

在本节课中,我们将要学习面向对象编程中两个核心概念:继承与多态。我们将探讨如何通过继承来复用代码、建立类之间的“是一个”关系,以及如何利用多态来编写更灵活、可扩展的程序。

继承与“是一个”关系

上一节我们介绍了组合,它是一种通过“有一个”关系来构建复杂对象的方法。本节中,我们来看看另一种构建新类的方法:继承。

继承与组合不同,它建立的是类之间的“是一个”关系。这意味着,如果一个类继承自另一个类,那么子类的实例也可以被看作是父类的一个实例。

在Java中,我们使用 extends 关键字来实现继承。当一个类继承另一个类时,它会自动获得父类的所有非私有字段和方法。

以下是继承的一个基本示例,我们从一个一维点类开始构建:

public class Point1D {
    private double x;

    public Point1D(double x) {
        this.x = x;
    }

    public double getX() { return x; }
    public void setX(double x) { this.x = x; }

    public double distance(Point1D other) {
        return Math.sqrt(Math.pow(this.x - other.getX(), 2));
    }

    public String toString() {
        return "(" + x + ")";
    }
}

扩展类:从一维点到多维点

现在,假设我们需要一个二维点。我们可以从头开始编写,但注意到二维点“是一个”一维点,只是多了一个Y坐标。使用继承,我们可以复用 Point1D 的代码。

public class Point2D extends Point1D {
    private double y;

    public Point2D(double x, double y) {
        super(x); // 调用父类构造函数
        this.y = y;
    }

    public double getY() { return y; }
    public void setY(double y) { this.y = y; }

    // 重写 toString 方法
    @Override
    public String toString() {
        return "(" + getX() + ", " + y + ")";
    }

    // 重载 distance 方法以处理二维点
    public double distance(Point2D other) {
        return Math.sqrt(Math.pow(getX() - other.getX(), 2) + Math.pow(this.y - other.getY(), 2));
    }
}

关键点:

  • super(x):super 关键字用于调用父类的构造函数。由于 Point1D 没有无参构造函数,我们必须在 Point2D 构造函数的第一行调用 super 并传入 x 值。
  • @Override:注解表明我们正在重写父类的方法。重写要求方法名和参数列表完全相同。
  • 重载 vs. 重写:distance(Point2D other) 是重载,因为它与父类的 distance(Point1D other) 参数类型不同。重写是替换,重载是添加。

我们可以继续此模式来创建三维点:

public class Point3D extends Point2D {
    private double z;

    public Point3D(double x, double y, double z) {
        super(x, y); // 调用 Point2D 的构造函数
        this.z = z;
    }

    public double getZ() { return z; }
    public void setZ(double z) { this.z = z; }

    @Override
    public String toString() {
        return "(" + getX() + ", " + getY() + ", " + z + ")";
    }

    // 重载 distance 方法以处理三维点
    public double distance(Point3D other) {
        return Math.sqrt(Math.pow(getX() - other.getX(), 2) + Math.pow(getY() - other.getY(), 2) + Math.pow(this.z - other.getZ(), 2));
    }
}

通过继承,我们极大地减少了代码重复。对父类的任何修改都会自动传播到所有子类。

访问控制:private, protected 与 super

在继承中,访问控制至关重要。

  • private:子类无法直接访问父类的私有字段。它们必须通过父类提供的公共getter和setter方法。这确保了父类状态的封装和有效性。
  • protected:标记为 protected 的字段或方法可以被同一个包内的类以及任何子类访问。虽然这提供了便利,但可能破坏封装性,需谨慎使用。
  • super:除了调用父类构造函数,super 关键字还可以用于调用被重写的父类方法。
public class Parent {
    protected String value = “Parent”;
    public String toString() {
        return value;
    }
}

public class Child extends Parent {
    public Child() {
        value = “Child”; // 可以访问 protected 字段
    }
    @Override
    public String toString() {
        // 使用 super 调用父类的 toString 方法
        return super.toString() + “ (from Child class)”;
    }
}

Java的单继承与Object类

Java只支持单继承,即一个类只能直接继承自一个父类。这形成了一个清晰的类层次结构。

在这个层次结构的顶端是 Object 类。在Java中,所有类都直接或间接继承自 Object 类。如果你没有显式使用 extends,你的类就隐式继承 Object。

这就是为什么你的类自动拥有如 toString(), equals(Object obj), getClass() 等方法的原因——它们都定义在 Object 类中。

以下代码演示了“万物皆对象”:

Object[] objects = new Object[] {
    new Object(),
    new Point1D(5),
    “Hello”, // String 对象
    42,      // 自动装箱为 Integer 对象
    true     // 自动装箱为 Boolean 对象
};
for (Object obj : objects) {
    System.out.println(obj.toString());
}

多态性

多态(Polymorphism)意为“多种形态”。在面向对象编程中,它指的是父类引用可以指向子类对象,并且通过这个父类引用调用方法时,实际执行的是子类重写后的方法。

这是继承最强大的特性之一。它允许我们编写更通用、更灵活的代码。

考虑之前的点类例子:

Point1D myPoint = new Point3D(1, 2, 3);
System.out.println(myPoint.getX()); // 可以,因为 Point1D 定义了 getX()
// myPoint.getZ(); // 错误!编译时类型是 Point1D,看不到 getZ() 方法
System.out.println(myPoint.toString()); // 输出: (1.0, 2.0, 3.0)

虽然 myPoint 的编译时类型是 Point1D,但它实际指向一个 Point3D 对象。当调用 toString() 时,Java虚拟机会找到对象实际类型(Point3D)的重写方法并执行。这就是动态方法绑定或运行时多态。

一个更实际的例子:游戏角色系统

让我们设计一个简单的游戏角色系统来展示继承和多态在实际中的应用。

首先,我们识别出英雄和怪物共享的属性和行为,创建一个基类:

public class GameCharacter {
    private int hitPoints;
    private int attackPower;

    public GameCharacter(int hp, int ap) {
        this.hitPoints = hp;
        this.attackPower = ap;
    }

    public void takeDamage(int damage) {
        hitPoints -= damage;
    }
    public int getHitPoints() { return hitPoints; }
    public int getAttackPower() { return attackPower; }
    public boolean isAlive() { return hitPoints > 0; }

    public String toString() {
        return getClass().getSimpleName() + “ [HP=“ + hitPoints + “]”;
    }
}

然后,我们创建特定的子类:

public class Monster extends GameCharacter {
    private int xpValue;

    public Monster() {
        super(80, 8); // 调用父类构造函数
        this.xpValue = 25;
    }

    public void attack(GameCharacter target) {
        System.out.println(“Monster attacks for “ + getAttackPower() + “ damage!”);
        target.takeDamage(getAttackPower());
    }
    // ... getter for xpValue
}

public class Hero extends GameCharacter {
    private int magicPoints;
    private int level;

    public Hero() {
        super(100, 10);
        this.magicPoints = 6;
        this.level = 1;
    }

    public void meleeAttack(GameCharacter target) {
        // 英雄攻击是随机的
        int damage = (int)(Math.random() * getAttackPower()) + 1;
        System.out.println(“Hero attacks for “ + damage + “ damage!”);
        target.takeDamage(damage);
    }
}

利用多态,我们可以编写通用的游戏逻辑:

public class Game {
    public static void main(String[] args) {
        Hero hero = new Hero();
        Monster monster = new Monster();

        while (hero.isAlive() && monster.isAlive()) {
            hero.meleeAttack(monster);
            if (monster.isAlive()) {
                monster.attack(hero);
            }
        }
        System.out.println(“Game Over”);
        System.out.println(hero);
        System.out.println(monster);
    }
}

引入抽象类

现在,让我们考虑一个员工薪酬系统的设计。我们有不同类型的员工: salaried(月薪)、hourly(时薪)、commission(佣金)。

所有员工共享一些基本信息(姓名、地址等),但计算薪酬的方式 (getEarnings) 却完全不同。

一种不完美的做法是在基类 Employee 中提供一个空的 getEarnings 方法:

public class Employee {
    private String name;
    // ... 其他字段和构造函数
    public double getEarnings() {
        return 0.0; // 默认实现,没有实际意义
    }
}

然后子类重写这个方法。这允许我们创建 Employee 数组并统一调用 getEarnings():

Employee[] employees = {new SalariedEmployee(…), new HourlyEmployee(…)};
for (Employee e : employees) {
    System.out.println(e.getName() + “ earned: $” + e.getEarnings());
}

问题:如果程序员忘记在某个新员工子类(如 CommissionEmployee)中重写 getEarnings() 方法,程序仍会编译运行,但会错误地返回 0.0 薪酬,这是一个难以察觉的bug。

我们需要一种机制来强制子类提供 getEarnings() 的实现,同时又不允许直接实例化像 Employee 这样不完整的“概念”类。这就是 抽象类 和 抽象方法 要解决的问题。我们将在下一讲深入探讨。

总结

本节课中我们一起学习了面向对象编程的核心支柱之一:继承与多态。

  • 继承 通过 extends 关键字建立“是一个”关系,允许子类复用父类的代码,并添加或修改功能。
  • 方法重写 (@Override) 允许子类提供父类方法的新实现。
  • 方法重载 发生在同一类中,方法名相同但参数列表不同。
  • super 关键字用于调用父类的构造函数或方法。
  • Java采用单继承,所有类都继承自 Object 类。
  • 多态 允许父类引用指向子类对象,并在运行时调用正确的方法实现,这使代码更加通用和可扩展。
  • 我们看到了如何设计类层次结构(如游戏角色、员工系统),并初步了解了为何需要抽象类来完善设计。

理解这些概念是构建模块化、可维护和可扩展软件系统的关键。在下一讲,我们将完成继承主题,学习抽象类和接口。

028:抽象类与接口 🧩

在本节课中,我们将继续讨论多态性,并深入探讨几个与继承相关的关键概念的区别。我们将学习具体类与抽象类,以及接口与抽象类的不同。通过本讲,你将能够理解如何使用继承来构建基于接口和类的系统。


抽象类 vs. 具体类

上一讲我们开始探讨了为什么需要抽象类。本节中,我们将重新回顾并深入理解这个概念。

抽象类用于将一组相关的类组织在一起。我们使用 abstract 关键字来定义抽象类。策略是:当我们需要将一组相关的类分组,但又无法或不希望为某些方法提供具体实现时,就使用抽象类。

让我们通过一个实际的源代码示例来理解。

示例:构建员工支付系统

假设我们正在为一家咖啡馆构建一个支付系统。经理按薪水支付,一些工人按小时支付,还有一些根据佣金支付。我们将创建一个 Employee 类,它同时使用了组合(有一个日期)和继承(是员工的基类)。

首先,我们定义一个 Date 组件类,用于表示员工的出生日期和雇佣日期。这个类类似于我们之前学过的 Time 类。

public class Date {
    private int year;
    private int month;
    private int day;
    private static final int[] daysPerMonth = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

    public Date(int day, int month, int year) {
        setDate(day, month, year);
    }

    public void setDate(int day, int month, int year) {
        setYear(year);
        setMonth(month);
        setDay(day);
    }

    private void setYear(int year) {
        if (year < 1900) {
            throw new IllegalArgumentException("年份必须 >= 1900");
        }
        this.year = year;
    }

    private void setMonth(int month) {
        if (month <= 0 || month > 12) {
            throw new IllegalArgumentException("月份必须在 1-12 之间");
        }
        this.month = month;
    }

    private void setDay(int day) {
        if (day <= 0 || day > daysPerMonth[month]) {
            throw new IllegalArgumentException("日期无效");
        }
        this.day = day;
    }

    // Getter 方法...
    public String toString() {
        return String.format("%02d/%02d/%04d", day, month, year);
    }
}

接下来,我们创建基类 Employee。每个员工都有姓名、地址、出生日期和雇佣日期。

public class Employee {
    private String name;
    private String address;
    private Date birthDate;
    private Date hireDate;

    public Employee(String name, String address, Date birthDate, Date hireDate) {
        this.name = name;
        this.address = address;
        this.birthDate = birthDate;
        this.hireDate = hireDate;
    }

    public String getName() {
        return name;
    }

    public String toString() {
        return String.format("姓名: %s, 地址: %s, 出生日期: %s, 雇佣日期: %s",
                             name, address, birthDate, hireDate);
    }
}

继承层次结构:具体子类

现在,让我们构建继承层次结构。我们说 SalaryEmployee 是一种 Employee。

public class SalaryEmployee extends Employee {
    private double annualSalary;

    public SalaryEmployee(String name, String address, Date birthDate,
                          Date hireDate, double annualSalary) {
        super(name, address, birthDate, hireDate); // 调用父类构造函数
        this.annualSalary = annualSalary;
    }

    public double getEarnings() {
        // 假设每月发两次薪水
        return annualSalary / 12 / 2;
    }

    @Override
    public String toString() {
        return super.toString() + String.format(", 年薪: $%.2f", annualSalary);
    }
}

类似地,我们可以创建 HourlyEmployee 和 CommissionEmployee 类。它们都扩展自 Employee,并添加了自己特有的字段和方法(如 getEarnings)。


多态性的挑战与动机

在测试类中,我们希望将所有员工放入一个数组中,并统一处理他们的薪水。理想情况下,我们希望这样写:

Employee[] employees = {kim, jim, tim, sam}; // 不同类型的员工
for (Employee worker : employees) {
    System.out.println(worker.getName() + " 的薪水: $" + worker.getEarnings()); // 错误!
}

但这会编译错误,因为 Employee 类中没有 getEarnings 方法。我们只能在子类中访问它。

一个笨拙的解决方法是使用 instanceof 检查和向下转型:

for (Employee worker : employees) {
    if (worker instanceof HourlyEmployee) {
        HourlyEmployee hourly = (HourlyEmployee) worker;
        System.out.println(hourly.getName() + " 的薪水: $" + hourly.getEarnings());
    } else if (worker instanceof SalaryEmployee) {
        // ... 类似处理
    }
}

这种方法可行,但违反了 DRY(不要重复自己)原则,并且代码臃肿。我们想要更简洁的多态行为。


引入抽象类和方法

更好的解决方案是让 Employee 类拥有 getEarnings 方法,但不提供具体实现。这就是抽象方法的用武之地。

抽象方法声明在类中,但留空不定义。它强制所有非抽象的子类必须提供具体实现。

如果类中至少有一个抽象方法,那么该类本身必须声明为 abstract。

public abstract class Employee {
    // ... 其他字段和构造函数 ...

    // 抽象方法声明
    public abstract double getEarnings();
}

现在,Employee 变成了一个抽象类。抽象类不能被直接实例化。你只能创建其具体子类(如 SalaryEmployee)的实例。

子类必须实现(覆盖)所有继承的抽象方法,否则它们自己也必须声明为 abstract。

public class SalaryEmployee extends Employee {
    // ... 其他代码 ...

    @Override
    public double getEarnings() {
        return annualSalary / 12 / 2; // 必须提供实现
    }
}

这种设计的好处是:

  1. 编译时安全:如果忘记在某个子类(如 CommissionEmployee)中实现 getEarnings,编译器会报错,防止出现“零薪水”的运行时错误。
  2. 简洁的多态:现在我们可以优雅地遍历员工数组并调用 getEarnings。
Employee[] employees = {kim, jim, tim, sam}; // 所有子类实例
for (Employee worker : employees) {
    // 多态调用:实际执行的是子类中的 getEarnings
    System.out.println(worker.getName() + " 的薪水: $" + worker.getEarnings());
}

接口

抽象类解决了相关类之间的多态问题。但有时我们需要将完全不相关的类分组,让它们表现出某种共同行为。这时就需要接口。

接口类似于一个完全抽象的类。它只能包含抽象方法(和静态常量),不能有实例字段或具体方法。一个类可以实现多个接口,但只能继承一个类(单继承)。

示例:扩展支付系统

假设咖啡馆的支付系统现在还需要处理发票(如牛奶箱的采购),而不仅仅是员工工资。员工和发票除了“需要支付”外,没有其他共同点。

我们创建一个 Payable 接口来代表“可支付”这个属性。

public interface Payable {
    double getCost(); // 抽象方法,获取成本
}

现在,让 Invoice 类实现这个接口:

public class Invoice implements Payable {
    private double totalCost;
    private String idNumber;
    private String description;

    public Invoice(double cost, String id, String desc) {
        this.totalCost = cost;
        this.idNumber = id;
        this.description = desc;
    }

    @Override
    public double getCost() {
        return totalCost; // 实现接口方法
    }

    // ... toString 方法 ...
}

同时,我们也可以让 Employee 类实现 Payable 接口。对于员工来说,成本就是其收入。

public abstract class Employee implements Payable {
    // ... 其他代码 ...

    @Override
    public double getCost() {
        return getEarnings(); // 调用自身的抽象方法
    }
}

现在,我们可以将员工和发票统一视为 Payable 对象进行处理:

Payable[] payables = {kim, jim, tim, sam, milkInvoice}; // 员工和发票
double totalCost = 0.0;
for (Payable payable : payables) {
    System.out.println(payable); // 调用各自的 toString
    totalCost += payable.getCost(); // 多态调用 getCost
}
System.out.println("总支付成本: $" + totalCost);

抽象类 vs. 接口:如何选择?

以下是核心区别和选择策略:

  • 抽象类:

    • 用于建立 “是一个(is-a)” 关系,表示紧密相关的类族。
    • 可以包含具体方法、抽象方法、实例字段和构造函数。
    • 子类使用 extends 关键字继承。
    • Java 是单继承,一个类只能有一个父类。
  • 接口:

    • 用于定义 “具有某种能力(can-do)” 或契约,可以将完全不相关的类分组。
    • 只能包含抽象方法(和 static final 常量)。
    • 类使用 implements 关键字实现接口。
    • 一个类可以实现多个接口。

策略:

  • 如果需要为相关类提供公共基类,并可能包含一些共享的实现代码,使用抽象类。
  • 如果需要为可能不相关的类定义共同的行为契约,或者需要实现多重“类型”,使用接口。


设计思维:自顶向下 vs. 自底向上

在软件开发中,良好的设计通常采用自顶向下的方式:

  1. 自顶向下设计:从最高层的抽象(接口或抽象类)开始思考。先定义系统需要哪些行为和契约(API),然后再创建具体的实现类。这种方式更灵活,更符合面向接口编程的原则。

    • 例如:设计宠物模拟器时,先思考 Animal 的抽象行为(Movable, Eatable),再通过接口组合(Bird implements Movable, Flyable)来构建具体的 Penguin 类。
  2. 自底向上设计:从具体的类开始编写,发现重复代码后再提取公共部分形成父类或接口。这种方式在初期快速,但后期重构成本高,设计可能不够清晰。

鼓励大家在设计时,优先考虑自顶向下的方式,多使用接口来定义行为,这将使你的代码更灵活、更健壮、更易于维护。


总结 🎯

本节课中我们一起学习了:

  1. 具体类与抽象类:抽象类用于定义相关类的模板,可以包含抽象方法,不能直接实例化。
  2. 抽象方法:声明但不实现的方法,强制子类提供具体行为,是实现多态的关键。
  3. 接口:定义行为契约的完全抽象类型,允许类实现多个接口,用于将不相关的类分组。
  4. 多态性的实现:通过抽象类或接口作为引用类型,可以编写处理多种具体类型的通用代码。
  5. 设计原则:理解了何时使用抽象类(is-a关系,共享代码)与接口(can-do关系,定义契约),并介绍了自顶向下的设计思维。

掌握这些概念对于构建灵活、可扩展的面向对象系统至关重要。

posted @ 2026-03-29 09:40  布客飞龙I  阅读(74)  评论(0)    收藏  举报