解锁Java：从0到1的编程蜕变之路_java从0到1开发本地环境跑-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_22232065/article/details/148251853

为什么选择 Java

在编程语言的璀璨星空中，Java 无疑是一颗耀眼的巨星。自 1995 年诞生以来，它凭借着卓越的特性和强大的功能，在全球范围内拥有庞大的开发者群体，市场占有率长期稳居前列。无论是在企业级应用开发、移动应用开发，还是大数据处理、分布式系统构建等领域，Java 都发挥着举足轻重的作用。

从就业市场来看，Java 开发工程师的需求量一直居高不下。各大招聘平台上，Java 相关岗位如过江之鲫，涵盖互联网、金融、电商、医疗等众多热门行业。掌握 Java 技术，就意味着打开了通往高薪职业的大门，为个人职业发展提供了广阔的空间。

开启 Java 之旅：环境搭建

（一）安装 JDK

JDK（Java Development Kit）是 Java 开发的核心工具包，如同建筑工人手中的各类工具，是 Java 开发不可或缺的基础。它包含了 Java 编译器（javac）、Java 运行工具（java）、Java 文档生成工具（javadoc）等一系列开发工具，以及 Java 运行时环境（JRE）和 Java 虚拟机（JVM）。

首先，我们需要从 Oracle 官网（https://www.oracl e.com /java /tech nolog ies/d ownlo ads/ ）或 OpenJDK 社区（https://jdk.java .net/ ）下载适合自己操作系统的 JDK 安装包。

Windows 系统：在官网下载页面找到 Windows 版本的 JDK 安装文件（通常为.exe 后缀），下载完成后，双击安装文件，按照安装向导的提示逐步进行安装。在安装过程中，可以选择安装路径，建议选择全英文路径，避免因路径中包含中文或特殊字符导致后续问题。安装完成后，需要配置环境变量。右键点击 “此电脑”，选择 “属性”，在弹出的窗口中点击 “高级系统设置”，再点击 “环境变量”。在系统变量中，新建一个变量名为 “JAVA_HOME”，变量值为 JDK 的安装路径（例如：C:\Program Files\Java\jdk11.0.11）；然后找到 “Path” 变量，点击 “编辑”，在变量值的开头或结尾添加 “% JAVA_HOME%\bin”，保存设置。最后，打开命令提示符（Win + R，输入 “cmd” 回车），输入 “java -version”，如果显示 JDK 的版本信息，说明安装和配置成功。

macOS/Linux 系统：在官网下载对应系统的 JDK 安装包（macOS 通常为.dmg 后缀，Linux 通常为.tar.gz 后缀）。对于 macOS，下载完成后，双击.dmg 文件，将 JDK 图标拖动到 “应用程序” 文件夹进行安装。对于 Linux，使用命令行解压下载的.tar.gz 文件（例如：tar -zxvf jdk-11.0.11_linux-x64_bin.tar.gz），然后将解压后的文件夹移动到合适的位置（如 /usr/local/jdk11）。接着配置环境变量，对于 macOS，编辑～/.bash_profile 或～/.zshrc 文件（根据使用的终端类型），添加 “export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-11.0.11.jdk/Contents/Home” 和 “export PATH=JAVA_HOME/bin:PATH”；对于 Linux，编辑 /etc/profile 或～/.bashrc 文件，添加 “export JAVA_HOME=/usr/local/jdk11” 和 “export PATH=JAVA_HOME/bin:PATH”。保存文件后，执行 “source ~/.bash_profile”（macOS）或 “source /etc/profile”（Linux）使设置生效。同样，在终端输入 “java -version” 验证安装是否成功。

（二）安装 IDE

安装好 JDK 后，我们还需要一个趁手的集成开发环境（IDE）来编写和管理 Java 代码。IntelliJ IDEA 是一款功能强大、深受 Java 开发者喜爱的 IDE，它提供了智能代码补全、代码分析、调试工具等丰富的功能，能大大提高开发效率。

我们可以从 JetBrains 官网（https://www.jetbra ins .com/id ea/do wnloa d/ ）下载 IntelliJ IDEA。官网提供了 Ultimate（旗舰版）和 Community（社区版）两个版本，旗舰版功能全面，但需要付费购买；社区版免费开源，适合初学者和个人开发者使用，这里我们以社区版为例进行安装介绍。

下载完成后，运行安装程序。在安装向导中，首先选择安装路径，同样建议选择全英文路径。接着可以根据个人需求选择一些附加选项，如创建桌面快捷方式、关联.java 文件等。完成设置后，点击 “Install” 开始安装。安装完成后，打开 IntelliJ IDEA。第一次启动时，会提示进行一些初始设置，如选择主题、导入设置等，可以根据个人喜好进行选择。

接下来创建一个新项目，点击 “Create New Project”，在弹出的窗口中，左侧选择 “Java”，右侧选择项目使用的 JDK 版本（如果没有显示已安装的 JDK，点击 “New” 手动指定 JDK 的安装路径），然后点击 “Next”。在下一步中，输入项目名称和项目存储路径，最后点击 “Finish”，一个全新的 Java 项目就创建好了，我们可以在这个项目中开始编写 Java 代码啦。

初窥门径：第一个 Java 程序

环境搭建完成后，就像是准备好了绘画工具，现在我们可以开始绘制 Java 编程世界的第一笔 —— 编写并运行第一个 Java 程序。按照惯例，我们从经典的 “Hello, World!” 程序入手。

（一）创建 Java 类文件

在 IntelliJ IDEA 的项目导航栏中，右键点击项目的 “src” 文件夹（src 是 source 的缩写，通常用于存放源代码），在弹出的菜单中选择 “New” -> “Java Class”（也可以使用快捷键 Alt + Insert，然后选择 “Java Class”）。在弹出的对话框中，输入类名，这里我们输入 “HelloWorld”，然后点击 “OK”。需要注意的是，Java 中类名的命名规则遵循驼峰命名法，即首字母大写，后续单词首字母也大写，并且类名需与文件名一致，这是 Java 的规范要求，因为在 Java 中，每个编译单元（即一个 Java 文件）只能有一个 public 类，且该类的名称必须与文件名称相同（不包括文件后缀.java）。

（二）定义主方法

在刚刚创建的 “HelloWorld” 类中，输入以下代码定义主方法：

public class HelloWorld {

public static void main(String[] args) {

// 这里开始编写主方法的代码

}

主方法（main 方法）是 Java 程序的入口点，当我们运行一个 Java 程序时，JVM（Java 虚拟机）会首先寻找并执行这个 main 方法。它的方法签名（即方法的定义形式）是固定的，必须是 “public static void main (String [] args)” 。其中，“public” 表示这个方法是公共的，任何其他类都可以访问它；“static” 表示这是一个静态方法，属于类本身，而不是类的实例，这样 JVM 在启动程序时无需创建类的实例就可以直接调用该方法；“void” 表示该方法没有返回值；“main” 是方法名，这是 JVM 识别程序入口的特定名称；“String [] args” 是一个字符串数组参数，用于接收命令行传入的参数，在我们这个简单的示例中暂时用不到，但在实际开发中，通过这个参数可以实现程序在启动时接收外部输入的功能。

（三）编写输出语句并运行

在主方法中，编写如下代码用于输出 “Hello, World!”：

public class HelloWorld {

public static void main(String[] args) {

System.out.println("Hello, World!");

}

“System.out.println ()” 是 Java 中用于在控制台输出信息的常用方法，“System.out” 代表标准输出流，“println” 是 “print line” 的缩写，意思是输出内容后换行。如果使用 “System.out.print ()” 方法，则输出内容后不会换行。

现在，我们已经完成了第一个 Java 程序的编写，接下来可以运行它来见证奇迹的时刻。在 IntelliJ IDEA 中，有多种运行程序的方式：可以点击工具栏上的绿色三角形 “Run” 按钮；也可以使用快捷键 Ctrl + Shift + F10（Windows/Linux 系统）或 Cmd + Shift + R（Mac 系统）；还可以在代码编辑区域右键点击，选择 “Run 'HelloWorld.main ()'” 。运行程序后，在 IDEA 下方的控制台窗口中，将会看到输出的 “Hello, World!”，这是 Java 程序与我们的第一次友好互动，标志着我们成功迈出了 Java 编程的第一步。

夯实基础：Java 基础语法

万丈高楼平地起，扎实的基础是成为 Java 编程高手的关键。接下来，我们深入学习 Java 的基础语法，就像学习一门语言的字母和语法规则一样，这是我们构建复杂程序的基石。

（一）数据类型与变量

基本数据类型：Java 的基本数据类型如同建筑中的基础材料，各自有着独特的用途和特点。

byte：字节型，占用 1 个字节（8 位），取值范围为 - 128 到 127 ，常用于存储小范围的整数，例如表示文件流中的字节数据，示例代码：byte b = 10;

short：短整型，占用 2 个字节（16 位），取值范围为 - 32768 到 32767 ，适用于内存空间有限且数值范围合适的场景，示例代码：short s = 1000;

int：整型，占用 4 个字节（32 位），取值范围为 - 2147483648 到 2147483647 ，是最常用的整数类型，用于一般的整数运算和存储，示例代码：int num = 520;

long：长整型，占用 8 个字节（64 位），取值范围为 - 9223372036854775808 到 9223372036854775807 ，用于存储较大范围的整数，在表示时间戳等场景中常用，示例代码：long l = 1234567890123L; （注意 long 类型的常量需要在数字后面加上大写或小写的 L 后缀）

float：单精度浮点型，占用 4 个字节（32 位），取值范围为负数范围：-3.402823E38 到 - 1.401298E-45，正数范围：1.401298E-45 到 3.402823E38 ，有效小数点位数为 6 - 7 位，用于存储精度要求不高的浮点数，示例代码：float f = 3.14f; （注意 float 类型的常量需要在数字后面加上小写的 f 后缀）

double：双精度浮点型，占用 8 个字节（64 位），取值范围为负数范围：-1.79769313486232E308 到 - 4.94065645841247E-324，正数范围：4.94065645841247E-324 到 1.79769313486232E308 ，是最常用的浮点数类型，用于需要更高精度的浮点运算，示例代码：double d = 3.141592653589793;

boolean：布尔型，占用 1 个字节（虽然实际存储时可能不占完整的一个字节，但逻辑上可以这样理解），取值只有 true（真）和 false（假），用于判断条件，示例代码：boolean flag = true;

char：字符型，占用 2 个字节（16 位），取值范围为 0 到 65535 ，采用 Unicode 编码，可以表示世界上大多数语言的字符，示例代码：char c = 'A';

引用数据类型：如果说基本数据类型是简单的零件，那么引用数据类型就是由这些零件组装而成的复杂组件。引用数据类型包括类、接口和数组等。类是对现实世界中事物的抽象，例如我们可以定义一个 “Person” 类来表示人，其中包含姓名、年龄等属性和说话、走路等方法；接口则定义了一组方法的签名，但没有实现，类可以实现接口来表明它具有某些特定的行为；数组是用于存储多个相同类型元素的容器。引用数据类型的变量存储的是对象的引用（内存地址），而不是对象本身，就像我们通过门牌号来找到房子，门牌号就是引用，房子就是对象。后续我们会深入学习类、接口和数组的详细用法。

变量声明与初始化：变量是程序中用于存储数据的容器，就像一个个小盒子，可以存放不同类型的数据。在 Java 中，声明变量时需要指定变量的类型，然后可以对其进行初始化。例如：

int age; // 声明一个int类型的变量age

age = 18; // 对变量age进行初始化

double salary = 5000.5; // 声明并初始化一个double类型的变量salary

boolean isStudent = true; // 声明并初始化一个boolean类型的变量isStudent

char gender = 'M'; // 声明并初始化一个char类型的变量gender

变量命名需要遵循一定的规范，就像给孩子取名要遵循一定的习俗一样。变量名必须以字母、下划线（_）、美元符号（$）开头，后续字符可以是字母、数字、下划线或美元符号；不能使用 Java 中的关键字（如 int、class 等）作为变量名；变量名区分大小写；并且为了提高代码的可读性，变量名应尽量具有描述性，见名知意，例如用 “studentName” 表示学生姓名，而不是用无意义的 “a”“b” 等。

（二）运算符与表达式

运算符分类：运算符是对数据进行操作的符号，就像数学中的加、减、乘、除符号一样。Java 中的运算符种类丰富，主要包括以下几类：

算术运算符：用于执行基本的数学运算，如加法（+）、减法（-）、乘法（*）、除法（/）、取模（%，即求余数），示例代码：

int a = 10;

int b = 3;

int sum = a + b; // 加法，结果为13

int diff = a - b; // 减法，结果为7

int product = a * b; // 乘法，结果为30

double quotient = a / (double)b; // 除法，因为a和b都是int类型，直接相除结果会是整数，这里将b转换为double类型，结果为3.333333

int remainder = a % b; // 取模，结果为1

关系运算符：用于比较两个值的大小关系，返回一个布尔值（true 或 false），包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）、小于等于（<=），示例代码：

int x = 5;

int y = 8;

boolean isEqual = x == y; // 判断x是否等于y，结果为false

boolean isNotEqual = x != y; // 判断x是否不等于y，结果为true

boolean isLessThan = x < y; // 判断x是否小于y，结果为true

boolean isGreaterThan = x > y; // 判断x是否大于y，结果为false

boolean isLessOrEqual = x <= y; // 判断x是否小于等于y，结果为true

boolean isGreaterOrEqual = x >= y; // 判断x是否大于等于y，结果为false

逻辑运算符：用于组合多个条件表达式，返回布尔值，包括逻辑与（&&）、逻辑或（||）、逻辑非（!），示例代码：

boolean condition1 = true;

boolean condition2 = false;

boolean resultAnd = condition1 && condition2; // 逻辑与，两个条件都为true时结果才为true，这里结果为false

boolean resultOr = condition1 || condition2; // 逻辑或，只要有一个条件为true结果就为true，这里结果为true

boolean resultNot =!condition1; // 逻辑非，对条件取反，这里结果为false

赋值运算符：用于将一个值赋给一个变量，最基本的赋值运算符是 “=” ，还有一些扩展赋值运算符，如加法赋值（+=）、减法赋值（-=）、乘法赋值（*=）、除法赋值（/=）、取模赋值（%=），示例代码：

int num = 10;

num += 5; // 等价于num = num + 5，结果num为15

num -= 3; // 等价于num = num - 3，结果num为12

num *= 2; // 等价于num = num * 2，结果num为24

num /= 4; // 等价于num = num / 4，结果num为6

num %= 3; // 等价于num = num % 3，结果num为0

表达式求值：表达式是由变量、常量、运算符等组成的组合，它会计算出一个值。例如 “3 + 5 * 2” 就是一个表达式，在计算表达式时，需要遵循一定的运算规则。首先，运算符有优先级之分，就像数学运算中先乘除后加减一样，Java 中运算符的优先级从高到低大致为：括号（()）、算术运算符（先乘除取模，后加减）、关系运算符、逻辑运算符、赋值运算符。当表达式中运算符优先级相同时，按照从左到右的顺序进行计算。例如，对于表达式 “(3 + 5) * 2”，先计算括号内的 “3 + 5” 得到 8，再乘以 2，最终结果为 16 ；对于表达式 “3 + 5 * 2”，先计算乘法 “5 * 2” 得到 10，再加上 3，结果为 13 。

（三）控制流程语句

条件语句：条件语句就像岔路口的指示牌，根据不同的条件决定程序的执行路径。Java 中的条件语句主要有 if - else 语句和 switch 语句。

if - else 语句：语法结构如下：

if (条件表达式) {

// 条件为true时执行的代码块

} else if (另一个条件表达式) {

// 该条件为true时执行的代码块

} else {

// 以上条件都不满足时执行的代码块

}

例如，根据年龄判断是否成年：

int age = 20;

if (age < 18) {

System.out.println("未成年");

} else if (age == 18) {

System.out.println("刚成年");

} else {

System.out.println("成年");

}

当有多个条件需要判断时，if - else 语句非常灵活，但如果条件分支过多，代码可能会变得冗长，可读性下降。

switch 语句：语法结构如下：

switch (表达式) {

case 值1:

// 当表达式结果为值1时执行的代码

break;

case 值2:

// 当表达式结果为值2时执行的代码

break;

default:

// 当以上都不匹配时执行的代码

}

例如，根据数字输出对应的星期几：

int day = 3;

switch (day) {

case 1:

System.out.println("星期一");

break;

case 2:

System.out.println("星期二");

break;

case 3:

System.out.println("星期三");

break;

default:

System.out.println("其他日子");

}

switch 语句适用于处理固定值的判断，结构清晰，可读性高，效率通常也高于 if - else 语句，但它只能对整数、字符、枚举等固定类型进行比较。

2. 循环语句：循环语句就像一个自动重复工作的机器人，可以让一段代码重复执行多次。Java 中的循环语句有 for 循环、while 循环和 do - while 循环。

for 循环：语法结构如下：

for (初始化; 条件; 更新) {

// 循环体代码

}

例如，打印 1 到 5 的数字：

for (int i = 1; i <= 5; i++) {

System.out.println(i);

}

for 循环常用于明确知道循环次数的场景，它的初始化部分在循环开始前执行一次，用于初始化循环变量；条件部分在每次循环开始时判断，若为 true 则执行循环体，否则结束循环；更新部分在每次循环结束后执行，用于更新循环变量。

while 循环：语法结构如下：

while (条件表达式) {

// 条件为true时执行的代码

}

例如，计算 1 到 100 的累加和：

int sum = 0;

int i = 1;

while (i <= 100) {

sum += i;

i++;

}

System.out.println("Sum: " + sum);

while 循环在每次迭代前先检查条件，如果条件为 true，则执行循环体，否则结束循环，适合循环条件不固定，可能由用户输入或动态计算决定的场景。

do - while 循环：语法结构如下：

do {

// 代码块

} while (条件表达式);

例如，读取用户输入，直到输入为 “exit” 为止：

import java.util.Scanner;

public class DoWhileExample {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String input;

do {

System.out.println("输入一些文字（输入exit退出）：");

input = scanner.nextLine();

System.out.println("你输入了: " + input);

} while (!input.equals("exit"));

System.out.println("程序结束");

scanner.close();

}

do - while 循环先执行循环体，然后再判断条件，这意味着即使条件最开始是 false，循环体也会至少执行一次，适合循环体代码至少要执行一次的场景。

此外，在循环中还可以使用 break 和 continue 语句来控制循环的执行。break 语句用于立即终止当前循环，跳出循环体；continue 语句用于跳过本次循环中 continue 后面的代码，直接开始下一次循环。例如，在一个打印 1 到 10 的循环中，如果遇到数字 5，使用 break 语句可以提前结束循环：

for (int i = 1; i <= 10; i++) {

if (i == 5) {

break;

}

System.out.println(i);

}

如果使用 continue 语句，则会跳过数字 5 的打印，继续打印后面的数字：

for (int i = 1; i <= 10; i++) {

if (i == 5) {

continue;

}

System.out.println(i);

}

进阶之路：数组与字符串操作

掌握了基础语法后，我们迎来了 Java 编程的重要进阶内容 —— 数组与字符串操作。数组和字符串是 Java 中非常常用的数据结构，熟练运用它们，能让我们更好地处理各种复杂的数据和逻辑。

（一）数组

数组定义与初始化：数组是一种用于存储多个相同类型元素的有序集合，就像一排整齐排列的小盒子，每个盒子里装着相同类型的数据。在 Java 中，数组有一维数组和多维数组之分。

一维数组：定义方式有多种，例如：

// 声明一个int类型的一维数组，未初始化

int[] numbers;

// 声明并动态初始化一个长度为5的int类型数组，此时数组元素有默认值（int类型默认值为0）

numbers = new int[5];

// 声明并静态初始化一个int类型数组，同时指定数组元素的值

int[] ages = {18, 20, 22, 25, 30};

多维数组：以二维数组为例，它可以看作是数组的数组，即每个元素又是一个数组。定义方式如下：

// 声明一个二维数组，未初始化

int[][] matrix;

// 声明并动态初始化一个3行4列的二维数组，元素有默认值

matrix = new int[3][4];

// 声明并静态初始化一个二维数组

int[][] scores = {

{85, 90, 92},

{78, 88, 85},

{95, 98, 100}

};

数组元素访问与遍历：数组中的元素可以通过索引（下标）来访问，索引从 0 开始，到数组长度减 1 结束。例如，对于上面定义的ages数组，ages[0]表示第一个元素 18，ages[2]表示第三个元素 22 。

遍历数组是获取数组中每个元素的常用操作。我们可以使用普通的 for 循环来遍历数组：

int[] numbers = {1, 2, 3, 4, 5};

for (int i = 0; i < numbers.length; i++) {

System.out.println(numbers[i]);

}

也可以使用 Java 5.0 引入的增强 for 循环（foreach 循环）来遍历数组，它的语法更加简洁，尤其适用于不需要获取元素索引的情况：

int[] numbers = {1, 2, 3, 4, 5};

for (int num : numbers) {

System.out.println(num);

}

对于二维数组，同样可以使用嵌套的 for 循环进行遍历：

int[][] matrix = {

{1, 2, 3},

{4, 5, 6},

{7, 8, 9}

};

for (int i = 0; i < matrix.length; i++) {

for (int j = 0; j < matrix[i].length; j++) {

System.out.print(matrix[i][j] + " ");

}

System.out.println();

}

增强 for 循环在遍历二维数组时也很方便：

int[][] matrix = {

{1, 2, 3},

{4, 5, 6},

{7, 8, 9}

};

for (int[] row : matrix) {

for (int num : row) {

System.out.print(num + " ");

}

System.out.println();

}

（二）字符串

字符串创建与常用方法：字符串是由字符组成的序列，在 Java 中，字符串是一种非常重要的数据类型，通过java.lang.String类来表示。创建字符串的方式主要有两种：

使用字面量：这是最常用的方式，直接使用双引号括起来的字符序列就是一个字符串字面量，例如：

String str1 = "Hello, Java";

这种方式创建的字符串会存储在字符串常量池中，如果常量池中已有相同内容的字符串，则不会创建新对象，而是直接引用已有对象，这样可以节省内存空间。

使用构造函数：通过new关键字调用String类的构造函数来创建字符串对象，例如：

String str2 = new String("Hello, Java");

使用这种方式创建的字符串对象在堆内存中，即使字符串常量池中已有相同内容的字符串，也会创建一个新的对象。

String类提供了丰富的方法来操作字符串，以下是一些常用方法的示例：

String str = "Hello, World!";

// 获取字符串长度

int length = str.length();

// 将字符串转换为大写

String upperCaseStr = str.toUpperCase();

// 将字符串中的指定字符替换为新字符

String replacedStr = str.replace('o', '0');

// 截取字符串的一部分

String subStr = str.substring(7, 12);

字符串比较：在比较字符串时，需要特别注意不能直接使用 “==” 运算符。“==” 运算符比较的是两个字符串对象的内存地址，而不是字符串的内容。例如：

String str1 = "Hello";

String str2 = "Hello";

String str3 = new String("Hello");

System.out.println(str1 == str2); // true，因为str1和str2指向字符串常量池中的同一个对象

System.out.println(str1 == str3); // false，因为str3是在堆内存中创建的新对象，与str1内存地址不同

要比较字符串的内容是否相等，应该使用equals()方法：

String str1 = "Hello";

String str2 = "Hello";

String str3 = new String("Hello");

System.out.println(str1.equals(str2)); // true，内容相同

System.out.println(str1.equals(str3)); // true，内容相同

如果需要忽略大小写进行比较，可以使用equalsIgnoreCase()方法：

String str1 = "Hello";

String str2 = "HELLO";

System.out.println(str1.equalsIgnoreCase(str2)); // true

实战演练：小型项目实践

学习编程，理论是基础，实践才是关键。接下来，我们通过两个小型项目 —— 简易计算器和图书管理系统（简化版），来巩固所学的 Java 知识，提升实际编程能力。

（一）简易计算器项目

项目需求分析：在日常生活和工作中，计算器是常用的工具，我们的目标是使用 Java 编写一个简易计算器程序，它需要具备基本的加、减、乘、除运算功能，能够接收用户在控制台输入的两个操作数和一个运算符，然后进行相应的运算，并将结果输出到控制台。

功能模块设计：为了实现上述功能，我们将程序划分为三个主要功能模块：

输入模块：负责从控制台获取用户输入的两个操作数和一个运算符。我们可以使用 Java 的Scanner类来实现这一功能，Scanner类提供了方便的方法来读取用户在控制台输入的数据。

运算模块：根据用户输入的运算符，对两个操作数执行相应的数学运算。这是程序的核心逻辑部分，我们可以使用switch语句来根据不同的运算符选择对应的运算逻辑。

输出模块：将运算模块得到的结果输出到控制台。使用System.out.println()方法即可实现输出功能。

代码实现与讲解：下面是实现简易计算器的关键代码：

import java.util.Scanner;

public class SimpleCalculator {

public static void main(String[] args) {

// 创建Scanner对象用于获取用户输入

Scanner scanner = new Scanner(System.in);

// 提示用户输入第一个数字

System.out.print("请输入第一个数字: ");

double num1 = scanner.nextDouble();

// 提示用户输入第二个数字

System.out.print("请输入第二个数字: ");

double num2 = scanner.nextDouble();

// 提示用户输入运算符

System.out.print("请输入运算符 (+, -, *, /): ");

char operator = scanner.next().charAt(0);

// 调用calculate方法计算结果

double result = calculate(num1, num2, operator);

// 检查结果是否有效

if (Double.isNaN(result)) {

System.out.println("无效的运算符或除数为零！");

} else {

System.out.println("结果: " + result);

}

// 关闭Scanner对象，释放资源

scanner.close();

}

/**

* 计算两个数字的运算结果

* @param num1 第一个数字

* @param num2 第二个数字

* @param operator 运算符

* @return 计算结果，如果运算符无效或除数为零，返回NaN

public static double calculate(double num1, double num2, char operator) {

switch (operator) {

case '+':

// 加法运算

return num1 + num2;

case '-':

// 减法运算

return num1 - num2;

case '*':

// 乘法运算

return num1 * num2;

case '/':

// 除法运算，判断除数是否为零

if (num2 != 0) {

return num1 / num2;

} else {

// 返回NaN表示无效值

return Double.NaN;

}

default:

// 如果运算符不是上述四种之一，返回NaN

return Double.NaN;

}

在这段代码中，首先创建了Scanner对象用于读取用户输入。然后，通过System.out.print()方法提示用户输入第一个数字、第二个数字和运算符，并使用scanner.nextDouble()方法获取用户输入的双精度浮点数，scanner.next().charAt(0)方法获取用户输入的单个字符运算符。

接下来，调用calculate方法进行运算，calculate方法使用switch语句根据不同的运算符执行相应的运算。如果运算符是 “+”，则执行加法运算num1 + num2；如果是 “-”，执行减法运算num1 - num2；如果是 “”，执行乘法运算num1 * num2；如果是 “/”，先判断除数num2是否为零，不为零时执行除法运算num1 / num2，为零时返回Double.NaN表示无效值。如果运算符不是 “+”“-”“”“/” 中的任何一个，也返回Double.NaN 。

最后，在main方法中判断计算结果是否为NaN，如果是则输出错误信息 “无效的运算符或除数为零！”，否则输出计算结果。程序结束时，调用scanner.close()方法关闭Scanner对象，释放资源。

（二）图书管理系统（简化版）

系统功能概述：我们要实现一个简化版的图书管理系统，它应具备基本的图书管理功能，包括图书信息的存储，用户可以借阅图书，借阅后更新图书的借阅状态，以及归还图书时再次更新借阅状态。

类与对象设计：为了实现这些功能，我们设计两个主要的类：

图书类（Book）：用于表示图书，包含图书的基本信息，如书名（name）、作者（author）、价格（price）、类型（type）以及是否被借阅（isBorrowed）。通过将这些属性封装在Book类中，实现了数据的封装，提高了数据的安全性和代码的可维护性。同时，为每个属性提供get和set方法，方便外部对这些属性进行访问和修改。还提供了一个构造方法，用于在创建Book对象时初始化部分属性。此外，重写toString方法，以便在输出Book对象时能够以更直观的方式展示图书信息。代码如下：

public class Book {

private String name;

private String author;

private double price;

private String type;

private boolean isBorrowed;

public Book(String name, String author, double price, String type) {

this.name = name;

this.author = author;

this.price = price;

this.type = type;

this.isBorrowed = false; // 初始化时图书未被借阅

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getAuthor() {

return author;

}

public void setAuthor(String author) {

this.author = author;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

public String getType() {

return type;

}

public void setType(String type) {

this.type = type;

}

public boolean isBorrowed() {

return isBorrowed;

}

public void setBorrowed(boolean borrowed) {

isBorrowed = borrowed;

}

@Override

public String toString() {

return "Book{" +

"name='" + name + '\'' +

", author='" + author + '\'' +

", price=" + price +

", type='" + type + '\'' +

", isBorrowed=" + isBorrowed +

'}';

}

图书馆类（Library）：用于管理图书，它包含一个Book类型的数组（books）来存储图书，以及一个整数（size）来记录当前存储的图书数量。提供了添加图书（addBook）、借阅图书（borrowBook）、归还图书（returnBook）等方法。在addBook方法中，先检查数组是否已满，未满时将新图书添加到数组中，并更新图书数量。borrowBook方法遍历数组查找指定书名的图书，找到且未被借阅时，将其借阅状态设置为已借阅并返回true，否则返回false 。returnBook方法同样遍历数组查找指定书名的图书，找到且已被借阅时，将其借阅状态设置为未借阅并返回true，否则返回false 。代码如下：

public class Library {

private Book[] books;

private int size;

public Library(int capacity) {

books = new Book[capacity];

size = 0;

}

// 添加图书

public void addBook(Book book) {

if (size < books.length) {

books[size] = book;

size++;

System.out.println("图书添加成功！");

} else {

System.out.println("书架已满，无法添加图书！");

}

// 借阅图书

public boolean borrowBook(String bookName) {

for (int i = 0; i < size; i++) {

if (books[i].getName().equals(bookName) &&!books[i].isBorrowed()) {

books[i].setBorrowed(true);

System.out.println("借阅成功！");

return true;

}

System.out.println("未找到该书或该书已被借阅！");

return false;

}

// 归还图书

public boolean returnBook(String bookName) {

for (int i = 0; i < size; i++) {

if (books[i].getName().equals(bookName) && books[i].isBorrowed()) {

books[i].setBorrowed(false);

System.out.println("归还成功！");

return true;

}

System.out.println("未找到该书或该书未被借阅！");

return false;

}

核心功能实现：以下是测试上述功能的代码：

public class LibraryTest {

public static void main(String[] args) {

// 创建一个容量为10的图书馆对象

Library library = new Library(10);

// 创建几本图书对象

Book book1 = new Book("Java核心技术", "Cay S. Horstmann", 128.0, "计算机技术");

Book book2 = new Book("Effective Java", "Joshua Bloch", 89.0, "计算机技术");

// 添加图书到图书馆

library.addBook(book1);

library.addBook(book2);

// 借阅图书

library.borrowBook("Java核心技术");

// 归还图书

library.returnBook("Java核心技术");

}

在LibraryTest类的main方法中，首先创建了一个容量为 10 的Library对象，表示一个可以存放 10 本书的图书馆。然后创建了两本图书book1和book2，并使用library.addBook方法将它们添加到图书馆中。接着，使用library.borrowBook方法尝试借阅 “Java 核心技术” 这本书，再使用library.returnBook方法归还这本书。每一步操作都会在控制台输出相应的提示信息，告知用户操作的结果。通过这些操作，展示了图书管理系统中图书添加、借阅和归还功能的实现。

总结与展望

从最初搭建 Java 开发环境，到完成第一个 “Hello, World!” 程序，再到深入学习基础语法、数组与字符串操作，以及通过实战项目将所学知识付诸实践，相信大家已经对 Java 编程有了较为全面的认识和掌握。这一路，我们如同在知识的海洋中逐浪前行，每一个知识点都是一座灯塔，照亮我们前行的道路；每一次代码的编写与调试，都是一次成长的历练。

然而，Java 的世界广袤无垠，我们目前所学只是冰山一角。在未来的学习道路上，还有许多高级特性等待我们去探索，如多线程，它能让程序同时执行多个任务，提高程序的效率和响应性，在服务器开发、图形界面编程等领域有着广泛的应用；异常处理，帮助我们优雅地处理程序运行过程中出现的错误，增强程序的健壮性和稳定性；集合框架，提供了丰富的数据结构和算法，方便我们高效地存储和操作数据。深入学习这些高级特性，就像解锁更多的编程技能，让我们能够应对更加复杂和多样化的开发需求。

学习 Java 编程，不仅是掌握一门技术，更是培养一种思维方式。它教会我们如何将复杂的问题分解为一个个可解决的小问题，如何用逻辑和代码构建出功能强大的软件系统。在这个快速发展的科技时代，编程能力已经成为不可或缺的核心竞争力。希望大家能保持对 Java 编程的热爱和好奇心，不断学习，不断实践，在 Java 的世界里继续探索前行。无论是追求个人技术的提升，还是为了实现职业目标，Java 都将是我们可靠的伙伴。愿大家在 Java 编程的道路上越走越远，创造出属于自己的精彩！