class 类

基本语法

class User {
  name: string; //指定属性数据类型
  age: number;
  constructor(n: string, a: number) {
    this.name = n;
    this.age = a;
  }
  info(): string {
    //指定方法数据类型
    return `${this.name}的年龄是 ${this.age}`;
  }
}

const users: User[] = []; // 约束数组内容只能是 User 实例对象

修饰符

public

指定公开的属性或方法 可以在类的内部与外部修改和访问

class User {
  public name: string;
  public age: number;
  constructor(n: string, a: number) {
    this.name = n;
    this.age = a;
  }
  public info(): string {
    return `${this.name}的年龄是 ${this.age}`;
  }
}

protected

只允许在父类与子类使用，不允许在类的外部使用

class Test {
  protected name: string;
  constructor(name: string) {
    this.name = name;
  }
}
class User extends Test {
  constructor(name: string) {
    super(name);
  }
  public info(): string {
    return `你好 ${this.name}`;
  }
}
const test = new User("xxx");
test.info();
test.name; //属性是 protected 不允许访问

private

指私有的，不允许在子类与类的外部使用

class Test {
  private name: string; //只能父类内部进行访问和修改
  constructor(name: string) {
    this.name = name;
  }
  private info(): void {}
}
class User extends Test {
  constructor(name: string) {
    super(name);
  }
  public info(): void {}
}

readonly

将属性定义为只读，不允许在类的内部与外部进行修改

class Test {
  readonly site: string = "xxxxx";
  constructor(site?: string) {
    this.site = site || this.site;
  }
  public get(url: string): any[] {
    console.log(`你正在请求 ${this.site + "/" + url}`);
    return [];
  }
}
const instance = new Test("xxx");
instance.get("users");

修饰符转换

 - 父类的 private 不允许子类修改
 - 父类的 protected 子类可以修改为 protected 或 public
 - 父类的 public 子类只能设置为 public

constructor

初始化实例参数使用的

class User {
  constructor(public name: string, public age: number) {}
  public info(): string {
    return `${this.name}的年龄是 ${this.age}`;
  }
}

static

定义静态属性或方法，属性或方法是属于构造函数的 只能通过构造函数自身访问，不能通过构造函数的 constructor 进行访问

class Site {
  static url: string = "xxx";
  static getSiteInfo() {
    return Site.url;
  }
}
Site.getSiteInfo();

单例模式

将 constructor 类型修饰为非 public 时，不能创建类的实例对象

class User {
  protected constructor() {}
}

const test = new User(); //报错

结合 static 即可实现单例模式，即只实例化一个对象

class User {
  static instance: User | null = null;
  protected constructor() {}
  public static make(): User {
    if (User.instance == null) User.instance = new User();
    return User.instance;
  }
}

const test = User.make();

get/set

可以动态设置和获取属性

class User {
  private _name;
  constructor(name: string) {
    this._name = name;
  }
  public get name() {
    return this._name;
  }
  public set name(value) {
    this._name = value;
  }
}

abstract

抽象类类似于类的模板，实现规范的代码定义 抽象方法是对方法的定义，子类必须实现这个方法 抽象类不可以直接使用，只能被继承 抽象类可以不包含抽象方法，但抽象方法必须存在于抽象类中

abstract class Animation {
  abstract move(): void;
  abstract name: string;
  protected getPos() {
    return { x: 100, y: 300 };
  }
}
class Tank extends Animation {
  name: string = "坦克";
  public move(): void {}
}
class Player extends Animation {
  name: string = "玩家";
  public move(): void {}
}

Interface

用于描述类和对象的结构

• 抽象类

interface AnimationInterface {
  name: string;
  move(): void;
}
abstract class Animation {
  protected getPos(): { x: number; y: number } {
    return { x: 100, y: 300 };
  }
}
class Tank extends Animation implements AnimationInterface {
  name: string = "敌方坦克";
  public move(): void {
    console.log(`${this.name}移动`);
  }
}

• 对象

  约束对象的数据类型及格式

interface UserInterface {
  name: string;
  age: number;
  isLock: boolean;
  info(other: string): string;
}
const hd: UserInterface = {
  name: "xxxx",
  age: 18,
  isLock: false,
  info(o: string) {
    return `${this.name}已经${this.age}岁了,${o}`;
  },
};

• 接口继承

  interface 接口之间彼此进行继承

interface PlayEndInterface {
  end(): void;
}
interface AnimationInterface extends PlayEndInterface {
  name: string;
  move(): void;
}

// 对象可以使用多个接口
interface PlayEndInterface {
  end(): void;
}
interface AnimationInterface {
  name: string;
  move(): void;
}
class Player extends Animation implements AnimationInterface, PlayEndInterface {
  name: string = "xxx";
  public move(): void {
    console.log(`${this.name}`);
  }
  end() {
    console.log("end");
  }
}

// 同名接口声明会进行合并
interface User {
  name: string;
}
interface User {
  age: number;
}
const test: User = {
  name: "xxx",
  age: 18,
};

// interface 也可以 extends 继承 type
type Admin = {
  role: string;
};
interface User extends Admin {
  name: string;
}

• 函数

  约束函数的参数与返回值

interface UserInterface {
  name: string;
  age: number;
  isLock: boolean;
}

function lockUser(user: UserInterface, state: boolean): UserInterface {
  user.isLock = state;
  return user;
}

//可以约束函数的定义
interface Pay {
  (price: number): boolean;
}
const getUserInfo: Pay = (price: number) => true;

• 构造函数

  使用 interface 可以优化代码

interface UserInterface {
  name: string;
  age: number;
}
class User {
  info: UserInterface;
  constructor(user: UserInterface) {
    this.info = user;
  }
}

• 数组

interface UserInterface {
  name: string;
  age: number;
  isLock: boolean;
}

const test: UserInterface = {
  name: "xxxx",
  age: 18,
  isLock: false,
};

• 枚举

enum SexType {
  BOY,
  GIRL,
}

interface UserInterface {
  name: string;
  sex: SexType; //设置为枚举类型
}

const hd: UserInterface = {
  name: "xxx",
  sex: SexType.GIRL,
};

type

type 与 interface 非常相似都可以描述一个对象或者函数 使用 type 用于定义类型的别名，是非常灵活的类型定义方式 type 与 interface 都是可以进行扩展

• 基本语法

type User = {
  name: string;
  age: number;
};
const test: User = { name: "xxxx", age: 18 };

• 类型别名

//基本类型别名
type IsAdmin = boolean;

//定义联合类型
type Sex = "boy" | "girl";

type User = {
  isAdmin: IsAdmin;
  sex: Sex;
};
const test: User = {
  isAdmin: true,
  sex: "boy",
};

• 索引类型

interface User {
  [key: string]: any;
}

type UserTYpe = {
  [key: string]: any;
};

• 声明继承

// 报错，不允许同名重复声明
type User {
    name: string
}
type User {
    age: number
}

type Admin = {
  role: string;
  isSuperAdmin: boolean;
};
type Member = {
  name: string;
};

type User = Admin & Member; //不允许type与interface使用&进行合并
type User = Admin | Member; //声明满足一个即可

implements

class 可以使用 implements 来实现 type 或 interface

type Member = {
  name: string;
};

class User implements Member {
  name: string = "xxxx";
}