Java方法详解

Java方法是一段可重复使用的代码块，它接受传入的参数并产生一个结果。Java方法被广泛应用于各种对象导向的程序设计领域，通过方法，程序员可以将功能模块化，以减少代码冗余，提高代码的可重用性、可维护性和可读性，同时也使代码更加简洁。

一、方法的定义和语法

Java方法的定义语法如下所示：

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

其中，修饰符可以是public、protected、private或default，这里不再详述。返回类型可以是各种Java数据类型，也可以是对象类型或void类型。方法名用于标识方法，参数列表是指在方法调用时传入的参数，方法体是方法的具体实现。

下面是一个例子：

public class Example {
    public int add(int x, int y) {
        return x + y;
    }
}

该例子中，add()方法的返回类型是int，方法名是add，参数列表是x和y，方法体是return x + y。

二、Java方法的调用

Java方法的调用可以通过以下两种方式进行：

1. 对象调用

如果方法属于一个对象，那么我们必须先创建该对象，然后才能调用它的方法。如下例所示：

public class Example {
    public int add(int x, int y) {
        return x + y;
    }
}

public class Test {
    public static void main(String[] args) {
        Example example = new Example();
        int result = example.add(1, 2);
        System.out.println(result);
    }
}

该例子中，我们先创建了一个Example对象，然后通过对象调用add()方法，传入参数1和2，最终得到结果3。

2. 类调用

如果方法属于一个类，我们可以使用类名直接调用它的方法，如下例所示：

public class Example {
    public static int add(int x, int y) {
        return x + y;
    }
}

public class Test {
    public static void main(String[] args) {
        int result = Example.add(1, 2);
        System.out.println(result);
    }
}

该例子中，我们直接使用Example类名调用add()方法，传入参数1和2，最终得到结果3。

三、方法传值机制

Java方法的参数传递方式是“传值”，也就是说，在调用方法时，实参（即传入的参数）值会被复制到形参中，方法中对形参的修改不会影响实参。

由于Java中所有的对象都是指针类型的，因此涉及对象类的参数传递时，传递的是对象地址的指针值。

下面是一个示例程序：

public class Example {
    public void changeValue(int value) {
        value++;
    }
    
    public void changeReferenceValue(StringBuilder str) {
        str.append("World");
    }
}

public class Test {
    public static void main(String[] args) {
        Example example = new Example();
        
        int value = 1;
        example.changeValue(value);
        System.out.println(value); // output: 1
        
        StringBuilder str = new StringBuilder("Hello");
        example.changeReferenceValue(str);
        System.out.println(str.toString()); // output: HelloWorld
    }
}

该例子中，我们定义了两个方法changeValue()和changeReferenceValue()，分别传递int类型和StringBuilder类型的参数。在main()方法中，分别传递了一个int类型的值和一个StringBuilder对象。我们发现，调用changeValue()方法后，实参value并没有被改变；而调用changeReferenceValue()方法后，实参str所引用的StringBuilder对象中的值被修改了。

四、方法的重载

方法的重载是指在一个类中，可以定义名字相同但参数类型或个数不同的多个方法。Java编译器会根据方法调用时传递的参数类型和个数，选择调用对应的方法。

下面是一个示例程序：

public class Example {
    public void print() {
        System.out.println("Hello, world!");
    }
    
    public void print(int num) {
        System.out.println("Num: " + num);
    }
    
    public void print(String str) {
        System.out.println("String: " + str);
    }
}

public class Test {
    public static void main(String[] args) {
        Example example = new Example();
        example.print(); // output: Hello, world!
        example.print(123); // output: Num: 123
        example.print("Hello"); // output: String: Hello
    }
}

该例子中，我们定义了三个名字相同但参数类型不同的方法print()，分别接受无参、int和String类型的参数。在main()方法中，我们分别调用这三个方法，Java编译器会根据我们传递的参数类型和个数选择调用相应的方法。

五、方法的覆盖

方法的覆盖是指在子类中，定义与父类中同名、同参数的方法，以覆盖父类中的方法。Java会在运行时确定实际所调用的方法，即在运行时调用子类的方法。需要注意的是，方法的返回类型、访问修饰符、throws异常类型必须与父类方法一致或者更为宽松。

下面是一个示例程序：

class Animal {
    public void move() {
        System.out.println("Animal can move");
    }
}

class Dog extends Animal {
    public void move() {
        System.out.println("Dog can walk and run");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.move(); // output: Animal can move

        Dog dog = new Dog();
        dog.move(); // output: Dog can walk and run
    }
}

该例子中，我们定义了Animal父类和Dog子类，它们都有一个同名、同参数的move()方法。在main()方法中，我们先创建了一个Animal对象，调用父类的move()方法，输出“Animal can move”；接着创建了一个Dog对象，调用子类中的move()方法，输出“Dog can walk and run”。

六、方法的递归

方法的递归指的是方法调用自身，分为直接递归和间接递归两种。递归的应用广泛，它为解决许多问题带来了便利。

下面是一个计算n的阶乘的递归程序：

public class Example {
    public static int factorial(int n) {
        if(n == 0) // 递归终止条件
            return 1;
        else
            return n * factorial(n - 1); // 递归调用
    }
}

public class Test {
    public static void main(String[] args) {
        int result = Example.factorial(5);
        System.out.println(result); // output: 120
    }
}

该例子中，我们定义了一个名为factorial()的递归方法，该方法计算一个数的阶乘。在方法内，首先判断递归终止条件（当n等于0时），然后在递归调用中，将参数n减1，再乘以factorial(n – 1)的值。