4.ts中的类

1. 类的定义

class Pointer {
    x: number 
    y: number  // 声明的变量会被增加到实例上
    // 此函数中依然可以使用 剩余运算符 可选参数  默认参数
    // 传入的实例直接就放在实例上，无需再次声明  
    constructor(x: number, y?: number, ...args: number[]){ // 在constructor中的操作都是初始化操作
        this.x = x;
        this.y = y as number;
    }
}
let p = new Pointer(100,200)
console.log(p.x, p.y)

2. 类中的修饰符

• 1. public 公开的，都可以访问到

class Animal {
    public name!: string  // 不写默认也是 public
    public age!: number
    constructor(name: string, age: number){
        this.name = name
        this.age = age
    }
}

class Dog extends Animal {
    constructor(name: string, age: number){
        super(name, age)
        console.log(this.name, this.age)  // 子类访问
    }
}

let p = new Dog('Jack', 6)
console.log(p.name, p.age) // 外部访问

• 2. protected 受保护的，只能自己和子类访问

class Animal {
    constructor(protected name: string, protected age: number){  // 简化写法
        this.name = name
        this.age = age
        console.log(this.name, this.age)  // 自己可以访问
    }
}

class Dog extends Animal {
    constructor(name: string, age: number){
        super(name, age)
        console.log(this.name, this.age)  // 子类可以访问
    }
}

let p = new Dog('Jack', 6)
// console.log(p.name, p.age) // 外部无法访问

• 3. private 私有的，只有自己可以访问

class Animal {
    constructor(private name: string, private age: number){
        this.name = name
        this.age = age
        console.log(this.name, this.age)  // 自己可以访问
    }
}

class Dog extends Animal {
    constructor(name: string, age: number){
        super(name, age)
        // console.log(this.name, this.age)  // 子类无法访问
    }
}

let p = new Dog('Jack', 6)
// console.log(p.name, p.age) // 外部无法访问

• 4. readonly 只能读取

class Animal {
    constructor(readonly name: string,public age: number){
        this.name = name
        this.age = age
    }
    changeName(name: string){
        this.name = name; // 无法修改，仅读属性只能在constructor中被赋值
    }
}

class Dog extends Animal {
    constructor(name: string, age: number){
        super(name, age)
    }
}

let p = new Dog('Jack', 6)
p.changeName('Tom')

3. 静态属性和方法

class Animal {
    static type = '哺乳动物'; // 静态属性
    static getName() { // 静态方法
        return '动物类';
    }
    private _name: string = 'Tom';

    get name() { // 属性访问器
        return this._name;
    }
    set name(name: string) {
        this._name = name;
    }
}
let a = new Animal();
console.log(a.name);

4. super 属性

class Animal {
    say(message:string){
        console.log(message);
    } 
    static getType(){
        return '动物'
    }
}
class Cat extends Animal {
    say(){ // 原型方法中的super指代的是父类的原型
        super.say('猫猫叫');
    }
    static getType(){ // 静态方法中的super指代的是父类
        return super.getType()
    }
}
let cat = new Cat();
console.log(Cat.getType())

5. 类的装饰器

• 1. 装饰类

装饰器作用就是扩展类，扩展类中的属性和方法 , 但不能修饰函数，函数会有变量提升的问题

function addSay1(val: string) {  // 洋葱模型
    console.log(val)
    return function (target: any) {
        console.log(1)
    }
}
function addSay2(val: string) {
    console.log(val)
    return function (target: any) {
        console.log(2)
    }
}
function addSay3(val: string) {
    console.log(val)
    return function (target: any) {
        console.log(3)
    }
}
@addSay1('a1')
@addSay2('a2')
@addSay3('a3')  // = addSay(Person);
class Person{

}  // a1 a2 a3 3 2 1
// 装饰类可以给类扩展功能，需要在tsconfig.json开启 experimentalDecorators:true

• 2. 装饰类中的属性

function toUpperCase(target: any, key: string){  // target 类的原型，key就是修饰的属性
  let val: string = ''
  Object.defineProperty(target, key, {  // 原型定义属性
    get(){
      return val.toUpperCase()
    },
    set(newVal: string){
      val = newVal
    }
  })
}

function double(num: number){
  return function(target: any, key: string){
    let v = target[key]
    Object.defineProperty(target, key, {
      get(){
        return num * v
      }
    })
  }
}

class Person{
  @toUpperCase
  public name: string = 'Tom';  // 修饰的是实例，装饰器指的就是原型

  @double(2)
  static age: number = 18;  // 修饰的是静态属性，装饰器指的就是类
}

let p = new Person();
console.log(p.name) // TOM
console.log(Person.age)  // 36 静态属性需要通过类来调用

• 3. 装饰类中的方法

function Enum(bool: boolean){  // 修改方法不能枚举
  return function (target: any, key: string, descriptor: PropertyDescriptor){  // target 指原型
    descriptor.enumerable = bool
  }
}

class Person{
  @Enum(false)
  drink(){}
}
let p = new Person();
console.log(p)

• 4. 装饰参数

function params(target: any, key: string, index: number){  // target 原型 key 指方法drink index 索引0
  console.log(key, index)
}

class Person{
  drink(@params content: any){}  // 修饰参数
}