方法

一个class可以包含多个field,例如,我们给Person类就定义了两个field

  1. class Person {
  2. public String name;
  3. public int age;
  4. }

但是,直接把fieldpublic暴露给外部可能会破坏封装性。比如,代码可以这样写:

  1. Person ming = new Person();
  2. ming.name = "Xiao Ming";
  3. ming.age = -99; // age设置为负数

显然,直接操作field,容易造成逻辑混乱。为了避免外部代码直接去访问field,我们可以用private修饰field,拒绝外部访问:

  1. class Person {
  2. private String name;
  3. private int age;
  4. }

试试private修饰的field有什么效果:

方法 - 图1

是不是编译报错?把访问field的赋值语句去了就可以正常编译了。

buduijin

fieldpublic改成private,外部代码不能访问这些field,那我们定义这些field有什么用?怎么才能给它赋值?怎么才能读取它的值?

所以我们需要使用方法(method)来让外部代码可以间接修改field

方法 - 图3

虽然外部代码不能直接修改private字段,但是,外部代码可以调用方法setName()setAge()来间接修改private字段。在方法内部,我们就有机会检查参数对不对。比如,setAge()就会检查传入的参数,参数超出了范围,直接报错。这样,外部代码就没有任何机会把age设置成不合理的值。

setName()方法同样可以做检查,例如,不允许传入null和空字符串:

  1. public void setName(String name) {
  2. if (name == null || name.isBlank()) {
  3. throw new IllegalArgumentException("invalid name");
  4. }
  5. this.name = name.strip(); // 去掉首尾空格
  6. }

同样,外部代码不能直接读取private字段,但可以通过getName()getAge()间接获取private字段的值。

所以,一个类通过定义方法,就可以给外部代码暴露一些操作的接口,同时,内部自己保证逻辑一致性。

调用方法的语法是实例变量.方法名(参数);。一个方法调用就是一个语句,所以不要忘了在末尾加;。例如:ming.setName("Xiao Ming");

定义方法

从上面的代码可以看出,定义方法的语法是:

  1. 修饰符 方法返回类型 方法名(方法参数列表) {
  2. 若干方法语句;
  3. return 方法返回值;
  4. }

方法返回值通过return语句实现,如果没有返回值,返回类型设置为void,可以省略return

private方法

public方法,自然就有private方法。和private字段一样,private方法不允许外部调用,那我们定义private方法有什么用?

定义private方法的理由是内部方法是可以调用private方法的。例如:

方法 - 图4

观察上述代码,calcAge()是一个private方法,外部代码无法调用,但是,内部方法getAge()可以调用它。

此外,我们还注意到,这个Person类只定义了birth字段,没有定义age字段,获取age时,通过方法getAge()返回的是一个实时计算的值,并非存储在某个字段的值。这说明方法可以封装一个类的对外接口,调用方不需要知道也不关心Person实例在内部到底有没有age字段。

this变量

在方法内部,可以使用一个隐含的变量this,它始终指向当前实例。因此,通过this.field就可以访问当前实例的字段。

如果没有命名冲突,可以省略this。例如:

  1. class Person {
  2. private String name;
  3. public String getName() {
  4. return name; // 相当于this.name
  5. }
  6. }

但是,如果有局部变量和字段重名,那么局部变量优先级更高,就必须加上this

  1. class Person {
  2. private String name;
  3. public void setName(String name) {
  4. this.name = name; // 前面的this不可少,少了就变成局部变量name了
  5. }
  6. }

方法参数

方法可以包含0个或任意个参数。方法参数用于接收传递给方法的变量值。调用方法时,必须严格按照参数的定义一一传递。例如:

  1. class Person {
  2. ...
  3. public void setNameAndAge(String name, int age) {
  4. ...
  5. }
  6. }

调用这个setNameAndAge()方法时,必须有两个参数,且第一个参数必须为String,第二个参数必须为int

  1. Person ming = new Person();
  2. ming.setNameAndAge("Xiao Ming"); // 编译错误:参数个数不对
  3. ming.setNameAndAge(12, "Xiao Ming"); // 编译错误:参数类型不对

可变参数

可变参数用类型…定义,可变参数相当于数组类型:

  1. class Group {
  2. private String[] names;
  3. public void setNames(String... names) {
  4. this.names = names;
  5. }
  6. }

上面的setNames()就定义了一个可变参数。调用时,可以这么写:

  1. Group g = new Group();
  2. g.setNames("Xiao Ming", "Xiao Hong", "Xiao Jun"); // 传入3个String
  3. g.setNames("Xiao Ming", "Xiao Hong"); // 传入2个String
  4. g.setNames("Xiao Ming"); // 传入1个String
  5. g.setNames(); // 传入0个String

完全可以把可变参数改写为String[]类型:

  1. class Group {
  2. private String[] names;
  3. public void setNames(String[] names) {
  4. this.names = names;
  5. }
  6. }

但是,调用方需要自己先构造String[],比较麻烦。例如:

  1. Group g = new Group();
  2. g.setNames(new String[] {"Xiao Ming", "Xiao Hong", "Xiao Jun"}); // 传入1个String[]

另一个问题是,调用方可以传入null

  1. Group g = new Group();
  2. g.setNames(null);

而可变参数可以保证无法传入null,因为传入0个参数时,接收到的实际值是一个空数组而不是null

参数绑定

调用方把参数传递给实例方法时,调用时传递的值会按参数位置一一绑定。

那什么是参数绑定?

我们先观察一个基本类型参数的传递:

方法 - 图5

运行代码,从结果可知,修改外部的局部变量n,不影响实例page字段,原因是setAge()方法获得的参数,复制了n的值,因此,p.age和局部变量n互不影响。

结论:基本类型参数的传递,是调用方值的复制。双方各自的后续修改,互不影响。

我们再看一个传递引用参数的例子:

方法 - 图6

注意到setName()的参数现在是一个数组。一开始,把fullname数组传进去,然后,修改fullname数组的内容,结果发现,实例p的字段p.name也被修改了!

结论:引用类型参数的传递,调用方的变量,和接收方的参数变量,指向的是同一个对象。双方任意一方对这个对象的修改,都会影响对方(因为指向同一个对象嘛)。

有了上面的结论,我们再看一个例子:

方法 - 图7

不要怀疑引用参数绑定的机制,试解释为什么上面的代码两次输出都是"Bob"

练习

方法 - 图8

下载练习:给Person类增加getAge/setAge方法 (推荐使用IDE练习插件快速下载)

小结

  • 方法可以让外部代码安全地访问实例字段;

  • 方法是一组执行语句,并且可以执行任意逻辑;

  • 方法内部遇到return时返回,void表示不返回任何值(注意和返回null不同);

  • 外部代码通过public方法操作实例,内部代码可以调用private方法;

  • 理解方法的参数绑定。

读后有收获可以支付宝请作者喝咖啡,读后有疑问请加微信群讨论

方法 - 图9方法 - 图10