一、TS中定义类

新建一个ts文件，

  1. class Dog {
  2.     constructor(name: string) {
  3.         this.name = name;
  4.     }
  5.     public name: string = "dog"
  6. }
  7. let dog = new Dog('wangwang');
  8. console.log(dog)
  1. class Pointer{
  2.     x!:number; // 实例上的属性必须先声明
  3.     y!:number;
  4.     constructor(x:number,y?:number,...args:number[]){
  5.         this.x = x;
  6.         this.y = y as number;
  7.     }
  8. }
  9. let p = new Pointer(100,200, 2);
  10. console.log(p)

实例上的属性需要先声明在使用，构造函数中的参数可以使用可选参数和剩余参数

二、类中的修饰符

1、修饰符的写法

  1. class Animal {
  2.     constructor(name: string, age: number) {
  3.         this.name = name;
  4.         this.age = age;
  5.     }
  6.     public name: string;  // 不写public默认也是公开的
  7.     public age: number;
  8. }

通过参数属性来简化父类中的代码

  1. class Animal {
  2.     constructor(public name: string, public age: number) {
  3.         this.name = name;
  4.         this.age = age;
  5.     }
  6. }

可以直接在构造函数前面添加修饰符

  1. class Animal {
  2.     public constructor(name: string, age: number) {
  3.         this.name = name;
  4.         this.age = age;
  5.     }
  6. }

2、修饰符用法

1、public修饰符 公共成员

public修饰符（谁都可以访问到）

  1. class Animal {
  2.     constructor(name: string, age: number) {
  3.         this.name = name;
  4.         this.age = age;
  5.     }
  6.     public name: string;  // 不写public默认也是公开的
  7.     public age: number;
  8. }
  10. class Cat extends Animal{
  11.     constructor(name: string, age: number) {
  12.         super(name, age);
  13.         console.log(this.name, this.age); // 子类访问（public修饰的可以访问）
  14.     }
  15. }
  17. let c = new Cat('Tom', 18);
  18. console.log(c.name, c.age);  // 外部访问（public修饰的可以访问）

2、protected修饰符 受保护成员

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

  1. class Animal {
  2.     constructor(protected name: string, protected age: number) {
  3.         this.name = name;
  4.         this.age = age;
  5.     }
  6. }
  7. class Cat extends Animal {
  8.     constructor(name: string, age: number) {
  9.         super(name, age);
  10.         console.log(this.name, this.age, '===子类'); // 子类访问（protected 可以访问）
  11.     }
  12. }
  14. let c = new Cat('Tom', 18);
  15. console.log(c.name, c.age, '==外部访问');  // 外部访问（protected 无法访问）

3、private修饰符 私有成员

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

    1. class Animal {
    2.   constructor(private name: string, private age: number) {
    3.       this.name = name;
    4.       this.age = age;
    5.   }
    6. }
    7. class Cat extends Animal {
    8.   constructor(name: string, age: number) {
    9.       super(name, age);
    10.       console.log(this.name, this.age); // 无法访问
    11.   }
    12. }
    13. let p = new Cat('Tom', 18); 
    14. console.log(p.name,p.age);// 无法访问

    4、readonly修饰符 只读成员

  • readonly修饰符 （仅读修饰符）

    1. class Animal {
    2.   constructor(public readonly name: string, public age: number) {
    3.       this.name = name;
    4.       this.age = age;
    5.   }
    6.   changeName(name:string){
    7.       this.name = name; // 仅读属性只能在constructor中被赋值
    8.   }
    9. }
    10. class Cat extends Animal {
    11.   constructor(name: string, age: number) {
    12.       super(name, age);
    13.   }
    14. }
    15. let p = new Cat('Tom', 18); 
    16. p.changeName('Jerry');

    三、静态属性和方法

    静态属性和静态方法是可以被子类所继承的；
    静态属性只能通过类名来调用，不能通过子类调用； ```typescript class Animal { static type = ‘哺乳动物’; // 静态属性 static getName() { // 静态方法

    1.   return '动物类';

    } private _name: string = ‘Tom’;

    get name() { // 属性访问器

    1.   return this._name;

    } set name(name: string) {

    1.   this._name = name;

    } } let animal = new Animal(); console.log(animal.name);

// 静态属性只能通过类名来调用，不能通过子类调用； console.log(Animal.type); // 可以访问 console.log(animal.type); // 不能访问

  1. <a name="oOLyo"></a>
  2. ## 四、抽象类
  3. 所谓抽象类就是**只能被继承不能被实例化的类。**<br />**<br />抽象类无法被实例化，只能被继承，抽象方法不能在抽象类中实现，只能在抽象类的具体子类中实现,而且必须实现。
  4. ```typescript
  5. // abstract 定义抽象类
  6. abstract class Animal {
  7.     eat(){
  8.       console.lig('eat');
  9.   }
  10. }
  12. class Dog extends Animal {
  13.     constructor(name: string) {
  14.       super();
  15.     this.name = name;
  16.   }
  17.   name: string;
  18.   run(){}
  19. }
  20. let dog = new Dog('ww')
  21. dog.eat();

类的多态和链式调用

class Animal {
    eat(){
      console.lig('eat');
  }
}
let animals: Animal[] = [dog, cat];
animals.forEach(a => {
    a.eat()
})



class WorkFlow {
    step1(){
      return this;
  }
  step2(){
      return this;
  }
}
new WorkFlow().step1().step2();

// 保证父类子类调用的连贯性
class Myflow extends WorkFlow {
    next() {
      return this;
  }
}
new Myflow().next().step1().step2();

四、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())

五、类的装饰器

1.装饰类

function addSay(target:any){
    target.prototype.say = function(){console.log('say')}
}
@addSay
class Person {
    say!:Function
}
let person = new Person
person.say();