Java方法详解：定义、调用与参数传递

概述

方法（Method）是Java中用于执行特定任务的代码块。方法可以被重复调用，提高代码的复用性和可维护性。

1. 方法定义

基本语法

访问修饰符 返回类型 方法名(参数列表) {
    // 方法体
    return 返回值;  // 如果返回类型是void，可以省略
}

示例

public class MethodExample {
    // 无参数无返回值的方法
    public void sayHello() {
        System.out.println("Hello!");
    }
    
    // 有参数无返回值的方法
    public void printMessage(String message) {
        System.out.println(message);
    }
    
    // 有参数有返回值的方法
    public int add(int a, int b) {
        return a + b;
    }
    
    // 有多个返回值（使用数组）
    public int[] divide(int a, int b) {
        int quotient = a / b;
        int remainder = a % b;
        return new int[]{quotient, remainder};
    }
    
    public static void main(String[] args) {
        MethodExample example = new MethodExample();
        
        example.sayHello();
        example.printMessage("Hello, Java!");
        
        int sum = example.add(10, 20);
        System.out.println("Sum: " + sum);
        
        int[] result = example.divide(10, 3);
        System.out.println("Quotient: " + result[0] + ", Remainder: " + result[1]);
    }
}

2. 方法参数

基本类型参数

public class PrimitiveParameterExample {
    public void changeValue(int number) {
        number = 100;  // 这不会改变原始值
    }
    
    public static void main(String[] args) {
        PrimitiveParameterExample example = new PrimitiveParameterExample();
        int num = 5;
        
        example.changeValue(num);
        System.out.println("num = " + num);  // 输出：5
    }
}

引用类型参数

public class ReferenceParameterExample {
    public void changeValue(int[] numbers) {
        numbers[0] = 100;  // 这会改变原始数组
    }
    
    public static void main(String[] args) {
        ReferenceParameterExample example = new ReferenceParameterExample();
        int[] nums = {1, 2, 3};
        
        example.changeValue(nums);
        System.out.println("nums[0] = " + nums[0]);  // 输出：100
    }
}

可变参数

public class VarargsExample {
    // 可变参数
    public int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    // 混合使用可变参数
    public void printInfo(String name, int... scores) {
        System.out.print(name + "的成绩: ");
        for (int score : scores) {
            System.out.print(score + " ");
        }
        System.out.println();
    }
    
    public static void main(String[] args) {
        VarargsExample example = new VarargsExample();
        
        int total = example.sum(1, 2, 3, 4, 5);
        System.out.println("Sum: " + total);
        
        example.printInfo("张三", 85, 90, 95);
    }
}

3. 方法重载

方法重载是指在同一个类中可以有多个同名方法，但参数列表不同：

public class OverloadExample {
    // 方法重载
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public String add(String a, String b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        OverloadExample example = new OverloadExample();
        
        System.out.println(example.add(10, 20));        // 30
        System.out.println(example.add(10.5, 20.5));    // 31.0
        System.out.println(example.add(10, 20, 30));    // 60
        System.out.println(example.add("Hello", " Java")); // Hello Java
    }
}

4. 递归方法

递归是指方法调用自身：

public class RecursionExample {
    // 递归计算阶乘
    public long factorial(int n) {
        if (n <= 1) {
            return 1;
        }
        return n * factorial(n - 1);
    }
    
    // 递归计算斐波那契数列
    public int fibonacci(int n) {
        if (n <= 1) {
            return n;
        }
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
    
    // 递归计算幂
    public double power(double base, int exponent) {
        if (exponent == 0) {
            return 1;
        }
        if (exponent < 0) {
            return 1 / power(base, -exponent);
        }
        return base * power(base, exponent - 1);
    }
    
    public static void main(String[] args) {
        RecursionExample example = new RecursionExample();
        
        System.out.println("5! = " + example.factorial(5));
        System.out.println("fibonacci(10) = " + example.fibonacci(10));
        System.out.println("2^10 = " + example.power(2, 10));
    }
}

5. 静态方法

静态方法属于类而不是对象，可以直接通过类名调用：

public class StaticMethodExample {
    // 静态方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    // 静态方法可以调用其他静态方法
    public static void printSum(int a, int b) {
        System.out.println("Sum: " + add(a, b));
    }
    
    // 非静态方法可以调用静态方法
    public void nonStaticMethod() {
        int result = add(10, 20);
        System.out.println("Result: " + result);
    }
    
    public static void main(String[] args) {
        // 直接通过类名调用静态方法
        int sum = StaticMethodExample.add(10, 20);
        System.out.println("Sum: " + sum);
        
        StaticMethodExample.printSum(10, 20);
        
        // 也可以通过对象调用静态方法
        StaticMethodExample example = new StaticMethodExample();
        example.nonStaticMethod();
    }
}

6. 方法作为参数

Java支持将方法作为参数传递：

public class MethodAsParameterExample {
    // 定义函数式接口
    @FunctionalInterface
    interface Calculator {
        int calculate(int a, int b);
    }
    
    // 方法接收函数式接口作为参数
    public static int operate(int a, int b, Calculator calculator) {
        return calculator.calculate(a, b);
    }
    
    public static void main(String[] args) {
        // 使用Lambda表达式传递方法
        int sum = operate(10, 20, (a, b) -> a + b);
        System.out.println("Sum: " + sum);
        
        int product = operate(10, 20, (a, b) -> a * b);
        System.out.println("Product: " + product);
    }
}

最佳实践

1. 方法命名规范：使用小写字母开头的驼峰命名法
2. 单一职责原则：每个方法只做一件事
3. 避免过长方法：方法长度一般不超过30行
4. 使用有意义的参数名：参数名应该清晰表达其含义
5. 合理使用静态方法：不需要访问实例变量的方法可以定义为静态方法

总结

方法是Java编程的基本构建块，掌握方法的定义、调用和参数传递对于编写高质量的Java代码至关重要。在实际编程中，要合理设计方法，提高代码的复用性和可维护性。