【004】属性读写、静态方法、子类继承 - 图1

属性读写 - getter & setter

getter和setter的作用就是可控的读写
有条件的写入是很有必要的

  1. // age属性读写[这里写法涉及闭包]
  2. let _age = 0.1
  3. const _smallChickenAge = 0.3
  4. // 设置小鸡的岁数常量是0.3年
  5. class Chicken {
  6.   constructor (type) {
  7.     this.type = type
  8.   }
  9.   // get就是读属性的方法
  10.   // getter就是这个
  11.   get age () {
  12.     return _age
  13.   }
  14.   // set就是写属性的方法
  15.   // setter就是这个
  16.   set age (val) {
  17.     if (val < _smallChickenAge) {
  18.       _age = _smallChickenAge
  19.     } else _age = val
  20.   }
  21. }
  23. // 创建实例对象miu小鸡
  24. let miu = new Chicken('chicken')
  25. console.log(miu.age)
  27. // 测试一下年龄读写
  28. miu.age = 0.2
  29. console.log(miu.age)
  30. miu.age = 0.9
  31. console.log(miu.age)

静态方法 - static

静态方法 static类方法
静态方法 绝缘 实例对象！
静态方法只在类上，不在实例对象上！

  1. // 还是用小鸡类做例子
  2. class Chicken {
  3.   constructor (type) {
  4.     this.type = type
  5.   }
  6.   eat () {
  7.     Chicken.walk() 
  8.     // 使用类的静态方法
  9.     // 静态方法在类上的
  10.     // 不是在实例对象上的
  11.     console.log('eat Chicken food')
  12.   }
  13.   static walk () {
  14.   // static 关键字就是静态方法
  15.     console.log('chicken walking')
  16.   }
  17. }
  18. // 创建实例
  19. let miu = new Chicken('chicken')
  20. // 使用对象
  21. miu.eat()

这里会输出

  1. chicken walking
  2. eat Chicken food

因为在eat（）方法内
先调用了静态方法 Chicken.walk()
再输出 eat Chicken food

继承 - extends

关键字 extends
语法：class 父类 extends 子类
构造函数可添加子类的新属性
子类和父类属性相同-子类构造函数可不写
super(type)不带{}记住！！！

  1. // 父类 - Animal
  2. class Animal{
  3.   constructor(type){
  4.     this.type = type
  5.   }
  6.   eat (){
  7.     console.log('eat food')
  8.   }
  9. }
  11. // 子类 - Dog
  12. class Dog extends Animal{
  13.   constructor(type){
  14.     super(type)
  15.     // 子类继承原本的构造函数
  16.     // 如果有不同的地方这里可以继续添加属性
  17.     this.age = 1
  18.     // 这里给子类添加age属性
  19.   }
  20. }
  22. // 创建实例对象
  23. let dog = new Dog('dog')
  24. // 查看子类的新属性
  25. console.log(dog.age)