Java的面向对象 -- 方法

一个 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 有什么效果：

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 ：

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 方法的。例如：

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 int calcAge(int currentYear) {   // private方法
        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;
    }
}