typescript 类 实现多重继承 typescript重载

admin2024-06-04  8

  1. 重写和重载的的区分:
    重写是存在类与类之间的;重载没有类与类之间的说法,比如同一个类里面方法名字相同,但是他们的参数不同(包括参数的顺序,个数,类型不同),那么这些函数就是重载。通过传入的参数不同匹配相应的方法。需要注意的是,是不是重载和函数返回值类型无关,即使两个函数函数名以及参数一样,但是返回值类型不一样,它们也不能称作为重载。
// 重写
class Animal{
  move(){
    console.log('animal can move')
  }
}
class Snack extends Animal{
  move(){ // 重写
    console.log('snack can move')
  }
  black(){
    console.log('snack is black')
  }
}
const snack = new Snack();
snack.move()  // snack can move
  1. 派生类包含了构造函数,必须调用super(),super()它会执行基类的构造函数。 而且,在构造函数里访问 this的属性之前,我们 一定要调用 super()。
  2. 修饰符public, private, protected,readonly区别:
  • 默认是 public,哪里都能访问。
  • private:当成员被标记成 private时,它只能在它声明的类{}里面使用。它就不能在声明它的类的外部访问。

    一般的用法是:
class Animal {
  private name: string; // 私有成员变量
  constructor(theName: string) { this.name = theName; }
  getName(){
    return this.name
  }
  setName(name: string){
    this.name = name // 只能在当前类使用
  }
}

class Rhino extends Animal {
  constructor() { super("Rhino");}
}

class Employee {
  private name: string;
  constructor(theName: string) { this.name = theName; }
}

const animal = new Animal("Goat");
animal.setName('dog');
console.log(animal.getName()); // dog
let rhino = new Rhino();
let employee = new Employee("Bob");
  • protected成员在它声明的类{}中和派生类{}中可以访问。例如:
class Person{
  protected name: string;
  constructor(name: string){
    this.name = name;
  }
}

class Emplyee extends Person{
  constructor(name: string){
    super(name)
  }
  public getSalaryValue(money: number){
    console.log(`${this.name} get money$ ${money}`)
  }
}
const person = new Person('person');
const emplyee = new Emplyee('sandy');

emplyee.getSalaryValue(100000000) // sandy get money$ 100000000
person.name //Error: 属性“name”受保护,只能在类“Person”及其子类中访问。
  • 构造函数也可以被标记成 protected。 这意味着这个类不能在包含它的类外被实例化,但是能被继承。
class Person {
    protected name: string;
    protected constructor(theName: string) { this.name = theName; }
}

// Employee 能够继承 Person
class Employee extends Person {
    private department: string;

    constructor(name: string, department: string) {
        super(name);
        this.department = department;
    }

    public getElevatorPitch() {
        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
    }
}

let howard = new Employee("Howard", "Sales");
let john = new Person("John"); // 错误: 'Person' 的构造函数是被保护的.
  • 你可以使用 readonly关键字将属性设置为只读的。 只读属性必须在声明时或构造函数里被初始化。
class Octopus {
    readonly name: string;
    readonly numberOfLegs: number = 8;
    constructor (theName: string) {
        this.name = theName;
    }
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // 错误! name 是只读的.

4. 静态属性 static
// static 静态成员在内存中只会存在一份,它是属于类的,通过类名.的方式访问,不同的对象访问的时候,访问的都是同一个内存中的静态成员

class Animal{
  static names: string;
  constructor(name: string){
    Animal.names = name;
  }
  static move(removing: number){
    const str = `${Animal.names} can move ${removing}m`;
    console.log(str);
  }
}
class Snack extends Animal{
  constructor(){
    super('蛇')
  }
  eat(species: string){
    console.log(`${Animal.names} 吃 ${species}`)
  }
}

const animal = new Animal('cat');
const snack = new Snack();
// animal.move(5) //Error: 属性 "move" 不是类型为 "Animal" 的静态成员
Animal.move(5); // 蛇 can move 5m
snack.eat('耗子'); // 蛇 吃 耗子

5. 抽象类 abstract
抽象类为其它派生类的基类使用。不会直接被实例化。不同于接口的地方是,抽象类可以包含成员的实现细节。 abstract关键字是用于定义抽象类和在抽象类内部定义抽象方法。
抽象类中的抽象方法不包含具体实现并且必须在派生类中实现。 抽象方法的语法与接口方法相似的地方是: 两者都是定义方法签名但不包含方法体。 然而,抽象方法必须包含 abstract关键字并且可以包含访问修饰符。

abstract class Department {

    constructor(public name: string) {
    }

    printName(): void {
        console.log('Department name: ' + this.name);
    }

    abstract printMeeting(): void; // 必须在派生类中实现
}

class AccountingDepartment extends Department {

    constructor() {
        super('Accounting and Auditing'); // 在派生类的构造函数中必须调用 super()
    }

    printMeeting(): void {
        console.log('The Accounting Department meets each Monday at 10am.');
    }

    generateReports(): void {
        console.log('Generating accounting reports...');
    }
}

let department: Department; // 允许创建一个对抽象类型的引用
department = new Department(); // 错误: 不能创建一个抽象类的实例
department = new AccountingDepartment(); // 允许对一个抽象子类进行实例化和赋值
department.printName();
department.printMeeting();
department.generateReports(); // 错误: 方法在声明的抽象类中不存在(多态口诀,编译看左边,运行看右边)  *** 
// 上面这句代码等价于 let department: Department = department.generateReports(); 编译的时候看左边,由于Department不存在generateReports函数,所以直接报错。
//运行的时候看右边,就是看右边的对象是什么,就调用该对象的函数。
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明原文出处。如若内容造成侵权/违法违规/事实不符,请联系SD编程学习网:675289112@qq.com进行投诉反馈,一经查实,立即删除!