5.ts类

• 定义类

1. 如果类中的属性必须初始化可以开启 strictPropertyInitialization=true
2. 实例上的属性需要先声明在使用，构造函数中的参数可以使用可选参数和剩余参数

// 未开启strictPropertyInitialization
class Point {
  x: number;
  y: number;
}

const pt = new Point();
pt.x = 0;
pt.y = 0;

// 开启strictPropertyInitialization
class Point {
  x: number;
  y: number;
  constructor(x: number, y: number) {
    this.x = x;
    this.y = y
  }
}
const pt = new Point(1, 3);

class Pointer{
    x!:number; // 实例上的属性必须先声明
    y!:number;
    constructor(x:number,y?:number,...args:number[]){
        this.x = x;
        this.y = y as number;
    }
}
let p = new Pointer(100,200);

• 类中的修饰符

1. public 修饰符（谁都可以看到）不写默认为public

// public属性谁都可以看到 
class Person {
  public name!: string;
  age!: number;
  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
}
class myPerson extends Person {
  constructor(name: string, age: number) {
    super(name, age)
    console.log(this.name, this.age)
  }
}
let p = new Person('xj', 18);
console.log(p.name, p.age);

2. protected修饰符 (自己和子类可以访问到)

class Person2 {
  constructor(protected name: string, protected age: number) {
    this.name = name
    this.age = age
  }
}

class myPerson1 extends Person2 {
  constructor(namae: string, age: number) {
    super(namae, age)
    console.log(this.name, this.age)
  }
}
let pp = new myPerson1('Tom', 18);
console.log(pp.name, pp.age);// 无法访问

3. private修饰符 （除了自己都访问不到）

class PrivatePerson {
  constructor(private name: string, private age: number) {
    this.name = name
    this.age = age
  }
}
class PrivateP extends PrivatePerson {
  constructor(name: string, age: number) {
    super(name, age)
    console.log(this.age, this.namae)
  }
}
let pp1 = new myPerson1('Tom', 18);
console.log(pp1.name, pp1.age);// 无法访问

4. readonly修饰符 （仅读修饰符）

class ReadonlyPerson {
  constructor(readonly name: string, public age: number) {
    this.name = name
    this.age = age
  }
  changeName(name: string) {
    this.name = name; // 仅读属性只能在constructor中被赋值
  }
}
class ReadonlyP extends ReadonlyPerson {
  constructor(name: string, age: number) {
    super(name, age)
    console.log(this.age, this.name)
  }
}
let ppp1 = new myPerson1('Tom', 18);
console.log(ppp1.name, ppp1.age);

• 静态属性和方法

1. 在 TypeScript 中，类可以具有静态属性和静态方法。静态属性和方法属于类本身，而不是类的实例。
2. 可以通过类名直接访问和调用静态属性和方法，而无需创建类的实例。
3. 静态属性和静态方法是可以被子类所继承的

class MathUtils {
  static PI: number = 3.14159; // 静态属性

  static calculateCircumference(radius: number): number {
    return 2 * MathUtils.PI * radius; // 静态方法中访问静态属性
  }
}

console.log(MathUtils.PI); // 直接访问静态属性
console.log(MathUtils.calculateCircumference(5)); // 调用静态方法
// 子类要访问父类的静态方法需要 父类 get/set

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

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

• super属性

1. 子类可以通过super 去调用父类的静态方法和属性

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

• 抽象类

1. 抽象类无法被实例化，只能被继承，
2. 抽象方法不能在抽象类中实现，只能在抽象类的具体子类中实现,而且必须实现。

abstract class Animal{
    name!:string;
    abstract speak():void
}
class Cat extends Animal {
    speak(){
        console.log('猫猫叫');
    }
}
class Dog extends Animal{
    speak():string{
        console.log('汪汪叫');
        return 'wangwang'
    }
}