在本实验中，我们将通过向你介绍方法（methods）和面向对象编程（OOP）的基础知识，将你的 Java 技能提升到一个新的水平。这些概念对于编写更有组织性、可重用性和高效性的代码至关重要。我们将涵盖以下内容：
在本实验结束时，你将能够编写使用方法来将复杂问题分解为更小、更易管理的部分的 Java 程序。你还将了解面向对象编程在 Java 中的工作原理，这对于构建更大、更复杂的应用程序至关重要。如果这些概念听起来很复杂，请不要担心——我们将一步一步地进行讲解，到最后你会发现这些想法如何使你的代码更有组织性和更强大。
让我们开始吧！
方法（methods）就像是主程序中的小型程序。它们帮助你组织代码，使其更具可读性，并允许你重用代码而无需重复编写。你可以将方法想象成工具箱中的专用工具——每个工具都设计用于完成特定的任务。
首先，让我们在 WebIDE 中打开 MethodDemo.java 文件。你会看到以下初始代码：
public class MethodDemo {
public static void main(String[] args) {
System.out.println("Welcome to the Method Demo!");
// TODO: Call methods here
}
// TODO: Add methods here
}这是我们 Java 程序的基本结构。main 方法是程序开始执行的地方。
现在，让我们创建第一个方法。我们将编写一个简单的方法来打印问候语。将此方法添加到 main 方法之外，位于类的层级：
public class MethodDemo {
public static void main(String[] args) {
System.out.println("Welcome to the Method Demo!");
// TODO: Call methods here
}
// 在 main 方法之外添加新方法
public static void printGreeting(String name) {
System.out.println("Hello, " + name + "! Welcome to Java methods.");
}
}让我们分解一下：
public：这个关键字表示该方法可以从程序的任何地方访问。static：这意味着该方法属于类本身，而不是类的任何特定实例。暂时不必过于担心这一点，我们稍后会进一步探讨。void：这表示我们的方法不返回任何值。它只是执行一个操作（打印问候语）。printGreeting：这是我们为方法起的名字。我们可以通过这个名字调用它。(String name)：这是方法接受的参数——一个名为 name 的字符串。当我们调用此方法时，需要提供一个名字。很好！现在我们已经创建了一个方法，让我们来使用它。在 main 方法中，将 TODO 注释替换为：
printGreeting("Alice");
这行代码调用了我们的 printGreeting 方法，并传递了名字 "Alice"。
保存文件，然后编译并运行程序。在 WebIDE 底部的终端中，输入以下命令：
javac ~/project/MethodDemo.java
java -cp ~/project MethodDemo第一条命令编译我们的 Java 文件，第二条命令运行它。你应该会看到如下输出：
Welcome to the Method Demo!
Hello, Alice! Welcome to Java methods.太棒了！你已经创建并使用了第一个 Java 方法。让我们用另一个名字再次调用它。在 main 方法中，在第一次 printGreeting 调用之后添加这行代码：
printGreeting("Bob");保存、编译并再次运行程序。你现在应该看到：
Welcome to the Method Demo!
Hello, Alice! Welcome to Java methods.
Hello, Bob! Welcome to Java methods.看到我们如何用不同的输入重用方法了吗？这是使用方法的一大优势。
现在，让我们创建一个返回值的方法。将此方法添加到你的类中，放在 printGreeting 方法的下方：
public static int sumNumbers(int a, int b) {
return a + b;
}这个方法接受两个整数，将它们相加并返回结果。注意，这里我们使用 int 而不是 void，表示该方法返回一个整数。
让我们在 main 方法中使用这个新方法。在 main 方法的末尾添加以下代码：
int result = sumNumbers(5, 7);
System.out.println("The sum of 5 and 7 is: " + result);这里，我们调用 sumNumbers 方法，传入值 5 和 7，并将结果存储在一个名为 result 的变量中。然后我们打印这个结果。
保存、编译并再次运行程序。你应该会看到额外的输出：
The sum of 5 and 7 is: 12
恭喜！你已经创建并使用了第一个 Java 方法。你已经看到方法如何执行操作（如打印问候语）并返回值（如两个数字的和）。方法允许你将代码分解为更小、可重用的部分，使你的程序更易于理解和维护。
现在我们已经理解了方法，接下来让我们通过创建一个简单的类来迈入面向对象编程的世界。在面向对象编程中，我们使用类作为蓝图来创建对象。你可以将类想象成饼干模具，而对象就是用这个模具制作出的饼干。
打开 Car.java，让我们开始构建我们的类。首先，我们定义类并添加一些属性：
public class Car {
// 属性
private String make;
private String model;
private int year;
}这些属性（也称为字段或属性）定义了每个 Car 对象将具有的内容。每辆车都会有制造商（make）、型号（model）和生产年份（year）。
private 关键字表示这些属性只能在类内部访问。这是一个称为封装（encapsulation）的概念，它有助于保护对象内部的数据。
现在，让我们为类添加一个构造函数。构造函数是一个特殊的方法，在创建新对象时调用。它用于初始化对象的属性。将此构造函数添加到你的 Car 类中：
// 构造函数
public Car(String make, String model, int year) {
this.make = make;
this.model = model;
this.year = year;
}这个构造函数接受三个参数，并使用它们来设置我们的属性值。this 关键字用于引用当前对象的属性。
接下来，让我们为类添加一个方法来显示汽车的信息。将此方法添加到你的 Car 类中：
// 方法
public void displayInfo() {
System.out.println("Car Information:");
System.out.println("Make: " + make);
System.out.println("Model: " + model);
System.out.println("Year: " + year);
}
这个方法不接受任何参数，也不返回任何值。它只是打印出汽车的信息。
很好！我们已经创建了 Car 类。现在让我们打开 CarDemo.java 并添加以下代码：
public class CarDemo {
public static void main(String[] args) {
// 我们将在下一步在这里添加代码
}
}这为我们的演示程序设置了基本结构。
现在，让我们创建一些 Car 对象并使用它们。在 main 方法中添加以下代码：
Car myCar = new Car("Toyota", "Corolla", 2022);
myCar.displayInfo();
Car friendsCar = new Car("Honda", "Civic", 2023);
friendsCar.displayInfo();在这里，我们创建了两个 Car 对象。new 关键字用于创建一个新对象，我们调用之前定义的构造函数来设置制造商、型号和年份。然后我们在每辆车上调用 displayInfo 方法。
在编译和运行程序之前，需要注意的是，我们正在处理多个 Java 文件（Car.java 和 CarDemo.java）。当编译具有依赖关系的多个文件时，我们需要一起编译它们。此外，确保 CarDemo.java 与 Car.java 位于同一目录中，否则你需要在 CarDemo.java 的开头导入 Car 类。
如果 CarDemo.java 和 Car.java 位于不同的目录中，你可能需要在 CarDemo.java 的顶部添加导入语句：
import packagename.Car; // 如果适用，将 'packagename' 替换为实际的包名现在，让我们编译并运行 CarDemo 程序：
javac ~/project/Car.java ~/project/CarDemo.java
java -cp ~/project CarDemo第一条命令一起编译我们的两个 Java 文件，确保所有依赖关系都得到解决。第二条命令运行我们的 CarDemo 类。
你应该会看到如下输出：
Car Information:
Make: Toyota
Model: Corolla
Year: 2022
Car Information:
Make: Honda
Model: Civic
Year: 2023
恭喜！你刚刚创建了第一个 Java 类，并使用它创建了对象。这是 Java 中面向对象编程的基础。你定义了一个蓝图（Car 类），并使用它创建了特定的实例（Car 对象）。每个对象都有自己的一组属性，但它们都共享由类定义的相同结构和行为。
现在我们已经对类和对象有了基本的了解，接下来让我们通过添加更多方法来增强 Car 类，使其更加实用。我们将添加一些表示汽车可以执行的操作的方法，以及我们可能想了解的汽车属性。
打开 Car.java 文件。让我们添加一个表示汽车加速的方法。将此方法添加到 Car 类中：
public void accelerate() {
System.out.println("The " + make + " " + model + " is accelerating.");
}这个方法不会改变汽车的属性，它只是打印一条关于汽车加速的消息。
现在，让我们添加一个表示刹车的方法。将此方法添加到 Car 类中：
public void brake() {
System.out.println("The " + make + " " + model + " is braking.");
}同样，这个方法只是打印一条关于汽车操作的消息。
接下来，让我们添加一个返回汽车信息的方法。添加以下方法：
public String getMakeAndModel() {
return make + " " + model;
}这个方法将制造商和型号组合成一个字符串并返回。注意，返回类型是 String 而不是 void，因为这个方法会返回一些信息。
最后，让我们添加一个方法来判断一辆车是否被认为是古董车。在许多地方，如果一辆车的年龄超过 25 年，它就被认为是古董车。添加以下方法：
public boolean isAntique() {
int currentYear = java.time.Year.now().getValue();
return (currentYear - year) > 25;
}这个方法使用 Java 内置的 Year 类来获取当前年份。然后计算汽车的年龄，如果超过 25 年则返回 true，否则返回 false。
现在我们已经将这些方法添加到 Car 类中，让我们更新 CarDemo.java 文件以使用它们。打开 CarDemo.java 并将其内容替换为：
public class CarDemo {
public static void main(String[] args) {
Car myCar = new Car("Toyota", "Corolla", 2022);
Car classicCar = new Car("Ford", "Mustang", 1965);
myCar.displayInfo();
myCar.accelerate();
myCar.brake();
System.out.println(classicCar.getMakeAndModel() + " is an antique: " + classicCar.isAntique());
Car[] carArray = {myCar, classicCar};
for (Car car : carArray) {
System.out.println(car.getMakeAndModel() + " is an antique: " + car.isAntique());
}
}
}这个新的 main 方法做了以下几件事：
Car 对象：一辆现代汽车和一辆经典汽车。accelerate 和 brake 方法。getMakeAndModel 和 isAntique 方法。Car 对象数组，并使用 for-each 循环遍历它们，展示了如何处理对象集合。保存这两个文件，然后编译并运行 CarDemo 程序：
javac ~/project/Car.java ~/project/CarDemo.java
java -cp ~/project CarDemo你应该会看到类似以下的输出：
Car Information:
Make: Toyota
Model: Corolla
Year: 2022
The Toyota Corolla is accelerating.
The Toyota Corolla is braking.
Ford Mustang is an antique: true
Toyota Corolla is an antique: false
Ford Mustang is an antique: true恭喜！你已经显著扩展了 Car 类，并使用对象创建了一个更复杂的程序。这展示了如何使用面向对象编程在代码中模拟现实世界的概念。每个汽车对象现在都有自己的数据（制造商、型号、年份）和行为（加速、刹车等），就像真正的汽车一样。
Car 类添加了表示操作的方法（accelerate() 和 brake()）。这些方法不会改变汽车的状态，但在更高级的程序中，它们可以修改速度或燃油量等属性。getMakeAndModel() 方法，它组合了关于汽车的两条信息。这是面向对象编程中的常见模式——提供对对象数据的便捷访问的方法。isAntique() 方法展示了我们如何使用对象数据（汽车的年份）和外部信息（当前年份）来计算关于对象的新信息。CarDemo 类中，我们演示了如何创建和使用多个对象，如何在这些对象上调用各种方法，以及如何处理对象数组。这个例子展示了面向对象编程的强大之处。我们创建了一个 Car 类，它封装了数据（制造商、型号、年份）和行为（加速、刹车、判断是否为古董车）。我们创建的每个 Car 对象都是独立的，拥有自己的数据集，但它们都共享由类定义的相同行为集。
在本实验中，我们在 Java 编程的学习中迈出了重要的一步。我们涵盖了一些对于编写更复杂和更有组织的 Java 程序至关重要的基础概念。让我们回顾一下我们所学到的内容：
方法（Methods）：
类与对象（Classes and Objects）：
Car 类，包含属性（制造商、型号、年份）和方法（displayInfo、accelerate、brake 等）。面向对象编程（Object-Oriented Programming）：
Car 类中。Car 对象，展示了每个对象如何拥有自己的数据集，但共享由类定义的相同行为。增强类的功能（Enhanced Class Functionality）：
Car 类，包括一个使用 Java 内置日期功能来判断汽车是否为古董车的方法。处理多个对象（Working with Multiple Objects）：
Car 对象数组，展示了如何在程序中处理对象集合。这些概念构成了 Java 编程的基础，对于构建更大、更复杂的应用程序至关重要。随着你继续学习 Java，你会发现自己在不断使用这些概念。
记住，掌握编程的关键在于练习。以下是一些扩展学习的建议：
Car 类添加更多属性，例如 color 或 mileage。paint(String newColor) 或 drive(int miles)。Garage 类，用于存储多个 Car 对象。添加方法以将汽车添加到车库、移除汽车并显示车库中的所有汽车。Book 或 Student。继续编码，继续实验，最重要的是，保持乐趣！你已经走在成为一名熟练 Java 程序员的道路上了。
