共计 5661 个字符，预计需要花费 15 分钟才能阅读完成。
一个 class 可以包含多个 field，例如，我们给Person 类就定义了两个field：
class Person {public String name;
public int age;
}
但是，直接把 field 用public暴露给外部可能会破坏封装性。比如，代码可以这样写：
Person ming = new Person();
ming.name = "Xiao Ming";
ming.age = -99; // age 设置为负数
显然，直接操作 field，容易造成逻辑混乱。为了避免外部代码直接去访问field，我们可以用private 修饰field，拒绝外部访问：
class Person {private String name;
private int age;
}
试试 private 修饰的 field 有什么效果：
// private field
public class Main {public static void main(String[] args) {Person ming = new Person();
ming.name = "Xiao Ming"; // 对字段 name 赋值
ming.age = 12; // 对字段 age 赋值
}
}
class Person {private String name;
private int age;
}
是不是编译报错？把访问 field 的赋值语句去了就可以正常编译了。
把 field 从public改成 private，外部代码不能访问这些field，那我们定义这些field 有什么用？怎么才能给它赋值？怎么才能读取它的值？
所以我们需要使用方法（method）来让外部代码可以间接修改field：
// private field
public class Main {public static void main(String[] args) {Person ming = new Person();
ming.setName("Xiao Ming"); // 设置 name
ming.setAge(12); // 设置 age
System.out.println(ming.getName() + "," + ming.getAge());
}
}
class Person {private String name;
private int age;
public String getName() {return this.name;
}
public void setName(String name) {this.name = name;
}
public int getAge() {return this.age;
}
public void setAge(int age) {if (age < 0 || age > 100) {throw new IllegalArgumentException("invalid age value");
}
this.age = age;
}
}
虽然外部代码不能直接修改 private 字段，但是，外部代码可以调用方法 setName() 和setAge()来间接修改 private 字段。在方法内部，我们就有机会检查参数对不对。比如，setAge()就会检查传入的参数，参数超出了范围，直接报错。这样，外部代码就没有任何机会把 age 设置成不合理的值。
对 setName() 方法同样可以做检查，例如，不允许传入 null 和空字符串：
public void setName(String name) {if (name == null || name.isBlank()) {throw new IllegalArgumentException("invalid name");
}
this.name = name.strip(); // 去掉首尾空格
}
同样，外部代码不能直接读取 private 字段，但可以通过 getName() 和getAge()间接获取 private 字段的值。
所以，一个类通过定义方法，就可以给外部代码暴露一些操作的接口，同时，内部自己保证逻辑一致性。
调用方法的语法是 实例变量. 方法名(参数);。一个方法调用就是一个语句，所以不要忘了在末尾加;。例如：ming.setName("Xiao Ming");。
定义方法
从上面的代码可以看出，定义方法的语法是：
修饰符 方法返回类型 方法名(方法参数列表) {
若干方法语句;
return 方法返回值;
}
方法返回值通过 return 语句实现，如果没有返回值，返回类型设置为void，可以省略return。
private 方法
有 public 方法，自然就有 private 方法。和 private 字段一样，private方法不允许外部调用，那我们定义 private 方法有什么用？
定义 private 方法的理由是内部方法是可以调用 private 方法的。例如：
// private method
public class Main {public static void main(String[] args) {Person ming = new Person();
ming.setBirth(2008);
System.out.println(ming.getAge());
}
}
class Person {private String name;
private int birth;
public void setBirth(int birth) {this.birth = birth;
}
public int getAge() {return calcAge(2019); // 调用 private 方法
}
// private 方法:
private int calcAge(int currentYear) {return currentYear - this.birth;
}
}
观察上述代码，calcAge()是一个 private 方法，外部代码无法调用，但是，内部方法 getAge() 可以调用它。
此外，我们还注意到，这个 Person 类只定义了 birth 字段，没有定义 age 字段，获取 age 时，通过方法 getAge() 返回的是一个实时计算的值，并非存储在某个字段的值。这说明方法可以封装一个类的对外接口，调用方不需要知道也不关心 Person 实例在内部到底有没有 age 字段。
this 变量
在方法内部，可以使用一个隐含的变量 this，它始终指向当前实例。因此，通过this.field 就可以访问当前实例的字段。
如果没有命名冲突，可以省略this。例如：
class Person {private String name;
public String getName() {return name; // 相当于 this.name
}
}
但是，如果有局部变量和字段重名，那么局部变量优先级更高，就必须加上this：
class Person {private String name;
public void setName(String name) {this.name = name; // 前面的 this 不可少，少了就变成局部变量 name 了
}
}
方法参数
方法可以包含 0 个或任意个参数。方法参数用于接收传递给方法的变量值。调用方法时，必须严格按照参数的定义一一传递。例如：
class Person {
...
public void setNameAndAge(String name, int age) {...}
}
调用这个 setNameAndAge() 方法时，必须有两个参数，且第一个参数必须为String，第二个参数必须为int：
Person ming = new Person();
ming.setNameAndAge("Xiao Ming"); // 编译错误：参数个数不对
ming.setNameAndAge(12, "Xiao Ming"); // 编译错误：参数类型不对
可变参数
可变参数用 类型...定义，可变参数相当于数组类型：
class Group {private String[] names;
public void setNames(String... names) {this.names = names;
}
}
上面的 setNames() 就定义了一个可变参数。调用时，可以这么写：
Group g = new Group();
g.setNames("Xiao Ming", "Xiao Hong", "Xiao Jun"); // 传入 3 个 String
g.setNames("Xiao Ming", "Xiao Hong"); // 传入 2 个 String
g.setNames("Xiao Ming"); // 传入 1 个 String
g.setNames(); // 传入 0 个 String
完全可以把可变参数改写为 String[] 类型：
class Group {private String[] names;
public void setNames(String[] names) {this.names = names;
}
}
但是，调用方需要自己先构造String[]，比较麻烦。例如：
Group g = new Group();
g.setNames(new String[] {"Xiao Ming", "Xiao Hong", "Xiao Jun"}); // 传入 1 个 String[]
另一个问题是，调用方可以传入null：
Group g = new Group();
g.setNames(null);
而可变参数可以保证无法传入null，因为传入 0 个参数时，接收到的实际值是一个空数组而不是null。
参数绑定
调用方把参数传递给实例方法时，调用时传递的值会按参数位置一一绑定。
那什么是参数绑定？
我们先观察一个基本类型参数的传递：
// 基本类型参数绑定
public class Main {public static void main(String[] args) {Person p = new Person();
int n = 15; // n 的值为 15
p.setAge(n); // 传入 n 的值
System.out.println(p.getAge()); // 15
n = 20; // n 的值改为 20
System.out.println(p.getAge()); // 15 还是 20?
}
}
class Person {private int age;
public int getAge() {return this.age;
}
public void setAge(int age) {this.age = age;
}
}
运行代码，从结果可知，修改外部的局部变量 n，不影响实例p 的age字段，原因是 setAge() 方法获得的参数，复制了 n 的值，因此，p.age和局部变量 n 互不影响。
结论：基本类型参数的传递，是调用方值的复制。双方各自的后续修改，互不影响。
我们再看一个传递引用参数的例子：
// 引用类型参数绑定
public class Main {public static void main(String[] args) {Person p = new Person();
String[] fullname = new String[] { "Homer", "Simpson" };
p.setName(fullname); // 传入 fullname 数组
System.out.println(p.getName()); // "Homer Simpson"
fullname[0] = "Bart"; // fullname 数组的第一个元素修改为 "Bart"
System.out.println(p.getName()); // "Homer Simpson" 还是 "Bart Simpson"?
}
}
class Person {private String[] name;
public String getName() {return this.name[0] + "" + this.name[1];
}
public void setName(String[] name) {this.name = name;
}
}
注意到 setName() 的参数现在是一个数组。一开始，把 fullname 数组传进去，然后，修改 fullname 数组的内容，结果发现，实例 p 的字段 p.name 也被修改了！
结论
引用类型参数的传递，调用方的变量，和接收方的参数变量，指向的是同一个对象。双方任意一方对这个对象的修改，都会影响对方（因为指向同一个对象嘛）。
有了上面的结论，我们再看一个例子：
// 引用类型参数绑定
public class Main {public static void main(String[] args) {Person p = new Person();
String bob = "Bob";
p.setName(bob); // 传入 bob 变量
System.out.println(p.getName()); // "Bob"
bob = "Alice"; // bob 改名为 Alice
System.out.println(p.getName()); // "Bob" 还是 "Alice"?
}
}
class Person {private String name;
public String getName() {return this.name;
}
public void setName(String name) {this.name = name;
}
}
不要怀疑引用参数绑定的机制，试解释为什么上面的代码两次输出都是"Bob"。
练习
给 Person 类增加 getAge/setAge 方法：
public class Main {public static void main(String[] args) {Person ming = new Person();
ming.setName("小明");
ming.setAge(12);
System.out.println(ming.getAge());
}
}
class Person {private String name;
public String getName() {return name;
}
public void setName(String name) {this.name = name;
}
}
下载练习
小结
-
方法可以让外部代码安全地访问实例字段；
-
方法是一组执行语句，并且可以执行任意逻辑；
-
方法内部遇到 return 时返回，void 表示不返回任何值（注意和返回 null 不同）；
-
外部代码通过 public 方法操作实例，内部代码可以调用 private 方法；
-
理解方法的参数绑定。
