关于typescript:Tyspscript中的class

申明一个类 class

class 类名 {
    // class 中次要蕴含两个局部，属性和办法
    属性
    办法
}

实例属性和类属性

• 实例属性：实例化之后，也就是 new 之后能力用的属性和办法

• 类属性 (动态属性)：class 自身本人间接应用的，上面是 TS 中的属性修饰符

  • static：动态属性，属于类本身不属于实例，只有本身能够拜访到
  • readonly：只读属性，只容许读取，不容许批改
  • public：所有属性的默认属性。随便读写
  • private：申明是一个公有属性，不容许在内部拜访
  • protected：和 private 根本一样，也是不容许在内部拜访，然而容许在子 类中拜访

• demo

  class Person {
      // 定义实例属性
      name:string = '景天';
      // 在属性前应用 static 关键字能够定义类属性
      static age:number = 18;
      
      // 定义实例办法
      sayHello() {console.log('Hello')
      }
      
      // 定义类办法
      static sayHi() {console.log('Hi')
      }
  }
  
  // 实例属性和办法的应用
  class p = new Person()
  console.log(p.name)
  p.sayHello()
  
  // 类属性和办法的应用
  console.log(Person.age)
  Person.sayHi()

class 中的构造函数 (constructor)

• 惯例写法

  class Person {
      name: string
      age: number
      
      // constructor 被称为构造函数
      // 构造函数会在实例对象创立的时候调用
      constructor(name:string,age:number) {
          // 在实例办法中，this 就是示意以后的实例
          // 在构造函数中，以后对象就是以后新建的那个对象
          // 能够通过 this 向新建的对象中增加属性
          this.name = name
          this.age = age
      }
      
      sayHi() {
          // 在实例办法中，能够通过 this 来示意以后调用办法的对象
          console.log(this)
          console.log(` 你好，我是 ${this.name}`)
      }
  }
  
  class p = new Person('景天'，18)
  console.log(p.name,p.age)

• 简写形式

  class Person {
      // 能够把属性的定义写到构造函数的参数中去，所示一种语法糖的写法
      constructor(public name:string, public age:number) { }
      
      sayHi() {console.log(` 你好，我是 ${this.name}`)
      }
  }
  
  class p = new Person('景天'，18)
  console.log(p.name,p.age)

class 中的继承

• 应用继承后，子类将会领有父类所有的办法和属性。
• 如果子类中和父类中有雷同的属性和办法，子类中会笼罩父类的办法。
• 应用： 子类 extends 父类

• demo

  // 创立一个父类
  class Animal {
      name: string
      
      constructor(name:string) {this.name = name}
      
      sayHi() {console.log('动物们说 Hi')
      }
  }
  
  // 狗这个子类继承父类
  class Dog extends Animal {
      age: number
      
      constructor(name:string,age:number) {
          // 如果在子类中写了构造函数，在子类的构造函数中必须要调用下父类的构造函数
          // super 就是代表父类中的构造函数
          super(name);
          this.age = age
      }
  
      // 增加一个本人的办法
      run() {console.log('我在跑呢')
      }
  }
  
  // 猫这个子类继承父类
  class Cat extends Animal {
      // 子类中也有 sayHi 办法，会笼罩父类中的办法，应用本人的办法
      sayHi() {console.log('喵喵喵喵')
      }
  }
  
  let dog = new Dog('哮天犬',1000)
  dog.sayHi()
  dog.run()
  let cat = new Cat('九命猫妖')
  cat.sayHi()

抽象类和形象办法

• 抽象类：用 abstract 结尾，这代表是一个抽象类，抽象类和其余类的区别不大，只是不能用来创建对象。
• 形象办法：同样 abstract 结尾，形象办法只能定义在抽象类中，并且子类中必须对形象办法进行重写。

• demo

  // 创立一个父类
  /* 
      咱们之前创立的父类，除了能够被继承，本人也能够实例化，然而有时候咱们就想申明一个父类，不容许实例化。那么能够用 abstract 结尾，这代表是一个抽象类，抽象类和其余类的区别不大，只是不能用来创建对象。能够说抽象类就是用来创立父类给子类继承的。抽象类中能够增加形象办法。*/
  abstract class Animal {
      name: string
      
      constructor(name:string) {this.name = name}
      
      // 定义一个形象办法，同样 abstract 结尾，没有办法体。// 形象办法只能定义在抽象类中，并且子类中必须对形象办法进行重写。// void：空值
      abstract sayHi():void}
  
  class Dog extends Animal {sayHi() {console.log("汪汪汪")
      }
  }
  
  let a = new Animal() // 这样就会报错，因为不容许实例化 

接口

• 和抽象类相比

  • 抽象类的属性值能够是有值得也能够是没值，接口的属性值都是没值的，只定义构造，不思考理论值
  • 接口中所有的办法都是形象办法。
  • 应用抽象类，是用 extends 继承，能够继承父类的办法，也能够重写。接口是应用 implements，而且必须满足接口中所有要求

• demo

  // 定义一个接口
  interface myInter {
      name: string
      
      sayHello():void}
  
  // 定义一个类去实现下面的接口，必须满足接口的所有要求
  class Myclass implements myInter {
      name：string
      
      constructor(name:string) {this,name = name}
      
      sayHello() {console.log('Hello')
      }
  }
  
  // 接口如何扩大呢？能够应用 extends 扩大，然而原来的不会扭转
  interface myInter2 extends myInter {age: number}
  
  // 须要留神的一点是，接口是容许反复的，并不会笼罩，而是会合并
  // 上面这样的，obj 就会有两个属性 name 和 age
  interface obj {name: string}
  interface obj {age: number}

属性的封装

• 利用场景：有时候咱们不想属性简略的裸露进来，也不想被随便更改

• 简略的封装

  class Person {
      /* 
          TS 能够在属性后面增加修饰符
              - static：动态属性，属于类本身不属于实例，只有本身能够拜访到
              - readonly：只读属性，只容许读取，不容许批改
              - public：所有属性的默认属性。随便读写
              - private：申明是一个公有属性，不容许在内部拜访
              - protected：和 private 根本一样，也是不容许在内部拜访，然而容许在子类中拜访
      */
      
      // 私有化两个属性
      private _name：string
      private _age: number
      
      constructor(name:string,age:number) {
          this._name = name;
          this._age = age;
      }
      
      // 提供给外界拜访和批改公有属性的办法
      getName() {return this._name}
      setName(value:string) {this._name = value}
      getAge() {return this._name}
      setAge(value:number) {if(value > 0) {this._age = value}
      }
  }
  
  let p = new Person('景天'，18)
  
  console.log(p.getName());
  p.setName('雪见')
  console.log(p.getAge());
  p.setAge(17)

• 存取器，比下面简略的封装好的多，这才是罕用的形式

  // 应用属性存取器
  class Person {
      // 私有化两个属性
      private _name：string
      paivate _age: number
      
      constructor(name:string,age:number) {
          this._name = name;
          this._age = age;
      }
      
      // 提供给外界拜访和批改公有属性的办法
      get name() {return this._name}
      set name(value:string) {this._name = value}
      get age() {return this._name}
      set age(value:number) {if(value > 0) {this._age = value}
      }
  }
  
  let p = new Person('景天'，18)
  
  console.log(p.name);
  p.name = '雪见'
  console.log(p.age);
  p.age = 17