一前言
时隔近一个月之后，我将继续更新我的学习内容，一天或许会更新不止一篇内容，欢迎关注。
二主要内容
面向对象编程，是一种通过对象的方式，把现实世界映射到计算机模型的一种编程方法。
现实世界中，我们定义了“人”这种抽象概念，而具体的人则是“小明”、“小红”、“小军”等一个个具体的人。所以，“人”可以定义为一个类（class），而具体的人则是实例（instance）：
| 现实世界 | 计算机模型 | Java代码 |
|---|---|---|
| 人 | 类 / class | class Person { } |
| 小明 | 实例 / ming | Person ming = new Person() |
| 小红 | 实例 / hong | Person hong = new Person() |
| 小军 | 实例 / jun | Person jun = new Person() |
同样的，“书”也是一种抽象的概念，所以它是类，而《Java核心技术》、《Java编程思想》、《Java学习笔记》则是实例：
| 现实世界 | 计算机模型 | Java代码 |
|---|---|---|
| 书 | 类 / class | class Book { } |
| Java核心技术 | 实例 / book1 | Book book1 = new Book() |
| Java编程思想 | 实例 / book2 | Book book2 = new Book() |
| Java学习笔记 | 实例 / book3 | Book book3 = new Book() |
定义class
在Java中，创建一个类，例如，给这个类命名为Person，就是定义一个class：
class Person { public String name; public int age; }一个class可以包含多个字段（field），字段用来描述一个类的特征。上面的Person类，我们定义了两个字段，一个是String类型的字段，命名为name，一个是int类型的字段，命名为age。因此，通过class，把一组数据汇集到一个对象上，实现了数据封装。
public是用来修饰字段的，它表示这个字段可以被外部访问。
我们再看另一个Book类的定义：
class Book { public String name; public String author; public String isbn; public double price; }请指出Book类的各个字段。
创建实例
定义了class，只是定义了对象模版，而要根据对象模版创建出真正的对象实例，必须用new操作符。
new操作符可以创建一个实例，然后，我们需要定义一个引用类型的变量来指向这个实例：
Person ming = new Person();上述代码创建了一个Person类型的实例，并通过变量ming指向它。
注意区分Person ming是定义Person类型的变量ming，而new Person()是创建Person实例。
有了指向这个实例的变量，我们就可以通过这个变量来操作实例。访问实例变量可以用变量.字段，例如：
ming.name = "Xiao Ming"; // 对字段name赋值 ming.age = 12; // 对字段age赋值 System.out.println(ming.name); // 访问字段name Person hong = new Person(); hong.name = "Xiao Hong"; hong.age = 15;上述两个变量分别指向两个不同的实例，它们在内存中的结构如下：
┌──────────────────┐ ming ──────▶│Person instance │ ├──────────────────┤ │name = "Xiao Ming"│ │age = 12 │ └──────────────────┘ ┌──────────────────┐ hong ──────▶│Person instance │ ├──────────────────┤ │name = "Xiao Hong"│ │age = 15 │ └──────────────────┘两个instance拥有class定义的name和age字段，且各自都有一份独立的数据，互不干扰。
注意一个Java源文件可以包含多个类的定义，但只能定义一个public类，且public类名必须与文件名一致。如果要定义多个public类，必须拆到多个Java源文件中。（类似于c中只能有一个main函数）
一个class可以包含多个field，例如，我们给Person类就定义了两个field：
class Person { public String name; public int age; }但是，直接把field用public暴露给外部可能会破坏封装性。比如，代码可以这样写：
显然，直接操作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"); // 编译错误：参数类型不对参数绑定
调用方把参数传递给实例方法时，调用时传递的值会按参数位置一一绑定。
那什么是参数绑定？
我们先观察一个基本类型参数的传递：
// 基本类型参数绑定 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"。(类似于局部变量和全局变量）
小结
方法可以让外部代码安全地访问实例字段；
方法是一组执行语句，并且可以执行任意逻辑；
方法内部遇到return时返回，void表示不返回任何值（注意和返回null不同）；
外部代码通过public方法操作实例，内部代码可以调用private方法；
理解方法的参数绑定。
三最后一语
假期学习总是困难的，我也需要克服，大家也一起开始学习吧
勇敢点，让你成为你自己的一切。寻求你的真理；构建你的人生，美丽的人生；坚强起来，不顾一切地寻找自己。
—— 西蒙娜·德·波伏娃 《青春手记》
感谢观看，共勉！！
