面向对象思想

属性

使用属性列表进行描述
strictPropertyInitialization:true 更加严格的判断当前属性是否有赋初始值 属性的初始化检查
属性可以修饰为可选的,或者是只读的

  1. class U {
  2.   readonly id: number = 1
  3.   name:string
  4.   age: number
  5.   idCard?: string
  7.   constructor(name: string,age:number){
  8.      this.name = name;
  9.       this.age = age; 
  10.   }
  11. }

访问修饰符

访问修饰符可以控制类中的某个成员的权限
- public： 默认的访问修饰符， 公开的，所有的代码均可访问
- private: 私有的， 只有在类中可以访问
- protected: 受保护的成员，只能在自身或者子类中才能访问
属性简写
如果某个属性，通过构造函数的参数传递，并且不做任何处理的赋值给该属性，可以进行简写

  1. class U {
  2.    public name:"古风",
  4.   private add(){
  6.   }
  7.               //属性简写   
  8.   constructor(public name: string){}
  9. }

访问器

作用： 控制属性的赋值和读取

  1. class U {
  2.   name:string
  3.   _age: number
  5.   constructor(public name: string, private _age:number){}
  7.   get age(){
  8.     return Math.floor(this._age);
  9.   }
  11.   set age(val: number){
  12.       console.log(val)
  13.   }
  15. }

类的继承 extends

继承可以描述类与类之间的关系
例如：A和B都是类，并且可以描述为A是B，则A和B形成继承关系；A继承与B，则A自动拥有B中的所有成员
成员的重写

  • 子类中覆盖父类的成员
  • 子类成员不能改变父类成员的类型
  • 无论是属性还是方法，子类都可以对父类的相应成员进行重写，但重写的时候需要保证类型的匹配
  • this关键字：在继承关系中，this的指向是动态的—调用方法时，根据具体的调用者确定this指向
  • 子结构辨型法 进行类型匹配： 子类的对象始终可以赋值给父类 ：：里氏替换原则
  • 可以使用 instanceof 判断一个数据的具体子类类型
  • super关键字: 在子类的方法中，可以使用super关键字读取父类的成员 ```javascript export class U { x:number = 0; y:number = 0; sayHello(){
    1. console.log("Hi")    }
    }

export class S extends U { test(){ super.sayHello() } }

  1. <a name="qoQUD"></a>
  2. ### 单根性和传递性
  3. 单根性：每个类最多只能拥有一个父类<br />传递性：如果A是B的父类，并且B是C的父类,则可以认为A是C的父类
  4. <a name="H9H9O"></a>
  5. ### 抽象类 abstract
  6.  某个类只表示一个抽象概念, 主要用于提取子类共有的成员,而不能直接创建它的对象，该类可以作为抽象类<br />给类的前面加上``` abstract ```  表示该类是一个抽象类，不可以创建一个抽象类的对象。
  8. - 抽象abstract 成员: 只能在抽类型中出现，而且必须在子类中实现, 形成一个强约束力
  9. ```javascript
  10. abstract class U{
  11.   abstract readonly nane: string = "";
  12.   abstract sayHello(){}
  13. }

模板模式

有些方法，所有的子类实现的流程完全一致，只是流程中的某个步骤的具体实现不一致，可以将该方法提取到父类，在父类中完成整个流程的实现，遇到实现不一致的方法时，可以将该方法做成抽象类

单例模式

某些类的对象，在系统中最多只能有一个，为了避免开发者造成随意创建多个类对象的错误，可以使用单例模式进行强约束

  1.  * class Board {
  2.  *     private constructor() {}
  3.  *     
  4.  *     private static _board?: Board
  5.  *     
  6.  *    static createBoard(): Board{
  7.  *        if(this._board){
  8.  *           return this._board
  9.  *        }
  10.  *        this._board = new Board();
  11.  *        return this._board;
  12.  * 
  13.  *     }    
  14.  * 
  15.  * }

静态成员

附着在类上的成员（属于某个构造函数的成员）
使用static 修饰的成员，是静态成员
实例成员：对象成员，属于某个类的对象
静态成员: 非实例成员，属于某个类
实例方法中的this指向的是当前对象，而静态方法中的this指向的是当前类

索引器

对象[值], 使用成员表达器
在TS中，默认情况下是不对索引器（成员表达式）做严格的类型检查
对索引器开启严格的类型检查：noImplicitAny：true 隐式any的检查
隐式any: TS 根据实际情况推导出的any类型
在索引器中，键的类型可以是 字符串 或者 是数字
在类中，索引器书写的位置应该在所有成员之前

  1. class U {
  2.    [prop: string]: any
  3. }

作用：

  • 在严格的检查下，可以实现为类动态增加成员
  • 在实现动态的操作类成员

在TS中，如果某个类使用了两种类型的索引器，要求两种索引器的值类型必须匹配