Java方法的定义和调用

什么是方法

如 System.out.println()，System 是类，out是该类的对象， println()就是这个对象的一个方法。

Java方法是语句的集合，它们在一块可以执行一个功能：

• 方法是解决一类问题的步骤的有序集合
• 方法包含于类或对象中
• 方法在程序中被创建，在其它地方被引用

设计方法的原则：

方法的本意是功能块，就是实现某个功能的语句块的集合。设计方法的时候，最好保持方法的“原子性”，就是一个方法只完成一个功能，这样有利于后期的扩展。

package Java方法;

public class Demo01 {
    public static void main(String[] args) {
                       //main方法
        int sum = add(1,2);
        System.out.println(sum);
    }
    //整数相加方法
    public static int add(int i,int j){
        return i+j;
    }
}
输出结果：
3

方法的定义

Java 方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般定义一个方法包含一下语法：

• 修饰符： 修饰符是可选的，告诉编译器该如何调用方法。 修饰符定义了该方法的访问类型，如 add 方法的 public static。
• 返回值类型： 方法可能会返回值。 returnValueType 是方法返回值的数据类型，如 add 方法的 int。有些方法执行所需的操作，但没有返回值，在这种情况下 returnValueType 是关键字 void，如 main 方法的 void。
• 方法名： 是方法的实际名称。 方法名和参数表共同构成方法签名，如 add 方法名就是 add。
• 参数类型： 参数像是一个占位符。 当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数，如 add 方法的 (int i , int j)。参数是可选的，方法可以不包含任何参数。
  • 形式参数：在方法被调用时用于接收外界输入的数据，如 add 方法的 i 和 j。
  • 实参：调用方法时实际传给方法的数据，如 add 方法的 1 和 2。
• 方法体： 方法体包含具体的语句，定义该方法的功能。
• 关于return： 如果方法需要返回一个值，则用 return 返回；如果方法是 void 型，则用 return 终止方法。

方法的调用

调用方法： 对象名.方法名(实参列表)

Java 支持两种调用方法的形式，根据方法是否返回值来选择。

• 当方法返回一个值的时候，方法调用通常被当作一个值。例如 int larger = max(30,40);

• 当方法返回值是 void 的时候，方法调用一定是一条语句。例如 System.out.println(“hhh”);

关于值传递和引用传递

Java 语言采用的总是 值传递 ，即方法得到的是所有参数值的一个拷贝，方法不能修改传递给它的参数变量内容。对对象采用的不是引用传递，本质还是按值传递的。采用《Java核心技术：卷Ⅰ》一书中的例子进行说明。

示例代码：

package Java方法;

public class ParamTest {
    public static void main(String[] args) {

        //Test 1: 方法不能修改基本数据类型（数值型和布尔型）的参数
        System.out.println("Testing tripleValue:");
        double percent = 10;
        System.out.println("Before:percent="+percent);
        tripleValue(percent);
        System.out.println("After:percent="+percent);
        System.out.println("--------------------------");

        //Test 2: 方法可以改变对象参数的状态
        System.out.println("Testing tripleSalary:");
        Employee harry = new Employee("Harry",50000);
        System.out.println("Before:salary="+harry.getSalary());
        tripleSalary(harry);
        System.out.println("After:salary="+harry.getSalary());
        System.out.println("--------------------------");

        //Test 3: 方法不能使得对象参数引用一个新的对象
        System.out.println("Testing swap:");
        Employee a = new Employee("Alice",70000);
        Employee b = new Employee("Bob",50000);
        System.out.println("Before:a="+a.getName());
        System.out.println("Before:b="+b.getName());
        swap(a,b);
        System.out.println("After:a="+a.getName());
        System.out.println("After:b="+b.getName());
    }

    //定义获得3倍值的方法
    public static void tripleValue(double x){
        x *= 3;
        System.out.println("End of method:x="+x);
    }

    //定义获得3倍薪水的方法
    public static void tripleSalary(Employee x){
        x.raiseSalary(200);
        System.out.println("End of method:salary="+x.getSalary());
    }

    //定义交换对象的方法
    public static void swap(Employee x, Employee y){
        Employee temp = x;
        x = y;
        y = temp;
        System.out.println("End of method:x="+x.getName());
        System.out.println("End of method:y="+y.getName());
    }
}

//定义一个雇员类
class Employee{
    private String name;
    private double salary;
    public Employee(String n, double s){
        name = n;
        salary = s;
    }
    public String getName(){
        return name;
    }
    public double getSalary(){
        return salary;
    }
    //定义一个加薪方法
    public void raiseSalary(double byPercent){
        double raise = salary * byPercent / 100;
        salary += raise;
    }
}

输出结果：

Testing tripleValue:
Before:percent=10.0
End of method:x=30.0
After:percent=10.0
--------------------------
Testing tripleSalary:
Before:salary=50000.0
End of method:salary=150000.0
After:salary=150000.0
--------------------------
Testing swap:
Before:a=Alice
Before:b=Bob
End of method:x=Bob
End of method:y=Alice
After:a=Alice
After:b=Bob

解释：

• 方法不能修改基本数据类型（数值型和布尔型）的参数，执行过程：
  • x 初始化为 percent 的一份拷贝（也是10）
  • x 执行乘 10 操作后变为 30，但是 percent 仍是 10
  • 这个方法结束后，x 不再使用

• 方法可以改变对象参数的状态，执行过程：
  • x 初始化为 harry 值的拷贝，这个值是一个对象的引用
  • x 调用 raiseSalary 这个方法（即 raiseSalary 这个方法应用于 x 这个对象引用），然后将 x 和 harry 共同引用的那个 Employee 对象的薪水提高了200%
  • 方法结束后，参数变量 x 不再使用， 但 Employee 对象的薪水已经改变（提高了200%），对象变量 harry 继续指向这个 Employee 对象

• 方法不能使得对象参数引用一个新的对象，执行过程：

  • 定义一个交换方法

    swap(Employee x, Employee y){

    Employee temp = x;

    x = y;

    y = temp;

    }

  • 如果 Java 对对象采用的是按引用传递，则这个方法就能实现交换数据的效果，但实际运行结果却不行

  • 方法并没有改变变量 a 和 b 的对象引用，swap 中的参数 x 和 y 初始化为两个对象的引用拷贝，这个方法实际交换的是这两个拷贝

  • 方法结束后参数变量 x 和 y 被丢弃，原来的变量 a 和 b 仍然引用这个方法调用之前所引用的对象

​