//类的定义
class Animal{
    id:string;//默认访问修饰符为 public ： 类本身、子类、类外部可访问
    public name:string; // public ： 类本身、子类、类外部可访问
    protected type:string = '动物'; // 保护成员 protected， 类本身、子类可访问， 类外部不可访问
    private color:string; // 私有成员 private: 类本身访问， 子类、类外部不可访问

    //构造函数
    constructor(id:string, name:string,color:string){
        this.id = id;
        this.name = name;
        this.color = color;
    }

    //实例方法
    run(){
        console.log(`${this.name}（编号为：${this.id}）在跑步`);
    }
}

//类的继承：继承关键字 extends
class Dog extends Animal{
    constructor(id:string, name:string, color:'白色'){
        super(id, name,color);//调用父类的构造函数
    }

    getDogInfo(){
        this.type = '小狗';
        //console.log(`品种：${this.type}; 名字：${this.name}; 颜色：${this.color}`); // this.color 报错，原因是color在父类中是私有成员，只能在父类中访问，所以报错
        console.log(`品种：${this.type}; 名字：${this.name}; `);
    }
}

let xioahong = new Dog('0001', '小白', '白色');
xioahong.run(); // 输出    小白（编号为：0001）在跑步
xioahong.getDogInfo();  //输出    品种：小狗; 名字：小白;

//类修饰符
//public : 公共属性，本类、子类、类外部均可访问
//protected: 保护成员，本类、子类中可访问，类外部不可访问
//private: 私有成员， 本类中可以访问，子类、类外部不可访问

//类中的静态属性、静态方法
class Cat {
    name:string = '小花猫';
    static tizhong:number = 12;
    static eat(){
        console.log(`${this.name}的体重为${Cat.tizhong}斤`);
    }
}
Cat.tizhong = 49; //调用静态属性
Cat.eat(); // 调用静态方法， 输出：  Cat的体重为49斤
/**
 * 解析：
 * 这里本来预期的输出应该是： 小花猫的体重为49斤， 但是 最终静态方法中无法获取到name属性的值
 * 静态方法是属于类的，即静态方法是随着类的加载而加载的，在加载类时，程序就会为静态方法分配内存
 * 非静态方法是属于对象的，对象是在类加载之后创建的
 * 静态方法先于对象存在,所以如果静态方法调用非静态方法的话，可能会报空指针异常。
 * 因此： 静态方法不能直接访问非静态属性，但是可以直接访问静态属性，访问方法为： [类名].[属性]
 * **/

//抽象类：

/**
 *  抽象的关键字： abstract
 *  抽象类是为其他类提供继承的基类，是给其他类定义的标准。
 *  抽象类不能直接被实例化
 *  抽象类必须包含至少一个抽象方法
 *  抽象方法的声明不包含具体的实现
 */
abstract class Person {
    abstract run():void;
    abstract getInfo():string;
}

//let p = new Person(); // 报错， 抽象类不能直接被实例化

/**
 * 继承抽象类：
 * 在这里 Gril 为派生类， Person 为基类
 * 派生类必须实现基类中的抽象方法
 */
class Gril extends Person{
    name:string;
    constructor(name:string){
        super();
        this.name = name;
    }

    //这里实现了Person类中的抽象方法 run()
    run(){
        console.log(`${this.name}在跑步`)
    }

    //这里实现了Person类中的抽象方法 getInfo()
    getInfo(): string {
        return this.name;
    }
}

let xiaohong = new Gril('小红');
xiaohong.run(); // 输出：小红在跑步
console.log(xiaohong.getInfo()); //输出  小红


//多态
// 万物皆对象，任何对象都会有不同的形态，这叫多态，比如 树叶是一个对象，但是树叶有不同的形状，这就是多态，又比如，都是动物，但是动物又分很多种，这就是多态
// 在代码中，多态其实就是继承，提供一个基类给多个对象继承

/**
 * 声明一个基类， 植物
 */
class Botany {
    name:string;
    constructor(name:string){
        this.name = name;
    }
    GrowUp(){
        console.log(`我是${this.name},我正在茁壮成长`);
    }
}

/**
 * 仙人掌是一种植物，继承 植物 这个对象
 */
class Cactus extends Botany{
    thorn:string = '尖尖';
    constructor(name:string){
        super(name)
    }
    growsThorns():void{
        console.log(`我是一颗${this.name}，我身上会长很多${this.thorn}的刺`);
    }
}


/**
 * 百合花是一种植物，继承 植物  这个对象
 */
class Lily extends Botany{
    leaf:string = '绿色';
    constructor(name:string){
        super(name)
    }
    growsLeaf():void{
        console.log(`我是一颗${this.name}，我身上会长很多${this.leaf}的叶子`);
    }
}

//实例化一个仙人掌对象
let cactus = new Cactus('仙人掌');
cactus.GrowUp(); // 输出：     我是仙人掌,我正在茁壮成长
cactus.growsThorns(); // 输出：  我是一颗仙人掌，我身上会长很多尖尖的刺

//实例化一个玫瑰花的对象
let lily = new Lily('百合花');
lily.GrowUp();  // 输出： 我是百合花,我正在茁壮成长
lily.growsLeaf();  // 输出： 我是一颗百合花，我身上会长很多绿色的叶子