TypeScript--类

类：实例属性，实例方法，静态属性，静态方法，构造器，存取器(get,set)

• 基础类 ： class是关键字，用来声明一个类

class Person {
    name: string;
    age: number;
    constructor() {
        this.name = "wangcai"
        this.age = 20
    }
}
let p = new Person()
console.info(p.name)  //wangcai
console.info(p.age)   //20

• 构造器：构造器就是给类中的属性进行赋值操作;当new了一个类那么每一个对象上面都有一个name和一个age的属性，this的指向也是不固定的,始终指向你new出来的那个对象。

class Animal {
    name: string;
    age: number;
    constructor(name, age) {
        this.name = name;
        this.age = age
    }
}
let a = new Animal("pig", 12);
let b = new Animal("cat", 20);
console.info(a.name, a.age)   //pig 12
console.info(b.name, b.age)   //cat 20

• 存取器：存取器,TypeScript支持通过getters/setters来截取对对象成员的访问

  set xxx:获取某个属性---- get xxx:获取某个属性

class Person{
    private _name:string;
    constructor(name){
        this._name = name;
    }
    public get name():string{
        return this._name;
    }
    public set name(newName:string){
        this._name = newName;
    }
}
let p:Person = new Person("张三"); // p类型是Person
console.info(p.name)               //张三
p.name = "zhangsan"
console.info(p.name)               //zhangsan

• 继承：在TypeScript里，我们可以使用常用的面向对象模式。 基于类的程序设计中一种最基本的模式是允许使用继承来扩展现有的类。

class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
}
class Dog extends Animal {
    name: string;
    age: number;
    constructor(name,age) {
        super(name)   //调用父类构造器
        this.name =name;
        this.age = age
    }
}
let d = new Dog("doudou",12)
console.info(d.name)   //doudou
console.info(d.age)    //12

• 抽象类：如果不想让别人去创建父类的对象,可以把这个父类声明成抽象类(abstract),抽象类不能new

abstract class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
}
class Dog extends Animal {
    name: string;
    age: number;
    constructor(name,age) {
        super(name)   //调用父类构造器
        this.name =name;
        this.age = age
    }
}
let d = new Dog("doudou",12)
console.info(d.name)   //doudou
console.info(d.age)    //12

• 三个访问权限符

abstract:声明成抽象类,抽象类不能new，所以抽象类没有constructor

public:所有类可以访问

private：只能在本类中访问

protected：本类和继承该类的子类

readonly：该关键字可以将属性设置为只读的

abstract class Animal {
    public readonly name: string = "wangcai";
    protected age: number = 20;
    private money: number = 0;  //只能在类内访问

}
class Dog extends Animal {
    public getAge() {
        console.info(this.age);  //0
    }
}
let d = new Dog()
console.info(d.name)  //wangcai
d.getAge();   //console.info(this.age);

• 静态属性： 静态属性不属于某个实例，属于当前这个类，不能通过对象.age来获取age，静态属性需要通过类名来获取

class Animal {
    public name: string;   // 实例属性
    static age: number = 666; 
    constructor(name: string) {
        this.name = name;
    }
}
let a = new Animal("wangcai");
console.info(a.name)      //wangcai 
console.info(Animal.age)  // 666 

• 静态方法：和静态属性类似，由于f1是静态访问，只能通过类名来调用

class Animal {
    static f1() {
        console.info("....")
    }
}
let a = new Animal();
Animal.f1();