Java方法

方法的定义和调用

方法的基本概念

方法（Method）是 Java 中组织代码的基本单元，也称为函数。它是一段可重用的代码块，用于执行特定任务。方法可以接收输入（参数）、处理逻辑，并返回输出（返回值）。使用方法可以提高代码的可读性、可维护性和复用性。

方法的组成部分：

修饰符：如 public、private、static（可选）。
返回类型：方法返回的值类型，如 int、void（无返回）。
方法名：小驼峰命名法（如 calculateSum）。
参数列表：括号内，多个参数用逗号分隔（如 (int a, int b)）。
方法体：大括号内，包含执行代码。
异常抛出：可选，如 throws Exception

语法：

修饰符 返回类型 方法名(参数类型 参数名, ...) {
    // 方法体
    return 值;  // 如果非 void
}

方法的定义

实例方法：属于对象，需要通过对象调用。

静态方法：属于类，用 static 修饰，通过类名调用。

public class MethodDefine {
    // 静态方法：求两个整数的和
    public static int add(int a, int b) {
        int sum = a + b;
        return sum;  // 返回结果
    }
    
    // 实例方法：打印问候
    public void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }
}

注意：void 方法无需 return，但可用 return; 提前退出.

方法的调用

静态方法调用：类名.方法名(参数)。
实例方法调用：new 对象().方法名(参数)。
参数传递：Java 是值传递（基本类型传值，引用类型传引用地址）。

public class MethodCall {
    public static void main(String[] args) {
        // 调用静态方法
        int result = MethodDefine.add(5, 10);
        System.out.println("和是：" + result);  // 输出：和是：15
        
        // 调用实例方法
        MethodDefine obj = new MethodDefine();
        obj.greet("Alice");  // 输出：Hello, Alice!
    }
}

参数传递细节：

基本类型（如 int）：修改形参不影响实参。

引用类型（如数组）：修改内容会影响原对象，但重新赋值不影响。

public class PassByValue {
    public static void changeInt(int x) {
        x = 20;  // 只改形参
    }
    
    public static void changeArray(int[] arr) {
        arr[0] = 100;  // 修改数组内容
    }
    
    public static void main(String[] args) {
        int num = 10;
        changeInt(num);
        System.out.println(num);  // 仍为 10
        
        int[] array = {1, 2};
        changeArray(array);
        System.out.println(array[0]);  // 100
    }
}

方法的重载

方法重载的基本概念

方法重载（Overloading）允许在同一类中定义多个同名方法，但参数列表不同（数量、类型、顺序）。JVM 根据调用时的参数选择合适方法。重载不考虑返回类型或修饰符。
语法：

方法名相同。
参数不同：数量、类型、顺序。

可以有不同返回类型，但不能仅靠返回类型区分。

public class OverloadDemo {
    // 重载：两个 int
    public int add(int a, int b) {
        return a + b;
    }
    
    // 重载：三个 int
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    
    // 重载：double 类型
    public double add(double a, double b) {
        return a + b;
    }
}

调用重载方法

public class OverloadCall {
    public static void main(String[] args) {
        OverloadDemo obj = new OverloadDemo();
        
        System.out.println(obj.add(1, 2));      // 调用两个 int：3
        System.out.println(obj.add(1, 2, 3));   // 调用三个 int：6
        System.out.println(obj.add(1.5, 2.5));  // 调用 double：4.0
    }
}

分析：JVM 匹配最精确的方法。如果无精确匹配，会自动类型转换（如 int 到 double），但可能导致歧义错误。

重载与类型转换

优先精确匹配。
次之自动提升（如 byte 到 int）。
如果有 add(int, int) 和 add(double, double)，调用 add(1, 2.0) 会匹配 double（因为 1 转 double）。

歧义示例（编译错误）：
1
2
3
public int method(long a) { ... }
public int method(int a) { ... }
// method(5) 歧义：5 可为 int 或 long

常见错误避免

仅返回类型不同：不允许重载，编译错误。
参数名不同：不构成重载，只看类型。
修饰符不同：不影响重载。
重载 vs 重写：重载在同一类，重写在子类（Override）。

命令行传递参数

命令行参数的基本概念

Java 程序可以通过命令行传递参数给 main 方法。main 的签名：public static void main(String[] args)，args 是字符串数组，存储参数。
运行时：在命令行或 IDE 配置参数，如 java ClassName param1 param2。

public class CommandLineArgs {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("无参数");
            return;
        }
        
        System.out.println("参数个数：" + args.length);
        for (String arg : args) {
            System.out.println("参数：" + arg);
        }
        
        // 示例：解析为 int 并求和
        int sum = 0;
        for (String arg : args) {
            try {
                sum += Integer.parseInt(arg);
            } catch (NumberFormatException e) {
                System.out.println("无效数字：" + arg);
            }
        }
        System.out.println("和：" + sum);
    }
}

可变参数

可变参数的基本概念

可变参数（Varargs）允许方法接收任意数量的同类型参数。从 Java 5 开始，用 … 表示，如 (int… numbers)。
内部：作为数组处理。只能是最后一个参数。

语法：

1
2
3

public void method(Type... varName) {
    // varName 作为 Type[] 使用
}

public class VarargsDemo {
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    // 混合固定和可变
    public static void print(String prefix, int... values) {
        System.out.print(prefix + ": ");
        for (int val : values) {
            System.out.print(val + " ");
        }
        System.out.println();
    }
}

调用可变参数

public class VarargsCall {
    public static void main(String[] args) {
        System.out.println(VarargsDemo.sum(1, 2, 3));  // 6
        System.out.println(VarargsDemo.sum());         // 0（空）
        int[] arr = {4, 5};
        System.out.println(VarargsDemo.sum(arr));      // 9（传数组）
        
        VarargsDemo.print("Numbers", 10, 20, 30);     // Numbers: 10 20 30 
    }
}

分析：sum() 时 numbers = 空数组。传数组直接兼容。

递归

递归的基本概念

递归是方法调用自身解决问题。包括：

基例：终止条件，避免无限递归。
递归步：缩小问题，趋近基例。

好处：简化复杂问题，如树遍历。缺点：栈溢出风险。

public class RecursionDemo {
    public static long factorial(int n) {
        if (n == 0 || n == 1) {
            return 1
        }
        return n * factorial(n-1);
    }
}

调用递归

public class RecursionCall {
    public static void main(String[] args) {
        System.out.println(RecursionDemo.factorial(5));  // 120
    }
}

注意：能不用递归就不用递归，比较消耗内存