第7周 7.1 面向对象的基本概念

7.1 面向对象的基本概念

7.1.1 类与对象

面向对象编程，是一种通过对象的方式，把现实世界映射到计算机模型的一种编程方法。
面向对象是一种编程思想，它将现实世界中的事物抽象为程序中的对象，每个对象都拥有自己的属性和行为。这种思想强调通过对象之间的交互来实现程序功能，而不是传统的过程式编程中的步骤化操作。
面向对象思想特点

• 让复杂的事情简单化
• 更加符合人的思维习惯
• 让我们从执行者变成指挥者

面向对象三大基本特征：封装、继承、多态

1. 封装
2. 继承
3. 多态

面向对象五大基本原则

1. 单一职责原则（SRP）
2. 开放封闭原则（OCP）
3. 里氏替换原则（LSP）
4. 依赖倒置原则（DIP）
5. 接口隔离原则（ISP）

本单元支技能图谱

graph LR; A(面向对象)-->B1(类与对象) A-->B2(类的成员) A-->B3(继承与多态) A-->B4(包装类和枚举类) A-->B5(数据封装) A-->B6(常用类)

面向过程：

把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
面向对象：
把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来

区别:

面向过程：强调步骤。
面向对象：强调对象，这里的对象就是洗衣机(面向对象的洗衣机有封装好的属性和行为)。

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
现实中，描述一类事物：

属性：就是该事物的状态信息。

行为：就是该事物能够做什么。

对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。（比如上图右边的实体手机）

类与对象的关系

类是对一类事物的描述，是抽象的。

对象是一类事物的实例，是具体的。

类是对象的模板，对象是类的实体

• 手机的设计图可以生成很多型号相同但配置、颜色、内存等不同的手机（实例）。他们个有着相同的属性，但属性的值不同。

• 类产生对象的过程是创建的过程，不是复制的过程。可以根据创建需求，为每个实例的属性添加不同的属性值。如果不另外指定，就采用默认的属性值。得到对象后，你还可以改变属性值，比如把买的电脑升级内存等，或者给手机加一个不同颜色的外壳。

• 我们要先有类，才能有对象。类是对象的模板，对象是类的实体。

• 对象之间通过消息传递进行通信，对象之间通过方法调用进行通信。

• 怎样产生类，就需要对现实世界的事物要有抽象思维，寻找一类事物的通用特征，这些特征就是类的属性，而具体的特征就是类的实例的属性。这一类事物共有的行为就是类中的方法。

• 这种面向对象的的思想，是怎样对应（或映射）到计算机编程世界的呢？毕竟计算机的组成结构和硬件的物理、电气特性与现实世界还是不同的。同学们要带着这些问题去开启面向对象精妙的奇幻之旅，你就能顺利进行面向对象程序设计的世界。当你在进入面向对象的过程中，不防随时回过头来看看，你会发现这些现在看来混沌的问题越来越清晰。

• 面向对象编程需要具有面向对象的思维方式，不然很有可能你使用面向对象的编程语言做的就是面向过程的编程来解决问题。

• 思维的改改变是痛痛的，特别是入门阶段，你用的是现有的思维方法去理解新思维方式，所以会感觉很难，但你要坚持，坚持一段时间，你会发现，原来编程可以这么简单，原来编程可以这么有趣，原来编程可以这么有成就感。

横看成岭侧成峰，远近高低各不同。
不识庐山真面目，只缘身在彼山中。

希望我们通过学习，可以：

初听不识曲中意，再听已是曲中人。

向来心是看客心，奈何人是剧中人

下面我们就开始这个痛并快乐着的奇幻之旅吧。

和面向对象编程不同的，是面向过程编程。面向过程编程，是把模型分解成一步一步的过程。比如，老板告诉你，要编写一个TODO任务，必须按照以下步骤一步一步来：

读取文件；
编写TODO；
保存文件。

而面向对象编程，顾名思义，你得首先有个对象：

类 、对象
类是一类事物的抽象
如书，“书”也是一种抽象的概念，所以它是类，而《Java核心技术》、《Java编程思想》、《Java学习笔记》则是实例

有了对象后，就可以和对象进行互动：

//先运行下面的无单元格，再运行此单元格
GirlFriend gf = new GirlFriend();
gf.name = "西施";
gf.send("花");

//定义一个类
class GirlFriend {
    String name; //姓名
    int age; //芳龄
    String job; //工作
    String address; //住址
    
    //定义一个方法
    void send(String gift){
        System.out.println("给俺女朋友"+name+"送"+gift);
    }
}

因此，面向对象编程，是一种通过对象的方式，把现实世界映射到计算机模型的一种编程方法。

在本章中，我们将讨论：

面向对象的基本概念，包括：

类
实例
方法
java类库

现实世界	计算机模型	Java代码
书	类 / class	class Book
Java核心技术	实例 / book1	Book book1 = new Book()
Java编程思想	实例 / book2	Book book2 = new Book()
Java学习笔记	实例 / book3	Book book3 = new Book()

class和instance[ˈɪnstəns]

// 类和实例

所以，只要理解了class和instance的概念，基本上就明白了什么是面向对象编程。

class是一种对象模版，它定义了如何创建实例，因此，class本身就是一种数据类型：

定义class

义一个class：

class Book {
    public String name;  //书名
    public String author; //作者
    public String isbn; //ISBN书号
    public String publisher; //出版社
    public double price;  //价格
}

一个class可以包含多个字段（field），字段用来描述一个类的特征。上面的Book类，我们定义了四个字段，前三个是String类型的字段，命名为name、author、isbn，一个是int类型的字段，命名为price。因此，通过class，把一组数据汇集到一个对象上，实现了数据封装。
public是用来修饰字段的，它表示这个字段可以被外部访问。

请指出GirlFriend类的各个字段。

创建实例

定义了class，只是定义了对象模版，而要根据对象模版创建出真正的对象实例，必须new操作符。

new操作符可以创建一个实例，然后，我们需要定义一个引用类型的变量来指向这个实例：

Person book = new Book();

上述代码创建了一个Book类型的实例，并通过变量book指向它。

注意区分Book book是定义Book类型的变量book，而new Book()是创建Book类型的实例。

有了指向这个实例的变量，我们就可以通过这个变量来操作实例。访问实例变量可以用

变量.字段

例如：

book.name = "Java编程思想";
book.author = "布鲁斯·埃克尔";  //Bruce Eckel
book.publisher = "机械工业出版社";
book.isbn = "9787115527626";
book.price = 39.9;

Book book2 = new Book();
book2.name = "Java核心技术";
book2.author = "凯·霍斯特曼"; //Cay Horstmann
book2.publisher = "机械工业出版社";
book2.isbn = "9787115515728";//ISBN号
book2.price = 49.9;

graph LR A(book Book实例) --> B1(name=Java编程思想) A(book Book实例) --> B2(author =布鲁斯·埃克尔) A(book Book实例) --> B3(publisher = 机械工业出版社) A(book Book实例) --> B4(isbn = 9787115515728) A(book Book实例) --> B5(price = 39.9)

graph LR A(book2 Book实例) --> B1(name=Java核心技术) A --> B2(author =凯·霍斯特曼) A --> B3(publisher = 机械工业出版社) A --> B4(isbn = 9787115515728) A --> B5(price = 49.9)

注意
一个Java源文件可以包含多个类的定义，但只能定义一个public类，且public类名必须与文件名一致。如果要定义多个public类，必须拆到多个Java源文件中。

成员变量

在Java中，成员变量（如属性和方法）分为静态成员变量和实例成员变量。静态成员变量属于类，而实例成员变量属于实例。

• 静态成员变量通过类名直接访问（不用创建实例）。
• 实例成员变量通过实例访问。

类变量使用static关键字定义，如我们main方法中的static。
类变量与成员变量的通用调用格式如下。

类名.类变量名  //类变量
对象名.成员变量名 //成员变量,

注意
类变量也可以采用试对象名.成员变量名调用，但不推荐，因为编译器在编译时也会把其转换为类名.成员变量名形式存储为字节码。这将增加性能消耗。也无法通过调用名来区分你调用的是成员变量还是类变变量。

java类变量与成员变量的不同应用场景如下。

        Count count1 = new Count();
        System.out.println("coutn1's seria1Number is:" + count1.serialNumber);
        System.out.println("now the value of cont is:" + Count.counter);
        Count count2 = new Count();
        System.out.println("coutn2's seria1Number is:" + count2.serialNumber);
        System.out.println("now the value of cont is:" + count2.counter);

 class Count {

        public int serialNumber;
        public static int counter = 0;
    
        public Count() {
            counter++;
            serialNumber = counter;
        }
    }

练习

请定义一个City类，该class具有如下字段:
name: 名称，String类型
latitude: 纬度，double类型
longitude: 经度，double类型
实例化几个City并赋值，然后打印。

// City城市
public class Main {
    public static void main(String[] args) {
        City bj = new City();
        bj.name = "Beijing";
        bj.latitude = 39.903; // 纬度
        bj.longitude = 116.401; // 经度
        System.out.println(bj.name); 
        System.out.println("location: " + bj.latitude + ", " + bj.longitude);
    }
}

class City {
    ???
}

小结

在OOP中，类和实例和是“模版”和“实例”的关系；

定义class就是定义了一种数据类型，对应的instance是这种数据类型的实例；

class定义的字段（field），每个实例（instance）都会拥有各自的field，且互不干扰；

通过new操作符创建新的instance，然后用变量指向它，即可通过变量来引用这个instance；

访问实例字段的方法是变量名.字段名；

指向instance的变量都是引用变量。

7.1.2 方法

一个class可以包含多个字段(field)，例如，我们给Book类就定义了5个field,下面我以Person类为例来学习。

class Person {
    public String name;
    public int age;
}

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
        Person ming = new Person();
        ming.name = "Xiao Ming"; // 对字段name赋值
        ming.age = 12; // 对字段age赋值

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

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

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

//调用
Person ming = new Person();
ming.setName("Xiao Ming"); // 设置name
ming.setAge(12); // 设置age
System.out.println(ming.getName() + ", " + ming.getAge());

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

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

class Person {
    private String name;
    private int age;

    public String getName() {
        return this.name;
    }
//增加了检查，不请允许输入空串
    public void setName(String name) {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("invalid name");
        }
        this.name = name.strip(); // 去掉首尾空格
    }

    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;
    }
}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字段，但可以通过getName()和getAge()间接获取private字段的值。

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

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

定义方法

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

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

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

public static void main(String[] args) {
    System.out.println("Hello World!");
}

private方法

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

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

class Person {
    private String name;
    private int birth;

    public void setBirth(int birth) {
        this.birth = birth;
    }

    public int getAge() {
        return calcAge(); // 调用private方法
    }

    // private方法:
    private int calcAge() {
        int currentYear = java.time.LocalDate.now().getYear();// 获取当前年份
        return currentYear - this.birth;
       
    }
}

Person ming = new Person();
ming.setBirth(2004);
System.out.println(ming.getAge());

观察上述代码，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 {
    
    String name;
    int age;
    public void setNameAndAge(String name, int age) { 
        this.name = name;
        this.age = age;    
    }
    public void getNameAnndAge() {
        System.out.println("name:" + name + ", age:" + age);
    }
}

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

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

ming.setNameAndAge("Xiao Ming", 20); // 正确
ming.getNameAnndAge();

可变参数

可变参数用类型...定义，可变参数相当于数组类型：

class Group {
    private String[] names;

    public void setNames(String... names) {
        this.names = names;
        System.out.println(Arrays.toString(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;
        System.out.println(Arrays.toString(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,不能不传g.setNames()，与我们前面调用main()方法一样

而可变参数可以保证不会输出null，因为传入0个参数时，接收到的实际值是一个空数组而不是null。

//再次运行上面使用可变参数的Group类，再运行下面代码
Group g = new Group();
g.setNames(); //会输出一个空数组，而不是null

参数值传递和引用传递

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

那什么是参数绑定？

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

// 基本类型参数绑定
class Person {
    private int age;

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
        Person p = new Person();
        int n = 15; // n的值为15
        p.setAge(n); // 传入n的值
        System.out.println("n=15,n的值传给age后，age="+p.getAge()); // 15
        n = 20; // n的值改为20
        System.out.println("n的值改为20后，age="+p.getAge()); // 15还是20?

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

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

// 引用类型参数绑定
class Person {
    private String[] name;

    public String getName() {
        return this.name[0] + " " + this.name[1];
    }

    public void setName(String[] name) {
        this.name = name;
    }
}
        Person p = new Person();
        String[] fullname = new String[] { "安东", "小伟" };
        p.setName(fullname); // 传入fullname数组
        System.out.println(p.getName()); // "安东", "小伟" 
        fullname[0] = "慕容"; // fullname数组的第一个元素修改为"慕容"
        System.out.println(p.getName()); // "安东", "小伟"还是"慕容", "小伟"?

        

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

结论

• 基本类型参数的传递，是调用方值的复制。双方各自的后续修改，互不影响。
• 引用类型参数的传递，调用方的变量，和接收方的参数变量，指向的是同一个对象。双方任意一方对这个对象的修改，都会影响对方（因为指向同一个对象或数据内存单元）。

有了上面的结论，我们再看一个例子：

class Person {
    private String name;

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
// 引用类型参数绑定

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"?

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

练习

class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person ming = new Person();
        ming.setName("小明");
        ming.setAge(12);
        System.out.println(ming.getAge());
    }
}
Main.main(null);

小结

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

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

• 方法内部遇到return时返回，void表示不返回任何值（注意和返回null不同）；

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

• 理解方法的参数绑定。

7.1.3 构造方法

创建实例的时候，我们经常需要同时初始化这个实例的字段，例如：

class Person{
    String name;
    int age;
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
}


Person ming = new Person();
ming.setName("小明");
ming.setAge(12);

初始化对象实例需要3行代码，而且，如果忘了调用setName()或者setAge()，这个实例内部的状态就是不正确的。

能否在创建对象实例时就把内部字段全部初始化为合适的值？

完全可以。

这时，我们就需要构造方法。

创建实例的时候，实际上是通过构造方法来初始化实例的。我们先来定义一个构造方法，能在创建Person实例的时候，一次性传入name和age，完成初始化：

// 构造方法
public class Main {
    public static void main(String[] args) {
        Person p = new Person("Xiao Ming", 15);
        System.out.println(p.getName());
        System.out.println(p.getAge());
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }
}
Main.main(null);

由于构造方法是如此特殊，所以构造方法的名称就是类名。构造方法的参数没有限制，在方法内部，也可以编写任意语句。但是，和普通方法相比，构造方法没有返回值（也没有void），调用构造方法，必须用new操作符。

默认构造方法

是不是任何class都有构造方法？是的。

那前面我们并没有为Person类编写构造方法，为什么可以调用new Person()？

原因是如果一个类没有定义构造方法，编译器会自动为我们生成一个默认构造方法，它没有参数，也没有执行语句，类似这样：

class Person {
    public Person() {
    }
}

要特别注意的是，如果我们自定义了一个构造方法，那么，编译器就不再自动创建默认构造方法：

// 构造方法
public class Main {
    public static void main(String[] args) {
        Person p = new Person(); // 编译错误:找不到这个构造方法
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }
}
Main.main(null);

如果既要能使用带参数的构造方法，又想保留不带参数的构造方法，那么只能把两个构造方法都定义出来：

// 构造方法
public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Xiao Ming", 15); // 既可以调用带参数的构造方法
        Person p2 = new Person(); // 也可以调用无参数构造方法
    }
}

class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }
}
Main.main(null);

没有在构造方法中初始化字段时，引用类型的字段默认是null，数值类型的字段用默认值，int类型默认值是0，布尔类型默认值是false：

class Person {
    private String name; // 默认初始化为null
    private int age; // 默认初始化为0

    public Person() {
    }
}

也可以对字段直接进行初始化：

class Person {
    private String name = "Unamed";
    private int age = 10;
}

那么问题来了：既对字段进行初始化，又在构造方法中对字段进行初始化：

class Person {
    private String name = "Unamed";
    private int age = 10;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

当我们创建对象的时候，new Person("Xiao Ming", 12)得到的对象实例，字段的初始值是啥？

在Java中，创建对象实例的时候，按照如下顺序进行初始化：

先初始化字段，例如，int age = 10;表示字段初始化为10，double salary;表示字段默认初始化为0，String s;表示引用类型字段默认初始化为null；
执行构造方法的代码进行初始化,覆盖字段的初始化值。
因此，构造方法的代码由于后运行，所以，new Person("Xiao Ming", 12)的字段值最终由构造方法的代码确定。

多个构造方法

可以定义多个构造方法，在通过new操作符调用的时候，编译器通过构造方法的参数数量、位置和类型自动区分：

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name) {
        this.name = name;
        this.age = 12;
    }

    public Person() {
    }
}

如果调用new Person("Xiao Ming", 20);，会自动匹配到构造方法public Person(String, int)。

如果调用new Person("Xiao Ming");，会自动匹配到构造方法public Person(String)。

如果调用new Person();，会自动匹配到构造方法public Person()。

一个构造方法可以调用其他构造方法，这样做的目的是便于代码复用。调用其他构造方法的语法是this(…)：

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name) {
        this(name, 18); // 调用另一个构造方法Person(String, int)
    }

    public Person() {
        this("Unnamed"); // 调用另一个构造方法Person(String) Unnamed未命名
    }
}

练习

请给Person类增加(String, int)的构造方法：

public class Main {
    public static void main(String[] args) {
        // TODO: 给Person增加构造方法:
        Person ming = new Person("小明", 12);
        System.out.println(ming.getName());
        System.out.println(ming.getAge());
    }
}

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

小结

实例在创建时通过new操作符会调用其对应的构造方法，构造方法用于初始化实例；

没有定义构造方法时，编译器会自动创建一个默认的无参数构造方法；

可以定义多个构造方法，编译器根据参数自动判断；

可以在一个构造方法内部调用另一个构造方法，便于代码复用。

7.1.4 方法重载

在一个类中，我们可以定义多个方法。如果有一系列方法，它们的功能都是类似的，只有参数有所不同，那么，可以把这一组方法名做成同名方法。例如，在Hello类中，定义多个hello()方法：

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }

    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public void hello(String name, int age) {
        if (age < 18) {
            System.out.println("Hi, " + name + "!");
        } else {
            System.out.println("Hello, " + name + "!");
        }
    }
}

这种方法名相同，但各自的参数不同，称为方法重载（Overload）。

注意：方法重载的返回值类型通常都是相同的。

方法重载的目的是，功能类似的方法使用同一名字，更容易记住，因此，调用起来更简单。

举个例子，String类提供了多个重载方法indexOf()，可以查找子串：

• int indexOf(int ch)：根据字符的Unicode码查找；
• int indexOf(String str)：根据字符串查找；
• int indexOf(int ch, int fromIndex)：根据字符查找，但指定起始位置；
• int indexOf(String str, int fromIndex)根据字符串查找，但指定起始位置。

试一试：

// java库里String.indexOf() 方法重载
public class Main {
    public static void main(String[] args) {
        String s = "Test string";
        int n1 = s.indexOf('t');
        int n2 = s.indexOf("st");
        int n3 = s.indexOf("st", 4);
        System.out.println(n1);
        System.out.println(n2);
        System.out.println(n3);
    }
}
Main.main(null);

3
2
5

练习

给Person增加重载方法setName(String, String)：

public class Main {
    public static void main(String[] args) {
        Person ming = new Person();
        Person hong = new Person();
        ming.setName("Xiao Ming");
        // TODO: 给Person增加重载方法setName(String, String):
        hong.setName("Xiao", "Hong");
        System.out.println(ming.getName());
        System.out.println(hong.getName());
    }
}

class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

小结

方法重载是指多个方法的方法名相同，但各自的参数不同；

重载方法应该完成类似的功能，参考String的indexOf()；

重载方法返回值类型应该相同。