TS中的class类

1. JS定义class类

---

//定义类
class Person {
    
    
    constructor () {
    
    
 
    }
    run () {
    
    
        
    }
}

2. TS定义class类

---

// 定义class类
class Person{
    
    
  name: string
  age: number
  constructor(name:string, age:number){
    
    
    this.name = name
    this.age = age
  }
}

3. 类的修饰符（public、private和protected）

---

• 使用public修饰符，定义的变量内部外部都可以访问，如果不写默认就是public

/* public */
class Person {
    
    
  public name: string
  private age: number
  protected some: any
  constructor(name: string, age: number, some: any) {
    
    
    this.name = name
    this.age = age
    this.some = some
  }
  run() {
    
    

  }
}
let tom = new Person('Tom', 18, '青青子衿')
tom.name

• 使用 private修饰符，定义的变量私有的只能在内部访问，不能在外部访问

/* private */
class Person {
    
    
  public name: string
  private age: number
  protected some: any
  constructor(name: string, age:number, some: any) {
    
    
    this.name = name
    this.age = age
    this.some = some
  }
  run() {
    
    

  }
}
let tom = new Person('Tom', 18, '青青子衿')
tom.age
tom.some

• 使用protected修饰符，代表定义的变量私有的只能在内部和继承的子类中访问，不能在外部访问

/* protected */
class Person {
    
    
  public name: string
  private age: number
  protected some: any
  constructor(name: string, age: number, some: any) {
    
    
    this.name = name
    this.age = age
    this.some = some
  }
  run() {
    
    }
}

class Man extends Person {
    
    
  constructor() {
    
    
    super('张三', 18, 1)
    console.log(this.some);
  }

  created() {
    
    
    console.log(this.some);
  }
}

let tom = new Person('Tom', 18, '青青子衿')
let man = new Man
man.some

4. static静态属性和静态方法

---

• static定义的属性和函数，不可以通过this去访问，只能通过类名去调用

/* static静态属性和静态方法 */
class Person {
    
    
  public name: string
  private age: number
  protected some: any
  static nb: string = '123'
  constructor(name: string, age: number, some: any) {
    
    
    this.name = name
    this.age = age
    this.some = some
    // this.nb     //static定义的属性，不可以通过this去访问，只能通过类名去调用
    // this.run()  //static定义的函数，不可以通过this去访问，只能通过类名去调用
  }
  static run() {
    
    
    return console.log(this.name);
  }
}
Person.nb

• 需注意： 如果两个函数都是static 静态的是可以通过this互相调用

class Person {
    
    
  public name: string
  private age: number
  protected some: any
  static nb: string = '123'
  constructor(name: string, age: number, some: any) {
    
    
    this.name = name
    this.age = age
    this.some = some
  }
  static run() {
    
    
    return this.aaa()
  }
  static aaa(){
    
    
    return '青青子衿，悠悠我心'
  }
}
Person.nb

5. interface 定义类

---

• interface定义类,使用关键字implements, 后面跟interface的名字多个用逗号隔开,继承还是用extends

interface PersonClass {
    
    
  get(type: boolean): boolean
}

interface PersonClass2{
    
    
  set():void,
  asd:string
}

class A {
    
    
  name: string
  constructor() {
    
    
      this.name = "123"
  }
}

class Person extends A implements PersonClass,PersonClass2 {
    
    
  asd: string
  constructor() {
    
    
      super()
      this.asd = '123'
  }
  get(type:boolean) {
    
    
      return type
  }
  set () {
    
    }
}

6. 抽象类

---

• abstract 所定义的抽象类
• abstract所定义的方法, 都只能描述不能进行一个实现
• 抽象类无法被实例化

abstract class A {
    
    
  name: string
  constructor(name: string) {
    
    
    this.name = name;
  }
  print(): string {
    
    
    return this.name
  }

  abstract getName(): string
}

class B extends A {
    
    
  constructor() {
    
    
    super('小满')
  }
  getName(): string {
    
    
    return this.name
  }
}

let b = new B();

console.log(b.getName());