typescript-类class

class Dog {
    constructor(name:string){
        this.name = name;
    }
    name:string
    run(){}
    private pri(){}
    protected pro(){}
    readonly legs:number = 4
    static food: string = "bones";
}

console.log(Dog.prototype);
let d1 = new Dog("dahuang");
console.log(d1)
console.log(d1.legs)
console.log(Dog.food)
//属性只在实例上 不在原型上
// 实例属性必须有初始值 或者在构造函数中初始化 或者设为可选属性


class  Husky extends Dog {
    constructor(name:string, public color:string){
        super(name);
        this.color = color;  //this一定要在super之后调用。
    }
    // color:string  构造函数参数被修饰会变成实例属性， 这里就不用再写了
} 
let hh = new Husky('xiaobai', 'red');
console.log(hh.legs)
console.log(Husky.food)  //静态属性可以被继承, 实例也不能访问
// console.log(hh.food)
// 修饰符
// public 公共的 
// private  私有属性 不能在实例使用  也不能被子类使用
// 构造函数 private 之后 ，既不能被实例化  也不能被继承
// protected  受保护成员只能在类 和子类中访问 不能在实例中访问， 修饰构造函数表示这个类只能被继承不能被实例化
// readonly  只读属性不能修改， 必须初始化
// static  类的静态成员只能通过类名调用， 不能通过子类来调用, 也不能通过实例来调用

// 构造函数的参数也能被修饰，作用是把参数变成类的实例属性



// -----抽象类

abstract class Animal{
    eat(){
        console.log( "eat somthing")
    }

    abstract sleep():void
}
// let animal = new Animal();  //抽象类无法实例化，只能被继承

class Cat extends Animal {
    constructor(public name:string){
        super();
        this.name = name;
    }
    run(){}
    sleep(){
        console.log("cat sleep")
    }
}
let cat = new Cat("miao");
cat.eat()
cat.sleep();

class Pig extends Animal {
    constructor(readonly name:string){
        super()
    }
    sleep(){
        console.log("pig sleep")
    }
}
let pig = new Pig("zhu");
console.log(pig.name)

let  animals:Animal[] = [cat, pig];

animals.forEach(i => {
    i.sleep();
})

// this
class  Workflow {
    step1(){
        console.info("step1")
        return this
    }
    step2(){
        console.info("step2")
        return this
    }
}

let workflow = new Workflow();
workflow.step1().step2();

class Myflow  extends  Workflow {
    next(){
        console.info("next")
        return this;
    }
}
let myflow = new Myflow();
myflow.next().step1().next().step2();