TypeScript中的类

;(function () {
  // 定义类
  class Person {
    // 公共属性，默认可以不写
    public name: string
    // 构造函数
    constructor(name: string) {
      // 初始化name属性
      this.name = name
    }
  }
  // 实例化类
  const person = new Person('一碗周')
  console.log(person.name) // 一碗周
})()

;(function () {
  class Person {
    constructor(public name: string) {}
  }
  // 实例化类
  const person = new Person('一碗周')
  console.log(person.name) // 一碗周
})()

;(function () {
  // 定义一个基类，又称超类
  class Person {
    // 在基类中定义一个name属性
    constructor(public name: string) {}
  }
  // 定义一个派生类，又称子类，继承于基类
  class Programmer extends Person {
    constructor(name: string, public hobby: string) {
      // 通过 super 调用基类的构造函数
      super(name)
    }
  }
  // 实例化子类
  const programmer = new Programmer('一碗周', 'coding')
  console.log(programmer.name, programmer.hobby) // 一碗周 coding
})()

// 定义一个 Person类
class Person {
    constructor(public name: string) {}
    // 定义一个方法
    sayMy() {
        console.log(`我的名字: ${this.name}`)
    }
}
// 定义一个 Adult 类继承于 Person 类
class Adult extends Person {
    constructor(public age: number) {
        super('彼岸繁華')
    } // 重写父类方法
    sayMy() {
        console.log(`我的名字: ${this.name} 年龄: ${this.age}`)
    }
}
// 定义一个 Programmer 类继承于 Adult 类
class Programmer extends Adult {
    constructor(public hobby: string) {
        super(18)
    } // 重写父类方法
    sayMy() {
        console.log(
            `我的名字: ${this.name} 年龄: ${this.age} 爱好: ${this.hobby}`
        )
    }
}
// 类的实例化
const programmer = new Programmer('coding')
programmer.sayMy() // 我的名字: 彼岸繁華 年龄: 18 爱好: coding

// 定义一个 Person 类，其中包含 public 成员 private 成员和 protected 成员。
class Person {
  public name: string
  // 约定 私有成员一般采用 _ 开头
  private _age: number
  protected hobby: string
  // 属性初始化
  constructor(name: string, age: number, hobby: string) {
    this.name = name
    this._age = age
    this.hobby = hobby
  }
  sayMy() {
    console.log(this.name, this._age, this.hobby)
  }
}

// 实例化 Person 类
const person = new Person('一碗周', 18, 'coding')

console.log(person.name) // 一碗周
// 类外访问私有成员 抛出异常
// console.log(person._age) // 报错
// 类外访问保护成员 抛出异常
// console.log(person.hobby) // 报错

// private 成员和 protected 成员可以在类内访问
person.sayMy() // 一碗周 18 coding

// 定义一个类继承与 Person 类
class Programmer extends Person {
  constructor(name: string, age: number, hobby: string) {
    super(name, age, hobby)
  }
  sayMy() {
    console.log(this.name) // 一碗周
    // 在子类不可以访问父类的私有成员
    // console.log(this._age) // 报错
    // 在子类可以访问受保护的成员
    console.log(this.hobby) // coding
  }
}

// 实例化 Programmer 类
const programmer = new Programmer('一碗周', 18, 'coding')
programmer.sayMy()

// 确保跟其他代码中的成员冲突
export {}

// 定义一个 Person 类
class Person {
  // 约定 私有成员一般采用 _ 开头
  private _name: string
  // 属性初始化
  constructor(name: string) {
    this._name = name
  }
  // 获取 私有的 _name 属性值
  get getName(): string {
    return this._name
  }
  // 设置 私有的 _name 属性值
  set setName(name: string) {
    this._name = name
  }
}
// 实例化类
const person = new Person('一碗粥')
// 通过 getName 的方式获取
console.log(person.getName) // 一碗粥
// 通过 setName 的方式设置 _name 的值
person.setName = '一碗周'
// 重新获取
console.log(person.getName) // 一碗周

// 定义一个类，且具有一个只读属性
class Person {
  // readonly name: string
  // 等同于
  // public readonly name: string
  // constructor(name: string) {
  //     this.name = name
  // }
  // 或者
  constructor(public readonly name: string) {}
}
// 实例化
const person = new Person('一碗周')
console.log(person.name) // 一碗周
// 修改name的值
// person.name = '一碗周' // 错误! name 是只读的.

class Hero {
  // 计数器
  static count = 0
  constructor(public name: string) {
    // 每创建一个属性 count ++
    ++Hero.count
  }
}
// 实例一个 Hero 类
const hero1 = new Hero('孙悟空')
console.log(Hero.count) // 1
const hero2 = new Hero('哪吒')
console.log(Hero.count) // 2

// 通过 abstract 关键字 定义一个抽象类，该类不必进行初始化，仅作为基类使用
abstract class Department {
  // 初始化name成员，参数属性
  constructor(public name: string) {}

  printName(): void {
    console.log('部门名称: ' + this.name)
  }
  // 抽象方法必须包含 abstract 关键字
  abstract printMeeting(): void // 必须在派生类中实现
}

class AccountingDepartment extends Department {
  constructor() {
    super('会计部') // 在派生类的构造函数中必须调用super()
  }

  printMeeting(): void {
    console.log('会计部是负责管钱的部门')
  }
}

// const department = new Department() // 抛出异常：不能创建一个抽象类的实例
// 实例化抽象子类
const department = new AccountingDepartment()
// 调用抽象类中的方法
department.printName() // 部门名称: 会计部
// 调用在派生类实现的抽象方法
department.printMeeting() // 会计部是负责管钱的部门

// 定义一个类
class Point {
    x: number
    y: number
}
// 定义一个接口继承与类
interface Point3D extends Point {
    z: number
}

let point3d: Point3d = { x: 1, y: 2, z: 3 }

// 定义接口
interface Eat {
  eat(food: string): void
}
interface Run {
  run(distance: number): void
}

// 定义类实现接口
class Person implements Eat, Run {
  eat(food: string): void {
    console.log(food)
  }
  run(distance: number) {
    console.log(distance)
  }
}
export {}