- 重写和重载的的区分：
重写是存在类与类之间的；重载没有类与类之间的说法，比如同一个类里面方法名字相同，但是他们的参数不同（包括参数的顺序，个数，类型不同），那么这些函数就是重载。通过传入的参数不同匹配相应的方法。需要注意的是，是不是重载和函数返回值类型无关，即使两个函数函数名以及参数一样，但是返回值类型不一样，它们也不能称作为重载。
// 重写
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
- 派生类包含了构造函数，必须调用super(),super()它会执行基类的构造函数。 而且，在构造函数里访问 this的属性之前，我们 一定要调用 super()。
- 修饰符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函数，所以直接报错。
//运行的时候看右边，就是看右边的对象是什么，就调用该对象的函数。