TypeScript基础学习随笔3-类（类的定义，继承，修饰符，static，抽象类）

1.类的定义

// js
function Person1(name) {
  this.name = name
  this.print = function() {
    console.log(this.name)
  }
}
let p1 = new Person1("aaa")
p1.print()

// ts
class Person2 {
  name:string
  age:number
  constructor(name:string,age:number) {
    this.name = name
    this.age = age
  }
  print() {
    return this.name+":"+this.age
  }
}
let p2 = new Person2("huangyi",18)
console.log(p2.print()) // huangyi:18
复制代码

2.类的继承

class Student extends Person2 {
  cardnumber:string
  school:string
  constructor(cardnumber:string,school:string,name:string,age:number) {
    super(name,age)
    this.cardnumber = cardnumber
    this.school = school
  }
  msg() {
    return this.name+"今年"+this.age+"岁，就读于"+this.school+",编号"+this.cardnumber
  }
}
let stu1 = new Student("1001","xxx大学","huangyi",18)
// stu1.cardnumber = "001"
// stu1.school = "xxx大学"
console.log(stu1.msg()) // huangyi今年18岁，就读于xxx大学,编号001

复制代码

3.接口的继承

interface Printer {
  getmsg()
}
// ColorPrinter这个接口继承Printer接口
interface ColorPrinter extends Printer {
  printing()
}
// 实现接口
class HYPrinter implements ColorPrinter {
  getmsg() {
    console.log("HY1001")
  }
  printing() {
    console.log("打印成功！")
  }
}
let hy = new HYPrinter()
hy.getmsg() // HY1001
hy.printing() // 打印成功！
复制代码

4.访问修饰符

// public公有的 / private私有的 / protected受保护的
class Person3 {
  public name:string
  private age:number
  protected email:string
  constructor(name:string,age:number,email:string) {
    this.name = name
    this.age = age
    this.email = email
  }
  print() {
    return this.name+":"+this.age+"，邮箱为："+this.email
  }
}
let p3 = new Person3("huangyi",18,"[email protected]")
console.log(p3.name)
// console.log(p3.age) // 报错: 属性“age”为私有属性，只能在类“Person3”中访问
// console.log(p3.email) // 报错: 属性“email”受保护，只能在类“Person3”及其子类中访问
console.log(p3.print())  // huangyi:18，邮箱为：[email protected]

class Student2 extends Person3 {
  show() {
    console.log(this.name) 
    // console.log(this.age) // 报错: 属性“age”为私有属性，只能在类“Person3”中访问
    console.log(this.email) 
  }
}
复制代码

5.静态属性和静态方法

// js中
function Person4() {
  // 实例属性
  this.name = "huangyi"
  // 实例方法
  this.print = function(){}
}
// 静态属性
Person4.age = 18
// 静态方法
Person4.print1 = function(){}
// 调用静态方法
Person4.print1()

let p4 = new Person4()
// 调用实例方法
p4.print()

// ts中
class Person5 {
  // 实例属性
  name:string
  age:number
  // 静态属性
  static email:string
  constructor(name:string,age:number,email:string) {
    this.name = name
    this.age = age
    Person5.email = email
  }
  // 实例方法
  print() {
    return this.name+":"+this.age +"，邮箱为："+Person5.email
  }
  // 静态方法
  static show() {
    console.log("show()方法")
  }
}
// 调用静态方法
Person5.show() // show()方法
let p5 = new Person5("huangyi",18,"[email protected]")
// 调用实例方法
console.log(p5.print()) // huangyi:18，邮箱为：[email protected]
复制代码

6.多态

class Animal1 {
  eat() {
    console.log("animal1 eat")
  }
}
class Cat1 extends Animal1 {
  eat() {
    console.log("猫吃鱼")
  }
}
class Dog1 extends Animal1 {
  eat() {
    console.log("狗吃肉")
  }
}
let cat = new Cat1()
cat.eat()
复制代码

7.抽象类/抽象方法

// 1抽象类是提供其他类继承的基类（父类），不能直接被实例
// 2抽象方法只能包含在抽象类中，抽象类中可以包含抽象方法和非抽象方法
// 3子类继承抽象类，实现抽象方法

// 定义
abstract class Animal2 {
  abstract eat()
  run() {
    console.log("run run run")
  }
}
class Cat2 extends Animal2 {
  // 不写eat方法会报错: 非抽象类“Cat2”不会实现继承自“Animal2”类的抽象成员“eat”
  eat() {
    console.log("猫吃鱼")
  }
}
class Dog2 extends Animal2 {
  eat() {
    console.log("狗吃肉")
  }
}
let cat2 = new Cat2()
cat2.eat() // 猫吃鱼
let dog2 = new Dog2()
dog2.eat() // 狗吃肉
复制代码