Classes in TypeScript

;(function () {
  // Define class class Person {
    // Public attributes, can be omitted by default public name: string
    // Constructor constructor(name: string) {
      // Initialize the name property this.name = name
    }
  }
  // Instantiate class const person = new Person('Yiwan Zhou')
  console.log(person.name) // Yiwan Zhou})()

;(function () {
  class Person {
    constructor(public name: string) {}
  }
  // Instantiate class const person = new Person('Yiwan Zhou')
  console.log(person.name) // Yiwan Zhou})()

;(function () {
  // Define a base class, also known as a superclass class Person {
    // Define a name property in the base class constructor(public name: string) {}
  }
  // Define a derived class, also known as a subclass, that inherits from the base class class Programmer extends Person {
    constructor(name: string, public hobby: string) {
      // Call the base class constructor super(name) through super
    }
  }
  // Instantiate subclass const programmer = new Programmer('一碗周', 'coding')
  console.log(programmer.name, programmer.hobby) // A bowl of weekly coding
})()

// Define a Person class class Person {
    constructor(public name: string) {}
    // Define a method sayMy() {
        console.log(`My name: ${this.name}`)
    }
}
// Define an Adult class that inherits from the Person class class Adult extends Person {
    constructor(public age: number) {
        super('the other side is prosperous')
    } // Override parent class method sayMy() {
        console.log(`My name: ${this.name} Age: ${this.age}`)
    }
}
// Define a Programmer class that inherits from the Adult class class Programmer extends Adult {
    constructor(public hobby: string) {
        super(18)
    } // Override parent class method sayMy() {
        console.log(
            `My name: ${this.name} Age: ${this.age} Hobby: ${this.hobby}`
        )
    }
}
// Class instantiation const programmer = new Programmer('coding')
programmer.sayMy() // My name: Bi'an Fanhua Age: 18 Hobbies: coding

// Define a Person class that contains public members, private members, and protected members.
class Person {
  public name: string
  // It is generally agreed that private members start with _ private _age: number
  protected hobby: string
  // Property initialization 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)
  }
}

// Instantiate the Person class const person = new Person('一碗周', 18, 'coding')

console.log(person.name) // 一碗周//Accessing private members outside the class throws an exception// console.log(person._age) // report an error//Accessing protected members outside the class throws an exception// console.log(person.hobby) // report an error//Private members and protected members can be accessed within the class person.sayMy() // 一碗周18 coding

// Define a class that inherits from the Person class class Programmer extends Person {
  constructor(name: string, age: number, hobby: string) {
    super(name, age, hobby)
  }
  sayMy() {
    console.log(this.name) // 一碗周// Private members of the parent class cannot be accessed in the subclass // console.log(this._age) // Error report// Protected members can be accessed in the subclass console.log(this.hobby) // coding
  }
}

// Instantiate the Programmer class const programmer = new Programmer('一碗周', 18, 'coding')
programmer.sayMy()

// Ensure that there is no conflict with members in other code export {}

// Define a Person class class Person {
  // It is agreed that private members usually start with _ private _name: string
  // Property initialization constructor(name: string) {
    this._name = name
  }
  // Get the private _name attribute value get getName(): string {
    return this._name
  }
  // Set the private _name property value set setName(name: string) {
    this._name = name
  }
}
// Instantiate class const person = new Person('a bowl of porridge')
// Get it by getName console.log(person.getName) // A bowl of porridge // Set the value of _name by setName person.setName = 'A bowl of porridge'
// Re-acquire console.log(person.getName) // Yiwan Zhou

// Define a class with a read-only attribute class Person {
  // readonly name: string
  // equivalent to // public readonly name: string
  // constructor(name: string) {
  // this.name = name
  // }
  // or constructor(public readonly name: string) {}
}
// Instantiation const person = new Person('一碗周')
console.log(person.name) // 一碗周// modify the value of name// person.name = '一碗周' // Error! name is read-only.

class Hero {
  // Counter static count = 0
  constructor(public name: string) {
    // Create a property count each time ++
    ++Hero.count
  }
}
// Instantiate a Hero class const hero1 = new Hero('Sun Wukong')
console.log(Hero.count) // 1
const hero2 = new Hero('Nezha')
console.log(Hero.count) // 2

// Use the abstract keyword to define an abstract class, which does not need to be initialized and is only used as a base class. abstract class Department {
  // Initialize the name member, parameter attribute constructor(public name: string) {}

  printName(): void {
    console.log('Department name: ' + this.name)
  }
  // Abstract methods must include the abstract keyword abstract printMeeting(): void // Must be implemented in derived classes}

class AccountingDepartment extends Department {
  constructor() {
    super('Accounting Department') // You must call super() in the constructor of a derived class
  }

  printMeeting(): void {
    console.log('The accounting department is responsible for managing money')
  }
}

// const department = new Department() // Throws exception: cannot create an instance of an abstract class // Instantiate abstract subclass const department = new AccountingDepartment()
// Call the method in the abstract class department.printName() // Department name: Accounting Department // Call the abstract method implemented in the derived class department.printMeeting() // The Accounting Department is the department responsible for managing money

// Define a class class Point {
    x: number
    y: number
}
// Define an interface inheritance and class interface Point3d extends Point {
    z: number
}

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

// define interface Eat {
  eat(food: string): void
}
interface Run {
  run(distance: number): void
}

// Define class to implement interface class Person implements Eat, Run {
  eat(food: string): void {
    console.log(food)
  }
  run(distance: number) {
    console.log(distance)
  }
}
export {}