【Java基础——11 方法】

在 Java 中，方法（也称为函数或子程序）是一个独立的代码块，用于执行特定的任务。方法可以接收输入参数并返回结果。以下是 Java 方法的详细介绍，包括定义、参数、返回值、方法重载。

方法的定义

基本语法

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

• 修饰符：可选，定义方法的访问级别（如 public、private）和其他特性（如 static、final）。
• 返回类型：方法返回的数据类型。如果方法不返回任何值，使用 void。
• 方法名：方法的名称，遵循命名规则和习惯。
• 参数列表：方法可以接收的参数，以逗号分隔的形式列出。如果没有参数，使用空括号 ()。
• 方法体：方法执行的代码块。

public class MethodExample {
    // 定义一个无返回值的方法
    public void printMessage() {
        System.out.println("Hello, World!");
    }

    // 定义一个有返回值的方法
    public int add(int a, int b) {
        return a + b;
    }

    // 主方法
    public static void main(String[] args) {
        MethodExample example = new MethodExample();

        // 调用无返回值的方法
        example.printMessage();

        // 调用有返回值的方法，并输出结果
        int result = example.add(5, 3);
        System.out.println("Sum: " + result);
    }
}

参数和返回值

参数传递

• 按值传递：基本数据类型（如 int、double）按值传递，即传递参数的副本。
• 按引用传递：对象类型按引用传递，即传递参数的引用。

public class ParameterExample {
    // 按值传递参数
    public void increment(int number) {
        number++;
        System.out.println("Inside method: " + number);
    }

    // 按引用传递参数
    public void changeName(Person person) {
        person.setName("John");
    }

    public static void main(String[] args) {
        ParameterExample example = new ParameterExample();

        // 按值传递
        int num = 5;
        example.increment(num);
        System.out.println("After method call: " + num);

        // 按引用传递
        Person person = new Person("Alice");
        example.changeName(person);
        System.out.println("After method call: " + person.getName());
    }
}

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

方法重载

方法重载是指在同一个类中，方法名相同但参数列表不同（参数的类型、数量或顺序不同）。

public class OverloadExample {
    // 重载方法1：无参数
    public void display() {
        System.out.println("No parameters");
    }

    // 重载方法2：一个参数
    public void display(int a) {
        System.out.println("One parameter: " + a);
    }

    // 重载方法3：两个参数
    public void display(int a, int b) {
        System.out.println("Two parameters: " + a + ", " + b);
    }

    public static void main(String[] args) {
        OverloadExample example = new OverloadExample();

        // 调用不同的重载方法
        example.display();
        example.display(10);
        example.display(10, 20);
    }
}

 方法重写

方法重写的规则

1. 方法名和参数列表：子类重写的方法必须与父类被重写的方法具有相同的方法名和参数列表。
2. 返回类型：子类重写的方法的返回类型必须与父类被重写的方法的返回类型相同，或者是其子类型（协变返回类型）。
3. 访问修饰符：子类重写的方法不能拥有比父类被重写的方法更低的访问权限。例如，如果父类方法是 public，则子类方法不能是 protected 或 private。
4. 异常：子类重写的方法不能抛出比父类被重写的方法更多或更广泛的检查型异常（即 throws 子句中的异常类型可以是父类方法抛出异常类型的子类型）。
5. @Override 注解：使用 @Override 注解可以帮助编译器检查是否正确地重写了方法。

 

静态方法

静态方法使用 static 关键字定义，不需要创建对象实例即可调用。

public class StaticMethodExample {
    // 静态方法
    public static void printMessage() {
        System.out.println("Hello from static method!");
    }

    public static void main(String[] args) {
        // 调用静态方法
        StaticMethodExample.printMessage();
    }
}

递归方法

递归方法是指一个方法在其方法体中调用自身。递归方法必须有一个终止条件，否则会导致无限递归。

public class RecursiveMethodExample {
    // 计算阶乘的递归方法
    public int factorial(int n) {
        if (n == 0) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }

    public static void main(String[] args) {
        RecursiveMethodExample example = new RecursiveMethodExample();

        // 计算并输出5的阶乘
        int result = example.factorial(5);
        System.out.println("Factorial of 5: " + result);
    }
}