Java面向对象1--方法

每一个类中可以定义多个参数，参数的属性可以分为公有的，私有的等等，即public，private，区别在于作用的范围，定义公有的类，方法或参数，外部的方法中可以调用使用，但是private只作用于本类中，若外部需要使用的话，需本类定义一个公有的方法，在公有的方法中调用私有的参数或方法，才可以调用到私有的参数或方法。

定义私有的方法或参数的原因

：为了在使用方法或参数的时候可以进行校验，更好的保障参数在使用时的合理性，防止外部可能会破坏封装性。

get，set方法

参数的私有化，可以通过get和set方法进行定义和获取。

在set方法中，使用private参数的时候，会用this.name来表示，是因为return中的其实也是this.参数名，只是其中不存在参数名冲突，可以省略，而在set方法中需要传递参数为name的值，所以为了区分，this不可省略。

例如，创建一个人的对象，对象中带有姓名和年龄两个参数，通过get和set进行对年龄和姓名的获取和定义。同时，通过set的方法对于赋值的参数进行校验，看是否符合常理。

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;
    }
}

输出：XiaoMing，12

方法的定义：

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

 方法参数

一个方法中可以有0个参数，也可以有多个参数。调用时，必须严格按照定义的方法进行调用。

例如：

public void setNameAndAge(String name, int age) {
        ...
    }

则调用该方法时，必须传递两个参数，并且第一个为字符型，第二个为整型。 

可变参数

定义：类型...

例如：

class Group {
    private String[] names;

    public void setNames(String... names) {
        this.names = names;
    }
}

调用可写的方法：

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

 也可以直接将names定义为String类型的数组，但是在调用时，就必须创建一个数组进行赋值。

class Group {
    private String[] names;

    public void setNames(String[] names) {
        this.names = names;
    }
}

调用：

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

使用可变参数的好处是，放调用方传入null时，可变参数存储的值不是null，而是空数组。

参数绑定

当定义的使用set和get方法时，是通过调用方法获取参数的值。当定义的参数为基本变量的时候，调用set，在调用get后，改变定义的参数的值，而调用的值不会改变，因为基本参数set是将定义的值的参数值进行复制放入。而引用型数组的存放和调用就不同，若改变数组的值，再获取值时，也会将get的值进行改变。

例如：

基本类型的参数绑定

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;
    }
}

结果：

引用类型的参数绑定：

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;
    }
}

 结果：

 注意的是，String也是引用类型，但是不会因为值的改变而改变。和基本类型的参数绑定一样。

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;
    }
}

 结果：