面向对象

1 封装

2 继承

继承让 protected 关键字有意义
Java支持子类重写父类方法。
final 修饰的方法不能被继承。
private 修饰的方法不能被继承。

2.1 层次性

• 通过 extends关键字实现

• 所有对象都继承 java.lang.Object

  2.2 构造函数

  2.2.1 Why 子类会默认初始化父类的构造函数

• 不然子类就没办法调用父类的方法

• 所以Java会默认生成无参的构造函数（这个是重点）

2.2.2 调用父类方法用 super 关键字

• 不然会产生递归，造成死循环呀。

代码示例 oop包路径下

# 执行结果
NormalUser Constructor
VipUser Constructor
SuperVipUser Constructor
我是普通用户SVIP
我是VIP用户，我可以点播
我是SVIP用户，我有一些钱
我是SVIP用户，我可以跳过广告

2.3 继承VS组合

继承和组合都是复用类的常用手段。
继承是 is-a（是一个） 关系。
组合是 has-a（有一个） 关系。
多用继承少于组合。
在使用继承的时候要考虑子类会不会存在向上转型，如果存在向上转型就必须使用继承。

3 多态

基于继承体系。
改善代码组织结构和可读性。

3.1 原理

动态绑定：运行是根据对象的类型进行绑定。所以就可以向上转型，传递父类对象，触发的是子类的行为。
private static``final类级别的标识符不存在动态绑定。
构造函数，其实本质也是static方法。
构造器内部进行多态调用

• 由于继承初始化的特性，会导致初始化子类，初始化父类。
• 父类构造函数执行多态方法，绑定的是当前对象的，不是子类对象。

3.2 两种方式

• 继承 ```java class Music { public static void tune(Instrument instrument) {

    instrument.play();

  } public static void main(String[] args) {

    Instrument instrument = new Guitar();
    // 多态向上转型
    tune(instrument);

  } }

class Guitar extends Instrument { private String name; @Override public void play() { System.out.println(“Guitar.play()”); }

} class Instrument { private String name; public void play() { System.out.println(“Instrument.play()”); } }

- 组合
```java
public class DelegateStage {
    public static void main(String[] args) {
        SwitchHero switchHero = new SwitchHero();
        switchHero.setHero(new YujiHero());
        switchHero.start();
        switchHero.setHero(new ChengyaojingHero());
        switchHero.start();
    }
}
class SwitchHero {
    private Hero hero;
    public void setHero(Hero hero) {
        this.hero = hero;
    }
    public void start(){
        hero.skill();
    }
}
class Hero {
    public void skill() {
        System.out.println("影响技能");
    }
}
class YujiHero extends Hero {
    @Override
    public void skill() {
        System.out.println("虞姬的三技能贼猛");
    }
}
class ChengyaojingHero extends Hero {
    @Override
    public void skill() {
        System.out.println("程咬金的二技能贼贱");
    }
}