前言

首先回顾一下在程序设计语言中关于如何将参数传递给方法的一些专业术语。按值调用表示方法接收的是调用者提供的值。而按引调用表示方法接收的是调用者提供的变量地址。方法可以修改按引用传递的变量的值，而不能修改按值传递的变量的值。
 

Java传参

Java程序设计语言总是采用按值调用。也就是说，方法得到的是所有参数值的一个副本。具体来讲，方法不能修改传递给它的任何参数变量的内容。
接下来，假定一个方法试图将一个参数值增加至3倍：

public static void tripleValue(double x) {
    x = 3 * x;
}

然后调用下面这个方法

double percent = 10;
tripleValue(percent);

不过这样并不能起作用。调用这个方法之后，percent的值还是10。具体的执行过程如下：

1. x初始化为percent值的一个副本(也就是10)。
2. x乘以3以后等于30，但是percent仍然是10
3. 这个方法结束之后，参数变量x不再使用。

然而，有两种类型的方法参数：

• 基本数据类型(数字、布尔值)。
• 对象引用

我们已经知道，一个方法不可能修改基本数据类型的参数，而对象引用作为参数就不同了，可以很容易得利用下面这个方法将一个员工的工资增至三倍：

public static void tripleSalary(Employee x) {
    x.raiseSalary(200)；
}

  当调用

harry = new Employee(...);
tripleSalary(harry);

时，具体的执行过程为：

1. x初始化为harry值的一个副本，这里就是一个对象引用。
2. raiseSalary方法应用与这个对象引用。x和harry同时引用的那个Employee对象的工资提高了200%。
3. 方法结束后，参数变量x不再使用。当然，对象变量harry继续引用那个工资增至3倍的员工对象。

可以看到，实现一个改变对象参数状态的方法是完全可以的，实际上也相当常见。理由很简单，方法得到的是对象引用的副本，原来的对象引用和这个副本都引用同一个对象。

总结
总结一下在Java中对方法参数能做什么和不能做什么：

• 方法不能修改基本数据类型的参数(即数值型和布尔型)
• 方法可以改变对象参数的状态
• 方法不能让一个对象参数引用一个新的对象

 

实战例子

public class 方法参数 {
    public static void main(String[] args) {
        /*
         * 测试1：方法不能修改基本数据类型的参数
         * */
        System.out.println("测试tripleValue:");
        double percent = 10;
        System.out.println("之前：percent=" + percent);
        tripleValue(percent);
        System.out.println("之后：percent=" + percent);

        /*
         * 测试2：方法可以改变对象参数的状态
         * */
        System.out.println("\nTesting tripleSalary");
        Emplpoyee harry = new Emplpoyee("Harry", 50000);
        System.out.println("之前：salary=" + harry.getSalary());
        tripleSalary(harry);
        System.out.println("之后：salary=" + harry.getSalary());

        /*
         * 测试3：方法不能让一个对象参数引用一个新的对象
         * */
        System.out.println("\nTesting swap:");
        Emplpoyee a = new Emplpoyee("Alice", 70000);
        Emplpoyee b = new Emplpoyee("Bob", 60000);
        System.out.println("之前：a=" + a.getName());
        System.out.println("之前：b=" + b.getName());
        swap(a, b);
        System.out.println("之后：a=" + a.getName());
        System.out.println("之后：b=" + b.getName());
    }

    public static void tripleValue(double x) {
        x = 3 * x;
        System.out.println("方法结束后：x=" + x);
    }
    
    public static void tripleSalary(Emplpoyee x) {
        x.raiseSalary(200);
        System.out.println("方法结束后：salary=" + x.getSalary());
    }
    
    public static void swap(Emplpoyee x, Emplpoyee y) {
        Emplpoyee temp = x;
        x = y;
        y = temp;
        System.out.println("方法结束后：x=" + x.getName());
        System.out.println("方法结束后：y=" + y.getName());
    }
};


class Emplpoyee {
    private String name;
    private double salary;
    
    public Emplpoyee(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;
    }
}

运行结果如下：

测试tripleValue:
之前：percent=10.0
方法结束后：x=30.0
之后：percent=10.0

Testing tripleSalary
之前：salary=50000.0
方法结束后：salary=150000.0
之后：salary=150000.0

Testing swap:
之前：a=Alice
之前：b=Bob
方法结束后：x=Bob
方法结束后：y=Alice
之后：a=Alice
之后：b=Bob

标签：13,Java,percent,System,Emplpoyee,参数,println,方法,out
来源： https://www.cnblogs.com/jiakecong/p/16484704.html