在本实验中，我们将通过向你介绍方法（methods）和面向对象编程（OOP）的基础知识，将你的 Java 技能提升到一个新的水平。这些概念对于编写更有组织性、可重用性和高效性的代码至关重要。我们将涵盖以下内容：
在本实验结束时，你将能够编写使用方法来将复杂问题分解为更小、更易管理的部分的 Java 程序。你还将了解面向对象编程在 Java 中的工作原理，这对于构建更大、更复杂的应用程序至关重要。如果这些概念听起来很复杂，请不要担心——我们将一步一步地进行讲解，到最后你会发现这些想法如何使你的代码更有组织性和更强大。
让我们开始吧！
方法本质上是你主程序中的小型程序。它们帮助你组织代码，提高代码的可读性，并实现代码重用，而无需重复编写相同的代码。可以将方法视为工具包中的专用工具——每个工具都为特定目的而设计。
首先，在 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
}
// Add the new method here, outside and after the main method
public static void printGreeting(String name) {
System.out.println("Hello, " + name + "! Welcome to Java methods.");
}
}让我们分解一下这意味着什么：
public：此关键字表示可以从其他类访问该方法。static：这意味着该方法属于类本身，而不是类的特定实例。我们稍后将更深入地研究这个概念；现在，可以将其视为我们想要在不创建对象的情况下使用的方法的要求。void：这表示我们的方法不返回任何值。它执行一个动作——打印问候语——但不返回任何数据。printGreeting：这是我们分配给方法的名称。我们将使用此名称来调用（invoke）或调用（call）该方法。(String name)：这是一个参数（parameter）——我们的方法接受的一段数据。它期望一个字符串（String），我们将其命名为 name。当我们调用此方法时，我们需要为此参数提供一个值。太棒了！现在我们已经创建了一个方法，让我们使用它。在 main 方法中，将 // TODO: Call methods here 注释替换为：
printGreeting("Alice");
这行代码*调用（calls）或调用（invokes）我们的 printGreeting 方法，并将名称 "Alice" 作为参数（argument）*传递给它。该参数提供了方法执行其操作所需的特定输入。
保存文件，让我们编译并运行该程序。在 WebIDE 底部的终端中，键入以下命令：
javac ~/project/MethodDemo.java
java -cp ~/project MethodDemo第一个命令编译我们的 Java 文件，将其转换为 Java 虚拟机可以理解的字节码（bytecode）。第二个命令运行编译后的程序。你应该看到类似于以下的输出：
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 程序员的道路上了。
