类 Class

类的基本组成

class Greeter {
    // 公有变量
    greeting: string;
    // 构造函数
    constructor(message: string){
        this.greeting = message;
    }
    // 公共函数
    greet(){
        return this.greeting;
    }
}

let greeter = new Greeter('word')；

// 类内部，访问自己的属性，要用this  表示访问的是当前类的成员

继承 extends

// 先定义一个类

class Animal {
    // 接收一个参数为number 类型， 且默认值为0
    move(num: number = 0){
        console.log(num);
    }
}

// 定义一个新的类 继承第一个类

class Dog extends Animal {
    bark(){
        console.log('3123')
    }
}

// 实例化这个类
const dog = new Dog();
dog.bark();
dog.move(10);

修饰符 public private protected

//1. public 公有的属性 或者函数   默认 都是public

class Animal {
    // name  和 age  一样都是public  
    public name: string;
    age: number;
}


// 2. private 私有的， 它不能再声明它的类的外部进行访问

class Animal {
    private name: string;
    contructor(theName: string){
        this.name = theName;
    }
}

let animal = new Aniaml("Dog");
animal.name // 这个是访问不到的，只能在其类的内部访问


// 3. protected 受保护的   protected 成员在派生类中 也就是子类中依然可以访问  实例不能进行访问


class Person {
    protected name: string;
    constructor(name: string) { this.name = name; }
}

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");
console.log(howard.getElevatorPitch());
console.log(howard.name); // 错误

修饰符 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 是只读的.

存取器 get set 方法

class Employee {
    private _fullName: string;

    get fullName(): string {
        return this._fullName;
    }

    set fullName(newName: string) {
       this._fullName = newName
    }
}

静态属性 static

// 静态成员存在于类的本身，而不是类的实例上，也就是说你访问这些类的实例属性的时候
// 类名.属性名

class Animal {
    static origin = { x: 1, y: 2};
    greet(){
        console.log(Animal.origin)
    }
    contructor (public num: number ){};
}

抽象类 abstract

// 利用关键字 abstract 将类设置为抽象类，一般不会被实例化

abstract class Animal {
    abstract makeSound(): void;
    move():void {
         console.log(123)
    }
}

类的高级技巧----构造函数

class Greeter {
    static standardGreeting = "Hello, there";
    greeting: string;
    greet() {
        if (this.greeting) {
            return "Hello, " + this.greeting;
        }
        else {
            return Greeter.standardGreeting;
        }
    }
}

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

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

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

//这个例子里， greeter1与之前看到的一样。 我们实例化 Greeter类，并使用这个对象。 与我们之前看到的一样。

//再之后，我们直接使用类。 我们创建了一个叫做 greeterMaker的变量。 这个变量保存了这个类或者说保存了类构造函数。 然后我们使用 typeof Greeter，意思是取Greeter类的类型，而不是实例的类型。 或者更确切的说，"告诉我 Greeter标识符的类型"，也就是构造函数的类型。 这个类型包含了类的所有静态成员和构造函数。 之后，就和前面一样，我们在 greeterMaker上使用 new，创建 Greeter的实例。

类的高级技巧----把类当做接口使用

class Point {
    x: number;
    y: number;
}

interface Point3d extends Point {
    z: number;
}

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