零、this 的本质
🍀 this 的本质是一个隐藏的（若不写也会默认存在）、位置最靠前的方法参数。 【这句话好重要】
看下面的代码:
class ClassOne {
public int num0 = 520;
public void test(int num1, int num2) {
System.out.println(num0 + num1 + num2);
}
}
public class ThisTheory {
public static void main(String[] args) {
ClassOne classOne = new ClassOne();
classOne.test(1, 2); // 523
}
}我们对上面的代码做下面的操作，看看会发生什么?
🌼 ① 当在类 ClassOne 的 test 方法的参数列表的第一个参数的前面增加一个参数 （ClassOne classOne）的时候，你会看到 main 方法中classOne.test(1, 2);语句的报错（如下图）。这一报错非常容易理解， ClassOne 类中的 test 方法需要 3个参数，而调用 test 方法的时候只传入了两个参数，不报错才怪😏。
🌼 ② 把上面的操作中添加的参数的参数名修改为 this，你会发现：不报错，并且代码可以正常运行😀（如下图）。【说明： this 的本质的确是一个隐藏的方法参数】
🌼 ③ 把【
ClassOne this】移动到其他参数之后（不作为参数列表的第一个参数），你会发现：又报错了
这次报错有一个很友好的报错信息【The receiver should be the first parameter】这个接受者应该是第一个参数。【说明：this 的本质的确是一个位置最靠前的方法参数】
再看下面的代码：
class ClassOne {
public int num0 = 520;
public void test(int num1, int num2) {
// test()_this: com.gq.ClassOne@1540e19d
System.out.println("test()_this: " + this);
System.out.println(num0 + num1 + num2);
}
}
public class ThisTheory {
public static void main(String[] args) {
ClassOne cls1 = new ClassOne();
// main()_cls1: com.gq.ClassOne@1540e19d
System.out.println("\nmain()_cls1: " + cls1);
cls1.test(1, 2); // 523
}
}🌼 ① 在 main 方法中打印了调用 test 方法的对象的引用【 cls1】；在 test 方法中打印了 this
🌼 ② 可以看到的是： 调用 test 方法的对象的引用【 cls1】和 test 方法中的 this 指向的是同一个对象
🌼 你可以记这样一个结论： 调用实例方法的时候，会把调用该方法的对象的引用作为参数传到该方法的第一个参数中。而最终调用该方法的对象的引用的值会被传给该方法的的隐藏的，位置最靠前的 this 参数一定要记住：🍀 this 的本质是一个隐藏的、位置最靠前的方法参数。
一、看一个简单的关于多态的例子
💜 上一节详细说明了【 this 的本质是一个隐藏的、位置最靠前的方法参数】，这个结论在后面会使用到，请牢记。
看下面这个简单的关于多态的例子, 思考它的打印结果：
class A {
public int i = 1;
public int sum1() {
return getI() + 2;
}
public int sum2() {
return i + 2;
}
public int getI() {
return i;
}
}
/**
* B 类继承 A 类
*/
class B extends A {
public int i = 3;
public int sum1() {
return getI() + 3;
}
public int sum2() {
return i;
}
public int getI() {
return i + 3;
}
}
public class DynamicBinding {
public static void main(String[] args) {
A a = new B();
System.out.println("main_a.i: " + a.i);
System.out.println("main_a.sum1: " + a.sum1());
System.out.println("main_a.sum2: " + a.sum2());
}
}🌱 上面的代码并不难，只涉及【多态】的相关知识，下面通过代码注释解释一下：
public class DynamicBinding {
public static void main(String[] args) {
// 父类类型的引用 a 指向子类（B）对象【向上转型】
// a 的编译类型是【A】; a 的运行类型是【B】
A a = new B();
// 访问 a 指向的对象的属性, 实际上是访问 a 的编译类型的属性
// a 的编译类型是【A】, 【A】中的 i 属性的值是【1】
// 所以打印结果是: main_a.i: 1
System.out.println("main_a.i: " + a.i);
// 用 a 调用方法 sum1: 从 a 的运行类型【B】开始找 sum1 方法
// 若【B】中有 sum1 方法就调用【B】中的 sum1 方法
// 否则调用 a 的运行类型的父类型中的 sum1 方法
// 在本案例中【B】中存在 sum1 方法, 所以调用【B】中的 sum1 方法
// 最终打印结果是：main_a.sum1: 9
System.out.println("main_a.sum1: " + a.sum1());
// 此处和调用【a.sum1()】是一样的
// 最终的打印结果是：main_a.sum2: 3
System.out.println("main_a.sum2: " + a.sum2());
}
}二、对上面案例的提升
看下面的代码, 思考打印结果：
class A {
public int i = 1;
public int sum() {
return getI() + i;
}
public int getI() {
return i;
}
}
/**
* B 类继承 A 类
*/
class B extends A {
public int i = 3;
public int getI() {
return i + 3;
}
}
public class DynamicBinding {
public static void main(String[] args) {
A a = new B();
// 思考下面的代码的打印结果？
System.out.println("main_a.sum: " + a.sum());
}
}☃️ ① a 的运行类型是【B】，a.sum()的时候会把 a 传递给sum()的第一个参数
☃️ ② 进入sum()后的代码如下图红圈所示：
☃️ ③ 上图中的 this 和 a 指向的是同一个对象
☃️ ④ a 的运行类型是 B，所以调用this.getI()是从 B 中开始找getI()方法，当 B 中找不到的时候，才在 B 的父类型中找。本案例中， B 中是有getI()方法的，所以调用的是 B 中的getI()方法。调用后的结果是： 6
☃️ ⑤ this 和 a 是一样的， a 的编译类型是 A，所以 this 的编译类型也是 A
☃️ ⑥this.i就类似a.i，a.i的值是 1，所以this.i的值是： 1
☃️ ⑦ 最终调用sum()的值是： 7
三、动态绑定机制
🥤 1、调用实例方法的时候，该方法会和该对象（或称该对象的引用）绑定
🌱 调用实例方法的时候，该方法会和该对象的内存地址（运行类型）绑定🥤 2、调用对象属性的时候，没有动态绑定机制，那里声明，那里使用
class A {
public int i = 1;
public int sum() {
return getI() + i;
}
public int getI() {
return i;
}
}
/**
* B 类继承 A 类
*/
class B extends A {
public int i = 3;
public int getI() {
return i + 3;
}
}
public class DynamicBinding {
public static void main(String[] args) {
A a = new B();
// main_a.sum: 7
System.out.println("main_a.sum: " + a.sum());
}
}
🌱 上面代码的运行结果也可通过【动态绑定机制】分析出来
🌱 调用 sum 方法的时候，sum 方法会和 a 的运行类型绑定
🌱 在 sum 方法内部调用getI()方法的时候调用的就是 a 的运行类型中的方法，或 a 的运行类型的父类型的方法（先从子类开始找，子类找不到才在父类中找）
🌱 调用属性没有动态绑定机制，所以a.i的值就是 A 类中的 1
四、多态的引用
多态数组
🍀 数组的定义类型为父类类型，里面保存的实际元素的类型为子类类型或数组定义的类型。
🍀 编写程序要求：创建1个 Person 对象、2个 Student 对象和2个 Teacher 对象和一个 Person[] 类型的数组。把之前创建的 Person 对象、Student 对象、Teacher 对象统一放在Person[]数组 中，并调用每个对象的show()方法。Teacher 类中有一独特的 teach 方法，Student 类中有一独特的 study 方法。编写代码，让 Teacher 对象和 Student 对象可以调用它们独特的方法。
非常简单，代码如下：
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String show() {
return "Person_" + name + "_" + age;
}
}
class Student extends Person {
private double score;
public Student(String name, int age, double score) {
super(name, age);
this.score = score;
}
public String show() {
return "Student_" + getName() + "_" + getAge() + "_" + score;
}
public void study() {
System.out.println(getName() + "_" + "study()");
}
}
class Teacher extends Person {
private double money;
public Teacher(String name, int age, double money) {
super(name, age);
this.money = money;
}
public String show() {
return "Teacher_" + getName() + "_" + getAge() + "_" + money;
}
public void teach() {
System.out.println(getName() + "_" + "teach()");
}
}
public class PolyArray {
public static void main(String[] args) {
// 创建一个多态数组
Person[] persons = new Person[5];
persons[0] = new Person("张思瑞", 12);
persons[1] = new Student("张浩男", 15, 99.5);
persons[2] = new Student("庆医", 16, 100);
persons[3] = new Teacher("李世民", 26, 12032);
persons[4] = new Teacher("安静然", 25, 6600);
// 遍历后, 调用 show 方法
for (Person person : persons) {
if (person instanceof Student) {
((Student) person).study();
} else if ((person instanceof Teacher)) {
((Teacher) person).teach();
}
System.out.println(person.show());
}
/*
output:
Person_张思瑞_12
张浩男_study()
Student_张浩男_15_99.5
庆医_study()
Student_庆医_16_100.0
李世民_teach()
Teacher_李世民_26_12032.0
安静然_teach()
Teacher_安静然_25_6600.0
*/
}
}这篇文章涉及了很多我自己的想法，若有错误请不吝赐教！
