TS study notes class

class

Class inheritance

When there is constructor When we use constructors , Be sure to call super()-> Execute the constructor of the base class . Use... In derived classes this Be sure to use super()

class Animal {
    
	name: string;
	constructor(theName: string) {
    
		this.name = theName;
	}
	move(name: string) {
    
		console.log(`${
      name} say ： I can move `);
	}
}
class Dog extends Animal {
    
	constructor(name: string) {
    
		super(name);
	}
	bark() {
    
		console.log(`${
      this.name} I can scream wildly `);
	}
	move() {
    
		// The subclass's method will override the parent's method 
		console.log(`${
      this.name} Say I can move by myself `);
		super.move(this.name); //  Calling the base class move Method 
	}
}
let dog = new Dog(' tearful ');
dog.bark();
dog.move();

public 、 Private and protected modifiers

• public( public ) -> The default value is js It can be written in Chinese, but not in Chinese
• private( private )
• protected( You can access... In a derived class )
• readonly( Read-only property )

More with private or protected Members of the type when , It's different . If one of the types contains a private member , So only if there is one of the other types private member , And they all come from the same declaration , Just think these two types are compatible . about protected Members also use this rule .

class Animal {
    
  private name: string;
  constructor(theName: string) {
     this.name = theName; }
}
class Rhino extends Animal {
    
  constructor() {
     super("Rhino"); }
}
class Employee {
    
  private name: string;
  constructor(theName: string) {
     this.name = theName; }
}
let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");
animal = rhino;
animal = employee; //  error : Animal  And  Employee  Are not compatible .

protected Member types can only be accessed and cannot be used , Constructors can also be marked as protected. This means that this class cannot be instantiated outside the class that contains it , But can be inherited .
Read only properties can only be used in constructor Function .

Static attribute

Static attributes exist on the class itself, not on instances of the class , You can use the class name . Property to access .

class Grid {
    
  static origin = {
    x: 0, y: 0};
  calculateDistanceFromOrigin(point: {
    x: number; y: number;}) {
    
    let xDist = (point.x - Grid.origin.x);
    let yDist = (point.y - Grid.origin.y);
    return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
  }
  constructor (public scale: number) {
     }
}

let grid1 = new Grid(1.0);  // 1x scale
let grid2 = new Grid(5.0);  // 5x scale

console.log(grid1.calculateDistanceFromOrigin({
    x: 10, y: 10}));
console.log(grid2.calculateDistanceFromOrigin({
    x: 10, y: 10}));

abstract class

Abstract classes are used as base classes for other derived classes . They are generally not instantiated directly . Unlike interfaces , Abstract classes can contain implementation details of members . Use abstract Keyword definition . Abstract methods in abstract classes do not contain concrete implementations and must be implemented in derived classes

abstract class Department {
    
  constructor(public name: string) {
    
  }
  printName(): void {
    
    console.log('Department name: ' + this.name);
  }
  abstract printMeeting(): void; //  Must be implemented in a derived class 
}
class AccountingDepartment extends Department {
    
  constructor() {
    
    super('Accounting and Auditing'); //  Must be called in the constructor of a derived class  super()
  }
  printMeeting(): void {
    
    console.log('The Accounting Department meets each Monday at 10am.');
  }
  generateReports(): void {
    
    console.log('Generating accounting reports...');
  }
}
let department: Department; //  Allows you to create a reference to an abstract type 
department = new Department(); //  error :  Cannot create an instance of an abstract class 
department = new AccountingDepartment(); //  Allows instantiation and assignment of an abstract subclass 
department.printName();
department.printMeeting();
department.generateReports(); //  error :  Method does not exist in the declared abstract class 

Use a class as an interface

Class definitions create two things ： Class and a constructor . Because classes can create types , So you can use classes where interfaces are allowed .

class Point {
    
	x: number;
	y: number;
}
interface Point3d extends Point {
    
	z: number;
}
let point3d: Point3d = {
     x: 1, y: 2, z: 3 };