5. 方法与类

在Java编程中，理解面向对象编程（OOP）的核心概念是构建高效、可维护应用程序的基础。面向对象编程通过类和对象来模拟现实世界中的实体和行为，从而实现代码的模块化和复用性。方法作为对象的行为定义了程序的逻辑流，构造器则为对象的初始化提供了灵活性。而访问修饰符与封装机制，则在保护数据和控制访问权限方面发挥了重要作用。

本篇文章将深入探讨方法的定义与重载、类与对象、构造器与对象初始化，以及访问修饰符与封装等核心概念。通过详细的解释和示例代码，展示这些概念的实际应用，帮助你更好地理解和掌握Java编程中的关键技术。

5.1. 定义方法与方法重载

方法是一组执行特定任务的语句集合，用于组织代码并实现功能模块化。方法通常用于重复执行某一操作或将逻辑单独封装。
语法结构

[修饰符] 返回类型 方法名(参数列表) {
    // 方法体
    // 执行的语句
}

public class Calculator {

    // 定义一个方法，用于计算两个整数的和
    public int add(int a, int b) {
        int sum = a + b;  // 计算和
        return sum;       // 返回结果
    }

    // 重载的方法，用于计算三个整数的和
    public int add(int a, int b, int c) {
        int sum = a + b + c;
        return sum;
    }

    public static void main(String[] args) {
        // 创建Calculator类的对象
        Calculator calculator = new Calculator();

        // 调用add方法并打印结果
        int result1 = calculator.add(10, 20);
        int result2 = calculator.add(10, 20, 30);

        System.out.println("The sum of two numbers is: " + result1);  // 输出: The sum of two numbers is: 30
        System.out.println("The sum of three numbers is: " + result2);  // 输出: The sum of three numbers is: 60
    }
}

1. 方法的定义 我们在Calculator类中定义了两个add方法：
   • 第一个add方法：用于计算两个整数的和。
   • 第二个add方法：重载了第一个方法，增加了一个参数，用于计算三个整数的和。
2. 方法重载 方法重载是指在同一个类中，可以定义多个同名但参数不同的方法。这种机制允许在不同情况下使用相同的方法名，增强了代码的灵活性和可读性。
3. 方法调用 在main方法中，通过Calculator对象调用了两个重载的add方法，一个用于计算两个整数的和，另一个用于计算三个整数的和。结果分别输出为30和60。

5.2. 类与对象

类是Java中面向对象编程的核心概念，它是对象的模板或蓝图，定义了对象的属性和行为。类包含字段（属性）和方法（行为）。
语法结构

[修饰符] class 类名 {
    // 字段（属性）
    // 方法（行为）
}

public class Car {

    // 字段（属性）
    private String model;
    private int year;

    // 方法（行为）
    public void drive() {
        System.out.println("The car is driving.");
    }
    
    public void displayInfo() {
        System.out.println("Model: " + model + ", Year: " + year);
    }

    public static void main(String[] args) {
        // 创建Car类的对象
        Car myCar = new Car();
        myCar.model = "Toyota";
        myCar.year = 2022;

        // 调用对象的方法
        myCar.drive();  // 输出: The car is driving.
        myCar.displayInfo();  // 输出: Model: Toyota, Year: 2022
    }
}

1. 类的定义 Car类定义了两个字段model和year，以及两个方法drive和displayInfo。字段存储了汽车的型号和年份，而方法定义了汽车的行为，如驾驶和显示信息。
2. 对象的创建 在main方法中，我们通过new关键字创建了一个Car类的实例对象myCar。通过对象myCar访问和修改类中的字段和方法。
3. 调用方法 通过对象myCar调用drive方法，程序输出The car is driving.，表示汽车正在驾驶中。同时调用displayInfo方法输出汽车的型号和年份信息。

5.3. 构造器与对象的初始化

构造器是用于初始化对象状态的特殊方法，在创建对象时自动调用。构造器的名称必须与类名相同，且不定义返回类型。它们可以被重载以支持不同的初始化方式。
语法结构

[修饰符] 类名(参数列表) {
    // 初始化语句
}

public class Car {

    private String model;
    private int year;

    // 构造器，用于初始化对象
    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    public void displayInfo() {
        System.out.println("Model: " + model + ", Year: " + year);
    }

    public static void main(String[] args) {
        // 使用构造器初始化对象
        Car myCar = new Car("Toyota", 2022);
        
        // 调用方法显示信息
        myCar.displayInfo();  // 输出: Model: Toyota, Year: 2022
    }
}

1. 构造器的定义 Car类定义了一个构造器Car(String model, int year)，用于在对象创建时初始化model和year字段。构造器与类名相同，没有返回类型。
2. 对象的初始化 在main方法中，使用构造器new Car("Toyota", 2022)创建并初始化Car对象myCar。构造器在对象创建时被自动调用，初始化对象的字段。
3. 调用方法 通过myCar对象调用displayInfo方法，输出汽车的型号和年份信息Model: Toyota, Year: 2022。

5.4. 访问修饰符与封装

访问修饰符用于控制类、方法和字段的访问级别，以保护数据和实现封装。常见的访问修饰符包括：

• public：对所有类可见。
• private：仅对定义它的类可见。
• protected：对同一包中的类和子类可见。
• 默认（无修饰符）：仅对同一包中的类可见。

public class Car {

    // 字段（属性）
    private String model;
    private int year;

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

    // 公共方法，允许外部访问字段
    public String getModel() {
        return model;
    }

    public int getYear() {
        return year;
    }

    public void displayInfo() {
        System.out.println("Model: " + model + ", Year: " + year);
    }

    public static void main(String[] args) {
        Car myCar = new Car("Toyota", 2022);
        
        // 通过公共方法访问私有字段
        System.out.println("Model: " + myCar.getModel());  // 输出: Model: Toyota
        System.out.println("Year: " + myCar.getYear());    // 输出: Year: 2022
    }
}

1. 访问修饰符的使用 在Car类中，model和year字段被声明为private，这意味着它们只能在Car类内部访问。为了允许外部类访问这些字段，我们定义了public的getModel和getYear方法。
2. 封装 封装是面向对象编程中的核心概念之一，通过将字段设为private，我们隐藏了对象的内部实现细节，外部只能通过公共方法访问和修改这些字段。这种设计提高了代码的安全性和灵活性。
3. 访问私有字段 在main方法中，我们通过公共的getModel和getYear方法访问和打印私有字段model和year的值，实现了数据的封装和访问控制。

在Java编程中，方法、类、构造器、访问修饰符与封装是构建面向对象应用程序的基础元素。通过理解和掌握这些概念，开发者可以设计出结构良好、可维护性高的代码。

1. 方法与方法重载：方法是执行特定任务的代码块，可以通过参数传递数据并返回结果。方法重载允许在同一类中定义多个同名方法，只要它们的参数列表不同。这种灵活性提高了代码的可读性和复用性。
2. 类与对象：类是对象的蓝图，定义了对象的属性和行为。通过类，可以创建多个具有相同结构但不同状态的对象。对象是类的实例，通过它们可以访问类中的字段和方法。
3. 构造器与对象的初始化：构造器是一种特殊的方法，用于初始化新创建的对象。它在对象创建时自动调用，确保对象的字段被正确设置。构造器可以被重载，以支持不同的初始化需求。
4. 访问修饰符与封装：访问修饰符控制类、字段和方法的可见性，以保护数据和实现封装。封装通过隐藏对象的内部实现细节，提供了安全的接口供外部访问。通过合理使用访问修饰符，开发者可以确保数据的完整性和安全性。