多态

README.md

@@ -380,7 +380,8 @@
 - [本科读者小公司一年工作经验社招拿下阿里美团头条京东滴滴等 offer✌️](docs/nice-article/weixin/shezynmjfxhelmtttjddd.md)
 - [非科班读者，用一年时间社招拿下阿里 Offer✌️](docs/nice-article/weixin/xuelybdzheloffer.md)
 - [二本读者社招两年半10家公司28轮面试面经✌️](docs/nice-article/weixin/huanxgzl.md)
-- [双非一本秋招收获腾讯ieg、百度、字节等6家大厂offer](docs/nice-article/weixin/quzjlsspdx.md)
+- [双非一本秋招收获腾讯ieg、百度、字节等6家大厂offer✌️](docs/nice-article/weixin/quzjlsspdx.md)
+- [双非学弟收割阿里、字节、B站校招 offer，附大学四年硬核经验总结✌️](docs/nice-article/weixin/zheisnylzldhzd.md)
 
 
 ## 面试准备
@@ -391,6 +392,7 @@
 - [校招时间节点、简历编写、笔试、HR面、实习等注意事项💪](docs/nice-article/weixin/youdxzhhmjzlycfx.md)
 
 
+
 ## 城市选择
 
 - [北京都有哪些值得加入的IT互联网公司？](docs/cityselect/beijing.md)

docs/.vuepress/sidebar.ts

@@ -118,7 +118,8 @@ export const sidebarConfig = sidebar({
           "basic-extra-meal/override-overload",
           "oo/static",
           "oo/final",
-          "oo/bigsai",
+          "oo/extends-bigsai",
+          "oo/polymorphism",
           {
             text: "instanceof",
             link: "oo/instanceof",
@@ -810,6 +811,7 @@ export const sidebarConfig = sidebar({
             "nice-article/weixin/miansmtgl",
             "nice-article/weixin/luoczbmsddyb",
             "nice-article/weixin/youdxzhhmjzlycfx",
+            "nice-article/weixin/zheisnylzldhzd",
           ],
         },
         {

docs/home.md

@@ -146,6 +146,7 @@ head:
 - [一文彻底搞懂 Java static 关键字：静态变量、静态方法、静态代码块、静态内部类](oo/static.md)
 - [一文彻底搞懂 Java final 关键字](oo/final.md)
 - [一万字彻底搞懂 Java 继承](oo/extends-bigsai.md)
+- [几句话，直观解释清楚 Java 多态](oo/polymorphism.md)
 - [Java instanceof关键字用法](oo/instanceof.md)
 - [深入理解Java中的不可变对象](basic-extra-meal/immutable.md)
 - [Java中可变参数的使用](basic-extra-meal/varables.md)
@@ -397,7 +398,8 @@ head:
 - [本科读者小公司一年工作经验社招拿下阿里美团头条京东滴滴等 offer✌️](nice-article/weixin/shezynmjfxhelmtttjddd.md)
 - [非科班读者，用一年时间社招拿下阿里 Offer✌️](nice-article/weixin/xuelybdzheloffer.md)
 - [二本读者社招两年半10家公司28轮面试面经✌️](nice-article/weixin/huanxgzl.md)
-- [双非一本秋招收获腾讯ieg、百度、字节等6家大厂offer](nice-article/weixin/quzjlsspdx.md)
+- [双非一本秋招收获腾讯ieg、百度、字节等6家大厂offer✌️](nice-article/weixin/quzjlsspdx.md)
+- [双非学弟收割阿里、字节、B站校招 offer，附大学四年硬核经验总结✌️](nice-article/weixin/zheisnylzldhzd.md)
 
 ### 面试准备
 

docs/oo/extends-bigsai.md

@@ -2,10 +2,10 @@
 title: 一万字彻底搞懂 Java 继承
 shortTitle: 一万字彻底搞懂Java继承
 description: Java程序员进阶之路，小白的零基础Java教程，认真聊聊 Java的三大特征：继承
-tags:
-  -  网络爬虫
 category:
-  - 其他网站
+  - Java 核心
+tag:
+  - 面向对象编程
 head:
   - - meta
     - name: keywords

docs/oo/polymorphism.md

+---
+title: 几句话，直观解释清楚 Java 多态
+shortTitle: 几句话直观解释Java多态
+description: Java程序员进阶之路，小白的零基础Java教程，认真聊聊 Java的三大特征：多态
+category:
+  - Java 核心
+tag:
+  - 面向对象编程
+head:
+  - - meta
+    - name: keywords
+      content: Java,Java SE,Java 基础,Java 教程,Java 程序员进阶之路,Java 入门,Java 多态
+---
+
+**多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编译时并不确定，而是在程序运行期间才确定。**
+
+**即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。**
+
+**因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。**
+
+再具体的分析一下。
+
+## 01、多态是什么
+
+在我刻板的印象里，西游记里的那段孙悟空和二郎神的精彩对战就能很好的解释“多态”这个词：一个孙悟空，能七十二变；一个二郎神，也能七十二变；他们都可以变成不同的形态，但只需要悄悄地喊一声“变”。
+
+Java的多态是什么呢？其实就是一种能力——同一个行为具有不同的表现形式；换句话说就是，执行一段代码，Java 在运行时能根据对象的不同产生不同的结果。和孙悟空和二郎神都只需要喊一声“变”，然后就变了，并且每次变得还不一样；一个道理。
+
+多态的前提条件有三个：
+
+*   子类继承父类
+*   子类覆盖父类的方法
+*   父类引用指向子类对象
+
+多态的一个简单应用，来看程序清单1-1：
+
+```java
+//子类继承父类
+public class Wangxiaoer extends Wanger {
+    public void write() { // 子类覆盖父类方法
+        System.out.println("记住仇恨，表明我们要奋发图强的心智");
+    }
+
+    public static void main(String[] args) {
+        // 父类引用指向子类对象
+        Wanger[] wangers = { new Wanger(), new Wangxiaoer() };
+
+        for (Wanger wanger : wangers) {
+            // 对象是王二的时候输出：勿忘国耻
+            // 对象是王小二的时候输出：记住仇恨，表明我们要奋发图强的心智
+            wanger.write();
+        }
+    }
+}
+
+class Wanger {
+    public void write() {
+        System.out.println("勿忘国耻");
+    }
+}
+```
+
+## 02、多态与后期绑定
+
+现在，我们来思考一个问题：程序清单1-1在执行 `wanger.write()` 时，由于编译器只有一个 Wanger 引用，它怎么知道究竟该调用父类 Wanger 的 `write()` 方法，还是子类 Wangxiaoer 的 `write()` 方法呢？
+
+答案是在运行时根据对象的类型进行后期绑定，编译器在编译阶段并不知道对象的类型，但是Java的方法调用机制能找到正确的方法体，然后执行出正确的结果。
+
+多态机制提供的一个重要的好处程序具有良好的扩展性。来看程序清单2-1：
+
+```java
+//子类继承父类
+public class Wangxiaoer extends Wanger {
+    public void write() { // 子类覆盖父类方法
+        System.out.println("记住仇恨，表明我们要奋发图强的心智");
+    }
+    
+    public void eat() {
+        System.out.println("我不喜欢读书，我就喜欢吃");
+    }
+
+    public static void main(String[] args) {
+        // 父类引用指向子类对象
+        Wanger[] wangers = { new Wanger(), new Wangxiaoer() };
+
+        for (Wanger wanger : wangers) {
+            // 对象是王二的时候输出：勿忘国耻
+            // 对象是王小二的时候输出：记住仇恨，表明我们要奋发图强的心智
+            wanger.write();
+        }
+    }
+}
+
+class Wanger {
+    public void write() {
+        System.out.println("勿忘国耻");
+    }
+    
+    public void read() {
+        System.out.println("每周读一本好书");
+    }
+}
+```
+
+在程序清单 2-1 中，我们在 Wanger 类中增加了 read() 方法，在 Wangxiaoer 类中增加了eat()方法，但这丝毫不会影响到 write() 方法的调用。write() 方法忽略了周围代码发生的变化，依然正常运行。这让我想起了金庸《倚天屠龙记》里九阳真经的口诀：“他强由他强，清风拂山岗；他横由他横，明月照大江。”
+
+多态的这个优秀的特性，让我们在修改代码的时候不必过于紧张，因为多态是一项让程序员“将改变的与未改变的分离开来”的重要特性。
+
+## 03、多态与构造器
+
+在构造器中调用多态方法，会产生一个奇妙的结果，我们来看程序清单3-1：
+
+```java
+public class Wangxiaosan extends Wangsan {
+    private int age = 3;
+    public Wangxiaosan(int age) {
+        this.age = age;
+        System.out.println("王小三的年龄：" + this.age);
+    }
+    
+    public void write() { // 子类覆盖父类方法
+        System.out.println("我小三上幼儿园的年龄是：" + this.age);
+    }
+    
+    public static void main(String[] args) {
+        new Wangxiaosan(4);
+//      上幼儿园之前
+//      我小三上幼儿园的年龄是：0
+//      上幼儿园之后
+//      王小三的年龄：4
+    }
+}
+
+class Wangsan {
+    Wangsan () {
+        System.out.println("上幼儿园之前");
+        write();
+        System.out.println("上幼儿园之后");
+    }
+    public void write() {
+        System.out.println("老子上幼儿园的年龄是3岁半");
+    }
+}
+```
+
+从输出结果上看，是不是有点诧异？明明在创建 Wangxiaosan 对象的时候，年龄传递的是 4，但输出结果既不是“老子上幼儿园的年龄是 3 岁半”，也不是“我小三上幼儿园的年龄是：4”。
+
+为什么？
+
+因为在创建子类对象时，会先去调用父类的构造器，而父类构造器中又调用了被子类覆盖的多态方法，由于父类并不清楚子类对象中的属性值是什么，于是把int类型的属性暂时初始化为 0，然后再调用子类的构造器（子类构造器知道王小二的年龄是 4）。
+
+## 04、多态与向下转型
+
+向下转型是指将父类引用强转为子类类型；这是不安全的，因为有的时候，父类引用指向的是父类对象，向下转型就会抛出 ClassCastException，表示类型转换失败；但如果父类引用指向的是子类对象，那么向下转型就是成功的。
+
+来看程序清单4-1：
+
+```text
+public class Wangxiaosi extends Wangsi {
+    public void write() {
+        System.out.println("记住仇恨，表明我们要奋发图强的心智");
+    }
+
+    public void eat() {
+        System.out.println("我不喜欢读书，我就喜欢吃");
+    }
+
+    public static void main(String[] args) {
+        Wangsi[] wangsis = { new Wangsi(), new Wangxiaosi() };
+
+        // wangsis[1]能够向下转型
+        ((Wangxiaosi) wangsis[1]).write();
+        // wangsis[0]不能向下转型
+        ((Wangxiaosi)wangsis[0]).write();
+    }
+}
+
+class Wangsi {
+    public void write() {
+        System.out.println("勿忘国耻");
+    }
+
+    public void read() {
+        System.out.println("每周读一本好书");
+    }
+}
+```
+
+----
+
+最近整理了一份牛逼的学习资料，包括但不限于Java基础部分（JVM、Java集合框架、多线程），还囊括了 **数据库、计算机网络、算法与数据结构、设计模式、框架类Spring、Netty、微服务（Dubbo，消息队列） 网关** 等等等等……详情戳：[可以说是2022年全网最全的学习和找工作的PDF资源了](https://tobebetterjavaer.com/nice-article/itmind/nice-article/itmind/miansjavamsdhmsmsbdjavabdjavaxxzlmsxxzlmszlzlxzmszlfxjlzl.html)
+
+关注二哥的原创公众号 **沉默王二**，回复**111** 即可免费领取。
+
+![](http://cdn.tobebetterjavaer.com/tobebetterjavaer/images/xingbiaogongzhonghao.png)