JavaSE-方法（java）

方法的作用

在Java中，方法（Method）是一段具有特定功能的代码块，它允许你将一段逻辑封装起来，以便在程序的多个地方重复使用这段逻辑。方法可以接收输入（参数），执行一系列操作，并可能返回一个结果（返回值）。

方法的作用：

1. 代码复用：通过将代码封装在方法中，你可以在程序的多个地方调用这段代码，而不需要重复编写相同的代码。

2. 提高代码的可读性：将逻辑封装在方法中可以使代码更加清晰和易于理解。

3. 模块化：方法允许你将程序分解成更小的、更易于管理的部分。

4. 参数化操作：方法可以接受参数，使得同一段代码能够处理不同的数据。

5. 返回结果：方法可以返回值，使得调用者可以使用方法的处理结果。

方法的基本结构：

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

• 访问修饰符：比如 public、private 等，用来定义方法的访问级别。
• 返回类型：方法执行完成后返回的数据类型，比如 int、double、String 等，如果是 void 表示方法没有返回值。
• 方法名：方法的名称，应该遵循Java的命名规范。
• 参数列表：方法可以接收的参数列表，参数之间用逗号分隔。
• 方法体：方法内部的代码，包含了方法的逻辑。

示例：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }

    public static void printMessage(String message) {
        System.out.println(message);
    }
}

// 使用方法
public class TestMethods {
    public static void main(String[] args) {
        HelloWorld.printMessage("Hello, Java!");
    }
}

在这个例子中，printMessage 是一个方法，它接受一个 String 类型的参数，并打印出来。main 方法中调用了 printMessage 方法来打印一条消息。

方法的定义

在Java中，方法可以被定义为静态方法或成员方法，它们的主要区别在于它们与类实例的关系。

静态方法（类的方法）

• 定义：静态方法使用 static 关键字定义，它属于类本身而不是类的实例。
• 特点：
  • 静态方法可以在没有创建类的实例的情况下被调用。
  • 静态方法不能访问类的非静态成员（即不能访问没有使用 static 修饰的成员变量或方法）。
  • 静态方法通常用于工具类，提供一些通用的功能。

成员方法（实例的方法）

• 定义：成员方法不使用 static 关键字定义，它是类的实例的一部分。
• 特点：
  • 成员方法需要通过类的实例来调用。
  • 成员方法可以访问类的任何成员，包括静态和非静态成员。
  • 成员方法通常用于操作类的实例状态。

静态方法和成员方法的示例：

public class MyClass {
    // 成员变量
    private int value;

    // 构造方法
    public MyClass(int initialValue) {
        this.value = initialValue;
    }

    // 成员方法
    public void setValue(int newValue) {
        this.value = newValue;
    }

    public int getValue() {
        return this.value;
    }

    // 静态方法
    public static void printHello() {
        System.out.println("Hello, World!");
    }
}

// 使用静态方法
MyClass.printHello(); // 直接调用，不需要类的实例

// 使用成员方法
MyClass myObject = new MyClass(10); // 创建类的实例
myObject.setValue(20); // 调用成员方法，需要类的实例
System.out.println(myObject.getValue()); // 调用成员方法，获取值

在这个例子中，MyClass 有一个成员变量 value 和两个方法：setValue 和 getValue，它们都是成员方法，需要通过类的实例来调用。而 printHello 是一个静态方法，可以直接通过类名调用，不需要创建类的实例。

注意事项：

• 静态方法不能直接访问类的非静态成员，如果需要访问，可以通过类的实例或者使用类名访问静态上下文中定义的静态成员。
• 静态方法通常用于不需要访问实例状态的场景，如数学计算、工具函数等。
• 成员方法可以访问类的任何成员，包括静态成员，但静态方法不能直接访问非静态成员。

方法的实参和形参

在Java编程中，参数（Parameter）分为两种类型：形式参数（Formal Parameter）和实际参数（Actual Parameter）。它们通常在函数或方法定义和调用时使用。

形式参数（Formal Parameter）

形式参数是在函数或方法定义时声明的参数。它们是函数或方法内部使用的变量，用于接收调用者传递的实际参数值。形式参数在函数或方法定义时被指定，并且它们的作用域仅限于函数或方法内部。

例如，在下面的函数定义中，num1和num2是形式参数：

public int add(int num1, int num2) {
    return num1 + num2;
}

实际参数（Actual Parameter）

实际参数是在函数或方法调用时传递给函数或方法的值。这些值被传递给形式参数，并在函数或方法内部使用。

例如，在下面的函数调用中，5和10是实际参数：

int result = add(5, 10);

注：

• 形式参数是函数或方法定义时声明的参数，用于接收实际参数的值。
• 实际参数是在函数或方法调用时传递给函数或方法的值。

通过这种方式，函数或方法可以接受不同的输入，并执行相应的操作。

在Java中，参数的传递方式可以分为两种：值传递（Pass by Value）和引用传递（Pass by Reference）。

值传递（Pass by Value）

在值传递中，函数或方法接收的是实际参数值的副本。也就是说，函数或方法内部对参数进行的任何修改都不会影响到实际参数。对于基本数据类型（如int、float、double、boolean等）和对象的实例（非静态）变量，Java使用值传递。

例如，以下代码将输出20和200：

public static void main(String[] args) {
    int num = 20;
    change(num);
    System.out.println(num); // 输出 20
}

public static void change(int x) {
    x = 200;
}

在这个例子中，change 方法接收的是num 值的副本，所以虽然在change 方法中修改了x 的值，但num 的值并不会改变。

在调用change方法时，传递给change方法的num值是一个复制品（副本）。在Java中，当我们把一个变量传递给方法时，实际上传递的是这个变量的值的一个副本。这个副本包含了原始值的所有特征，但在方法内部，我们操作的是这个副本，而不是原始值本身。

引用传递（Pass by Reference）

在引用传递中，函数或方法接收的是实际参数的引用（地址）。也就是说，函数或方法内部对参数的修改会影响到实际参数。对于引用数据类型（如数组、对象引用）和静态变量，Java使用引用传递。

例如，以下代码将输出100和100：

public static void main(String[] args) {
    int[] arr = {10};
    change(arr);
    System.out.println(arr[0]); // 输出 100
}

public static void change(int[] arr) {
    arr[0] = 100;
}

在这个例子中，change 方法接收的是arr 的引用，所以虽然在change 方法中修改了arr[0] 的值，但arr[0] 的值也会相应地改变。

总结

• 值传递是指将参数的值复制到函数或方法内部，对形式参数的任何修改都不会影响到实际参数。
• 引用传递是指将参数的引用（地址）传递到函数或方法内部，对形式参数的任何修改都会影响到实际参数。

通过这两种传递方式，Java函数或方法可以接收不同类型的参数，并执行相应的操作。

方法的调用

在Java中，方法调用是程序执行过程中的一个基本操作，它允许程序执行定义在类中的特定功能。以下是Java中方法调用的不同类型及其使用方式：

1. 无参数和无返回值的方法调用

public class Greeting {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
}

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting();
        greeting.sayHello(); // 调用无参数和无返回值的方法
    }
}

2. 有参数和有返回值的方法调用

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int sum = calculator.add(5, 3); // 调用有参数和有返回值的方法
        System.out.println("Sum: " + sum);
    }
}

3. 静态方法调用

静态方法可以通过类名直接调用，无需创建类的实例。

public class MathUtils {
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
}

public class Main {
    public static void main(String[] args) {
        int max = MathUtils.max(10, 20); // 调用静态方法
        System.out.println("Max: " + max);
    }
}

4. 构造方法调用

构造方法是一种特殊的方法，用于创建类的新实例。

public class Person {
    public Person(String name, int age) {
        // 初始化代码
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30); // 调用构造方法创建对象
    }
}

5. 方法重载调用

方法重载允许类中存在多个同名方法，只要它们的参数列表不同。

public class Service {
    public void display(String message) {
        System.out.println("String: " + message);
    }

    public void display(int number) {
        System.out.println("Integer: " + number);
    }
}

public class Main {
    public static void main(String[] args) {
        Service service = new Service();
        service.display("Hello"); // 调用第一个display方法
        service.display(123);    // 调用第二个display方法
    }
}

6. 方法重写（Override）调用

子类可以重写父类的方法，调用时将执行子类的版本。

public class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 向上转型
        myAnimal.sound(); // 调用Dog类的sound方法，体现多态
    }
}

7. 私有方法调用

私有方法只能在其所在的类内部访问和调用。

public class Account {
    private void updateBalance(double amount) {
        // 更新余额的代码
    }
}

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        // account.updateBalance(100); // 错误：无法从外部访问私有方法
    }
}

8. 递归方法调用

方法可以调用自身，这称为递归。

public class FactorialCalculator {
    public int calculateFactorial(int n) {
        if (n == 1) return 1;
        return n * calculateFactorial(n - 1); // 递归调用自身
    }
}

public class Main {
    public static void main(String[] args) {
        FactorialCalculator calculator = new FactorialCalculator();
        int factorial = calculator.calculateFactorial(5); // 计算5的阶乘
        System.out.println("Factorial: " + factorial);
    }
}

理解方法调用是掌握Java编程的基础，它涉及到程序的流程控制和数据操作。不同的方法调用类型展示了Java的多态性、封装性和继承性等核心概念。

方法的重载

方法重载（Overloading）是Java中一种重要的特性，允许我们在同一个类中定义多个同名方法，只要它们的参数列表不同即可。方法重载是根据方法的参数列表来确定要调用的具体方法，从而实现不同的功能。

方法重载的主要规则：

1. 方法名必须相同。
2. 参数列表必须不同（参数类型、参数数量或参数顺序不同）。
3. 返回类型可以相同，也可以不同。
4. 访问修饰符和权限可以不同。
5. 静态和非静态方法可以重载。

方法重载的主要目的是提高代码的可读性和可维护性，使同一操作对不同参数进行不同处理。

下面是一个简单的例子，演示了方法重载的用法：

public class OverloadingExample {
    public static void main(String[] args) {
        int sum1 = add(1, 2);
        int sum2 = add(1, 2, 3);
        System.out.println("Sum1: " + sum1); // 输出 Sum1: 3
        System.out.println("Sum2: " + sum2); // 输出 Sum2: 6
    }

    // 重载方法1
    public static int add(int a, int b) {
        return a + b;
    }

    // 重载方法2
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
}

在这个例子中，我们定义了两个名为add的方法。第一个方法接收两个参数a和b，第二个方法接收三个参数a、b和c。当我们在main方法中调用add方法时，Java会根据传递的参数数量自动选择要调用的具体方法。

通过这种方式，我们可以在不改变方法名的情况下，根据不同的参数列表对方法进行重载，从而实现不同的功能。