• 类:定义了一件事情的抽象特点,包含它的属性和方法
  • 对象:类的实例,通过new生成
  • 面向对象(OOP):封装,继承,多态
  • 封装:将对数据的操作细节隐藏起来,只暴露对外的接口。外界调用端不需要知道细节,节能通过对外提供的接口来访问该对象,同时也保证了外界无法任意更改对象内部的数据
  • 继承:子类继承父类,子类除了拥有父类的所有特性外,还拥有一些更具体的特性
  • 多态:由继承而产生了相关的不同的类,对同一个方法可以有不同的响应。
  • 存取器:泳衣改变属性的读取和赋值行为
  • 修饰符:修饰符是一些关键字,用于限定成员或类型的性质
  • 抽象类:是供其他类继承的基类,抽象类不允许被实例化。抽象类中的抽象方法必须在子类中被实现
  • 接口:不同类之间共有的属性或方法,可以抽象成一个接口。接口可以被类实现。一个类智能继承自另一个类,但是可以实现多个接口

修饰符

  • public:修饰的属性或方法是公有的,可以在任何地方被访问到,默认所有的属性和方法都是public
  • private修饰的属性或方法是私有的,不能在声明它的类的外部访问,只能在类的内部访问
  • protected:受保护的,和private类似,区别是它在子类中也是允许被访问的
// 父类
class Parent {
  private name: string
  constructor(name: string) {
    this.name = name
  }
  protected getPosition() {
    return `(${this.name})`
  }
}

// 子类
class Child1 extends Parent {
  constructor(name: string) {
    super(name)
    // console.log(super.name)
  }
}
console.log(new Child1('liu'))
//给constructor添加protected后无法实例化该类

readonly

  • 只读属性关键字
  • 只允许出现在属性声明或索引签名或构造函数中
class User {
  public readonly name: string
  constructor(name: string) {
    this.name = name
  }
}
const user = new User('liu')
// user.name = 'chen' // 无法分配到 "name" ,因为它是只读属性
console.log(user)

参数访问限定符 public private protected readonly// 1.规定属性类型 2.将该属性添加到实例上

抽象类

  • 抽象类不允许被实例化
  • 抽象类中的抽象方法必须被子类实现
// 抽象类
abstract class People {
  constructor(public name: string) {}
  /**
   * name
   */
  public abstract printName(): void
}
const p1 = new People() //无法创建抽象类的实例

// 非抽象类“Man”不会实现继承自“People”类的抽象成员“printName”。
class Man extends People {
  constructor(name: string) {
    super(name)
  }
  // 子类自己实现printName
  printName() {
    console.log(this.name)
  }
}
const man = new Man('liu')
man.printName()

类的存取器

class Info {
  public name: string
  public age: number
  private _infoStr: string

  constructor(name: string, age?: number, public sex?: string) {
    this.name = name
    this.age = age
  }
  get infoStr() {
    console.log('getter')
    return this._infoStr
  }
  set infoStr(value: string) {
    console.log('setter' + value)
    this._infoStr = value
  }
}
let info1 = new Info('liu')
let info2 = new Info('chen', 24)
let info3 = new Info('chen', 24, 'nv')
console.log(info3)
console.log('--------------')

// 存取器

info2.infoStr = 'liu:24'
console.log(info2.infoStr)

类的继承

abstract class People {
  abstract _name: string
  abstract get insideName(): string
  abstract set insideName(value: string) // 存值器函数不能标记返回值类型
}
// 抽象方法和抽象存取器都不能包含实际的代码块,只需要指定他属性名方法名方法参数返回值类型
class P extends People {
  // 非抽象类继承抽象类时,要去实现抽象类中的抽象属性跟抽象方法
  public _name: string
  public insideName: string
}

类继承接口

 类使用implements 关键字 继承接口
interface Foo {
  type: string
}
// 接口检测是使用该接口定义的类创建的实例,即类的实例要符合该接口
class FooClass implements Foo {
  public type: string // 这里如果加了static就会报错,静态属性定义在类上,而不是实例上
}

接口继承类

// 接口继承类,继承类成员不包括其实现
class AA {
  protected names: string
}
interface I extends AA {}

// class BB implements I {
//   names:string
// }

// 受保护的属性只能在这个类跟其子类中访问
// 这里BB 继承的是接口I 而不是 AA,而AA中的属性是protected

class BB extends AA implements I {
  names: string
}

泛型中使用类

// 泛型中使用类
// new () 调用这个类的构造函数
const create = <T>(c: new () => T): T => { // 工厂模式
  return new c()
}
class Infos {
  public age: number
  constructor() {
    this.age = 18
  }
}
console.log(create<Infos>(Infos).age) 

爬。