Typescript极简版笔记--类

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第14天，点击查看活动详情

类

类有3个成员：一个叫做 greeting的属性，一个构造函数和一个 greet方法

class Greeter {
  greeting: string;
  constructor(message: string) {
      this.greeting = message;
  }
  greet() {
      return "Hello, " + this.greeting;
  }
}

let greeter = new Greeter("world");

类的继承 / get set

使用extends进行继承

class Greeter {
  public greeting: string; //默认public属性，包括construtor，greet
  //private name: string; //err new Greeter("xx").name 私有属性无法以这种方式访问
  constructor(message: string) {
      this.greeting = message;
  }
  get myatr(){//只带有 get不带有 set的存取器自动被推断为 readonly
    return this.greeting + '555'
  }
//   set setAtr(msg:string){
//       this.greeting = msg
//   }
  greet() {
      console.log("Hello, " + this.greeting) 
  }
}

let greeter = new Greeter("world");
class Dog extends Greeter {
  constructor(name: string) { super(name); }
  bark() {
      console.log('Woof! Woof!');
      super.greet()
  }
}
const dog = new Dog('gg');
console.log(dog.myatr)//
dog.bark(); 

protect的继承

class Person {
    protected name: string;
    protected constructor(theName: string) { this.name = theName; }//不能被实例化，但可以被继承
}

// Employee 能够继承 Person
class Employee extends Person {
    private department: string;
    //constructor(readOnly name: string, department: string) {这么写是一个`参数属性`
    constructor(name: string, department: string) {
        super(name);//使用Person的constructor
        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' 的构造函数是被保护的.

静态属性

静态属性需要通过类名进行访问

class Grid {
    static origin = {x: 0, y: 0};
    calculateDistanceFromOrigin(point: {x: number; y: number;}) {
        let xDist = (point.x - Grid.origin.x);
    }
    constructor (public scale: number) { }
}

抽象类

abstract class department{
    constructor(){
    }
    nomust(){
        // console.ll
    }
    abstract must():void //抽象函数，必须在子类中实现
}
class DD extends department {
    constructor(){
        super()
    }
    must():void{
    }
    some():void{

    }
}
let dd:department //类型可以为抽象类
// dd = new department()
dd = new DD()
dd.must()
dd.some()//err some不存在抽象类中
dd.nomust()

构造函数

class Greeter {
    greeting: string;
    constructor(message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}

let greeter: Greeter;
greeter = new Greeter("world");
console.log(greeter.greet());

转换成JS写法

let Greeter = (function () {
    function Greeter(message) {
        this.greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + this.greeting;
    };
    return Greeter;
})();

let greeter;
greeter = new Greeter("world");
console.log(greeter.greet());

复制一个类

let greeterMaker: typeof Greeter = Greeter;
greeterMaker.standardGreeting = "Hey there!";

let greeter2: Greeter = new greeterMaker();
console.log(greeter2.greet());

类当接口使用

class Point {
  x!: number ;//这里需要赋值断言 确定传入的是number类型
  y: number | undefined; //编辑器提供的俩种写法
}

interface Point3d extends Point {
  z: number;
}

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