LabEx
登录免费加入

Java 方法与基础面向对象编程

JavaBeginner
立即练习

介绍

在本实验中，我们将通过向你介绍方法（methods）和面向对象编程（OOP）的基础知识，将你的 Java 技能提升到一个新的水平。这些概念对于编写更有组织性、可重用性和高效性的代码至关重要。我们将涵盖以下内容：

  1. 创建和使用方法来组织代码并提高可重用性
  2. 理解类和对象的基础知识
  3. 实现一个包含方法和属性的简单类

在本实验结束时，你将能够编写使用方法来将复杂问题分解为更小、更易管理的部分的 Java 程序。你还将了解面向对象编程在 Java 中的工作原理，这对于构建更大、更复杂的应用程序至关重要。如果这些概念听起来很复杂，请不要担心——我们将一步一步地进行讲解，到最后你会发现这些想法如何使你的代码更有组织性和更强大。

让我们开始吧！

理解和创建方法

方法本质上是你主程序中的小型程序。它们帮助你组织代码，提高代码的可读性，并实现代码重用，而无需重复编写相同的代码。可以将方法视为工具包中的专用工具——每个工具都为特定目的而设计。

  1. 首先，在 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 方法是我们程序执行的入口点。

  2. 现在，让我们创建我们的第一个方法。我们将创建一个简单的方法来打印问候语。在 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。当我们调用此方法时，我们需要为此参数提供一个值。

  3. 太棒了！现在我们已经创建了一个方法，让我们使用它。在 main 方法中，将 // TODO: Call methods here 注释替换为：

    printGreeting("Alice");

    Java method call example

    这行代码调用（calls）或调用（invokes）我们的 printGreeting 方法，并将名称 "Alice" 作为参数（argument）传递给它。该参数提供了方法执行其操作所需的特定输入。

  4. 保存文件，让我们编译并运行该程序。在 WebIDE 底部的终端中，键入以下命令：

    javac ~/project/MethodDemo.java
java -cp ~/project MethodDemo

    第一个命令编译我们的 Java 文件，将其转换为 Java 虚拟机可以理解的字节码（bytecode）。第二个命令运行编译后的程序。你应该看到类似于以下的输出：

    Welcome to the Method Demo!
Hello, Alice! Welcome to Java methods.

  5. 太棒了！你刚刚创建并使用了你的第一个 Java 方法。让我们用不同的名称再次调用它。在 main 方法中，在第一个 printGreeting 调用之后添加以下行：

    printGreeting("Bob");

  6. 保存，编译并再次运行该程序。你现在应该看到：

    Welcome to the Method Demo!
Hello, Alice! Welcome to Java methods.
Hello, Bob! Welcome to Java methods.

    请注意，我们如何使用不同的输入重用我们的方法？这是使用方法的一个重要好处。

  7. 现在，让我们创建一个返回一个值的方法。将此方法添加到你的类中，在 printGreeting 方法下方：

    public static int sumNumbers(int a, int b) {
    return a + b;
}

    此方法接受两个整数，将它们加在一起，然后返回结果。请注意，我们使用 int 而不是 void 来指示此方法返回一个整数值。

  8. 让我们在我们的 main 方法中使用这个新方法。在 main 方法的末尾添加以下行：

    int result = sumNumbers(5, 7);
System.out.println("The sum of 5 and 7 is: " + result);

    在这里，我们正在调用我们的 sumNumbers 方法，提供值 5 和 7 作为参数。该方法的返回值然后存储在一个名为 result 的变量中。在存储返回值后，我们将该值打印到控制台。

  9. 再次保存，编译并运行该程序。你现在应该看到额外的输出：

    The sum of 5 and 7 is: 12

    Java method output example

恭喜你！你已经创建并使用了你的第一个 Java 方法。你已经了解了方法如何执行操作（如显示问候语）并提供返回值（如两个数字的总和）。方法允许你将代码结构化为更小的、可重用的部分，使你的程序更易于理解和维护。

类与对象简介

现在我们已经理解了方法，接下来让我们通过创建一个简单的类来迈入面向对象编程的世界。在面向对象编程中，我们使用类作为蓝图来创建对象。你可以将类想象成饼干模具，而对象就是用这个模具制作出的饼干。

  1. 打开 Car.java，让我们开始构建我们的类。首先，我们定义类并添加一些属性：

    public class Car {
    // 属性
    private String make;
    private String model;
    private int year;
}

    这些属性（也称为字段或属性）定义了每个 Car 对象将具有的内容。每辆车都会有制造商（make）、型号（model）和生产年份（year）。

    private 关键字表示这些属性只能在类内部访问。这是一个称为封装（encapsulation）的概念，它有助于保护对象内部的数据。

  2. 现在，让我们为类添加一个构造函数。构造函数是一个特殊的方法，在创建新对象时调用。它用于初始化对象的属性。将此构造函数添加到你的 Car 类中：

    // 构造函数
public Car(String make, String model, int year) {
    this.make = make;
    this.model = model;
    this.year = year;
}

    这个构造函数接受三个参数，并使用它们来设置我们的属性值。this 关键字用于引用当前对象的属性。

  3. 接下来，让我们为类添加一个方法来显示汽车的信息。将此方法添加到你的 Car 类中：

    // 方法
public void displayInfo() {
    System.out.println("Car Information:");
    System.out.println("Make: " + make);
    System.out.println("Model: " + model);
    System.out.println("Year: " + year);
}

    Java 代码片段 displayInfo 方法

    这个方法不接受任何参数，也不返回任何值。它只是打印出汽车的信息。

  4. 很好！我们已经创建了 Car 类。现在让我们打开 CarDemo.java 并添加以下代码：

    public class CarDemo {
    public static void main(String[] args) {
        // 我们将在下一步在这里添加代码
    }
}

    这为我们的演示程序设置了基本结构。

  5. 现在，让我们创建一些 Car 对象并使用它们。在 main 方法中添加以下代码：

    Car myCar = new Car("Toyota", "Corolla", 2022);
myCar.displayInfo();

Car friendsCar = new Car("Honda", "Civic", 2023);
friendsCar.displayInfo();

    在这里，我们创建了两个 Car 对象。new 关键字用于创建一个新对象，我们调用之前定义的构造函数来设置制造商、型号和年份。然后我们在每辆车上调用 displayInfo 方法。

  6. 在编译和运行程序之前，需要注意的是，我们正在处理多个 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 类，并使用它创建了对象。这是 Java 中面向对象编程的基础。你定义了一个蓝图（Car 类），并使用它创建了特定的实例（Car 对象）。每个对象都有自己的一组属性，但它们都共享由类定义的相同结构和行为。

通过更多方法增强我们的类

现在我们已经对类和对象有了基本的了解，接下来让我们通过添加更多方法来增强 Car 类，使其更加实用。我们将添加一些表示汽车可以执行的操作的方法，以及我们可能想了解的汽车属性。

  1. 打开 Car.java 文件。让我们添加一个表示汽车加速的方法。将此方法添加到 Car 类中：

    public void accelerate() {
    System.out.println("The " + make + " " + model + " is accelerating.");
}

    这个方法不会改变汽车的属性，它只是打印一条关于汽车加速的消息。

  2. 现在，让我们添加一个表示刹车的方法。将此方法添加到 Car 类中：

    public void brake() {
    System.out.println("The " + make + " " + model + " is braking.");
}

    同样，这个方法只是打印一条关于汽车操作的消息。

  3. 接下来，让我们添加一个返回汽车信息的方法。添加以下方法：

    public String getMakeAndModel() {
    return make + " " + model;
}

    这个方法将制造商和型号组合成一个字符串并返回。注意，返回类型是 String 而不是 void，因为这个方法会返回一些信息。

  4. 最后，让我们添加一个方法来判断一辆车是否被认为是古董车。在许多地方，如果一辆车的年龄超过 25 年，它就被认为是古董车。添加以下方法：

    public boolean isAntique() {
    int currentYear = java.time.Year.now().getValue();
    return (currentYear - year) > 25;
}

    这个方法使用 Java 内置的 Year 类来获取当前年份。然后计算汽车的年龄，如果超过 25 年则返回 true，否则返回 false。

  5. 现在我们已经将这些方法添加到 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 循环遍历它们，展示了如何处理对象集合。

  6. 保存这两个文件，然后编译并运行 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 类，并使用对象创建了一个更复杂的程序。这展示了如何使用面向对象编程在代码中模拟现实世界的概念。每个汽车对象现在都有自己的数据（制造商、型号、年份）和行为（加速、刹车等），就像真正的汽车一样。

  1. 我们向 Car 类添加了表示操作的方法（accelerate() 和 brake()）。这些方法不会改变汽车的状态，但在更高级的程序中，它们可以修改速度或燃油量等属性。
  2. 我们创建了一个 getMakeAndModel() 方法，它组合了关于汽车的两条信息。这是面向对象编程中的常见模式——提供对对象数据的便捷访问的方法。
  3. isAntique() 方法展示了我们如何使用对象数据（汽车的年份）和外部信息（当前年份）来计算关于对象的新信息。
  4. 在我们的 CarDemo 类中，我们演示了如何创建和使用多个对象，如何在这些对象上调用各种方法，以及如何处理对象数组。

这个例子展示了面向对象编程的强大之处。我们创建了一个 Car 类，它封装了数据（制造商、型号、年份）和行为（加速、刹车、判断是否为古董车）。我们创建的每个 Car 对象都是独立的，拥有自己的数据集，但它们都共享由类定义的相同行为集。

总结

在本实验中，我们在 Java 编程的学习中迈出了重要的一步。我们涵盖了一些对于编写更复杂和更有组织的 Java 程序至关重要的基础概念。让我们回顾一下我们所学到的内容：

  1. 方法（Methods）：

    • 我们创建并使用方法组织代码，使其更具可重用性。
    • 我们看到了方法如何接受参数并返回值，从而让我们能够将复杂问题分解为更小、更易管理的部分。
    • 方法帮助我们避免重复代码，并使程序更易于理解和维护。

  2. 类与对象（Classes and Objects）：

    • 我们引入了类作为对象蓝图的概念。
    • 我们创建了一个 Car 类，包含属性（制造商、型号、年份）和方法（displayInfo、accelerate、brake 等）。
    • 我们学习了如何创建对象（类的实例）并在这些对象上调用方法。

  3. 面向对象编程（Object-Oriented Programming）：

    • 我们看到了面向对象编程如何让我们在代码中模拟现实世界的概念。
    • 我们将数据（属性）和行为（方法）封装在 Car 类中。
    • 我们创建了多个 Car 对象，展示了每个对象如何拥有自己的数据集，但共享由类定义的相同行为。

  4. 增强类的功能（Enhanced Class Functionality）：

    • 我们通过更复杂的方法扩展了 Car 类，包括一个使用 Java 内置日期功能来判断汽车是否为古董车的方法。
    • 我们看到了方法如何与对象数据和外部信息交互以计算新结果。

  5. 处理多个对象（Working with Multiple Objects）：

    • 我们创建了一个 Car 对象数组，展示了如何在程序中处理对象集合。

这些概念构成了 Java 编程的基础，对于构建更大、更复杂的应用程序至关重要。随着你继续学习 Java，你会发现自己在不断使用这些概念。

记住，掌握编程的关键在于练习。以下是一些扩展学习的建议：

  1. 尝试为 Car 类添加更多属性，例如 color 或 mileage。
  2. 创建修改这些属性的方法，例如 paint(String newColor) 或 drive(int miles)。
  3. 创建一个 Garage 类，用于存储多个 Car 对象。添加方法以将汽车添加到车库、移除汽车并显示车库中的所有汽车。
  4. 尝试为其他类型的对象创建类，例如 Book 或 Student。

继续编码，继续实验，最重要的是，保持乐趣！你已经走在成为一名熟练 Java 程序员的道路上了。

相关 Java 课程
Java 入门

Java 入门

java
Java 编程练习

Java 编程练习

java
批量插入数据到课程表

批量插入数据到课程表

java