ES6 class 类继承

• 通过 class 来声名类 extends 来继承类 super 来表示父类 将属性写在 constructor 中
• 注意 当子类中的方法名字与父类中的名字重复的话那么子类的方法将会覆盖父类的方法
• 注意 super 前面不能有 this 操作不然会报错
• 当子类继承父类时，如果不需要通过 constructor 设置属性和继承父类 constructor 中的属性，那么可以不写 constructor 和 super,否则，就必须写上 constructor 和 super

首先通过 class 声名一个父类

      class Parsen {
        name;
        age;
        constructor(name, age) {
          this.name = name;
          this.age = age;
        }
        run() {
          return "跑步";
        }
      }

通过extends 来继承父类

        class Son extends Parsen {
          sing() {
            return "唱歌";
          }
        }
        let s1 = new Son("广坤", "30");
        console.log(s1.run()); //跑步 //此时子类方法并没有 与父类重名

当子类与父类方法 重名时

        class Ele extends Parsen {
          run() {
            return "哈哈哈";
          }
          go() {
            return "南京";
          }
        }
        let e1 = new Ele("刘能", 31);
        console.log(e1.go()) //南京
        console.log(e1.run()); //哈哈哈 //此时子类方法与父类方法重名那么子类方法会覆盖父类方法

如果想要继续往子类中添加属性 通过 super 来完成

        class Son extends Parsen {
          money;
          address;
          constructor(name, age, money, address) {
            super(name, age);
            (this.money = money), (this.address = address);
          }
        }
        或者

        class Son extends Parsen {
          money;
          address;
          constructor(name, age, money, address) {
          super();
          this.name = name,
          this.age = age,
          this.money = money,
          this.address = address;

          }
        }
        const s2 = new Son("赵四", 26, "100w", "象牙山");
        console.log(s2.money, s2.address); //100w 象牙山

class 中的 this 指向

      class Son extends Parsen {
        money;
        address;
        constructor(name, age, money, address) {
          super();
          (this.name = name),
            (this.age = age),
            (this.money = money),
            (this.address = address);
          console.log(this);
          //这里的 this 指向实例化对象 （图一）
        }
        fn() {
          console.log(this);
          //这里的 this 同样指向实例化对象 （图二）
        }
      }
      const s2 = new Son("赵四", 26, "100w", "象牙山");
      console.log(s2.money, s2.address); //100w 象牙山
      s2.fn()

1. 图一
2. 图二

TS 访问修饰符

1. public: 公共的， 修饰 属性 和 方法 任何地方 都可以访问
2. private: 修饰 属性 和 方法 私有的 ， 只能在 本类 内部使用，其余地方 均不可以 访问 实例化对象 和 类 也不可 访问。（子类也不行）
3. protected: 修饰 属性 和 方法 被 保护的， 被当前类，以及子类内部非可访问，实例化对象和类也不可访问

访问修饰符的特性

多态性、封装性、继承性

//父类
class Person {
  private private1() {
    console.log("只能在当前类访问");
  }
  public public1() {
    console.log(" 当前类 子类 实例化对象哪里都可以访问");
    this.private1();
  }

  protected protected1() {
    console.log("可以在 当前类 与 子类 访问");
  }
}
let p1 = new Person();
p1.private1(); //会报错 不能被实例化对象使用
p1.protected1(); //会报错 不能被实例化对象使用
p1.public1(); //不会报错 可以被实例化对象使用


//子类
class Child extends Person {
  fn() {
    this.public1(); //不会报错 可以在子中使用
    this.private1(); //会报错 不能在子中使用
    this.protected1(); //不会报错 可以在子中使用
  }
}
let c1 = new Child();
c1.private1(); //会报错 不能被实例化对象使用
c1.protected1(); //会报错 不能被实例化对象使用
c1.public1(); //不会报错 可以被实例化对象使用