1、TypeScript 类

一、类的基本构成

类里面有有两个部分 1、属性   2、方法

//class 定义一个 City 类
class City{
    1、声明实例属性
    name: string;
    clevel: number;
    在属性前使用 static 关键字定义类属性（静态属性）
    static country = "中国";

    在属性前面加上readonly，属性会变成只读属性，只能读取不能修改。
    readonly provice = "湖南";

    //constructor 构造函数
    //构造函数会在对象创建时调用
    constructor(name: string, clevel: number){
        this.name = name;
        this.clevel = clevel;
    }
    //一般方法
    about(){
        //about方法放在了哪里? -类的原型对象 上，供实例使用
        //about中的this就是Person实例
        consloe.log(this)
        console.log(`欢迎来到${this.name},长沙是${this.clevel}级城市`);
    }
    static hello(){
        console.log("你好，长沙。")
    }

}
创建对象的实例
const c1 = new City("长沙", 1);
console.log(c1.name);
console.log(c1.provice);
c1.about();

//class中的方法默认开启了局部的严格模式，所以about中的this为undefined
const quanju = c1.about;
quanju();

console.log(City.country);
City.hello();

1.1、定义属性

直接定义的属性是实例属性，需要通过对象的实例去访问

const c1 = new City("长沙", 1);
c1.name;

在属性前使用 static 关键字定义类属性（静态属性）,直接通过类访问。

City.country;

1.1、定义方法

直接定义的方法是实例方法，需要通过对象的实例去访问

const c1 = new City("长沙", 1);
c1.about();

在属性前使用 static 关键字定义类方法（静态方法）,直接通过类访问。

City.hello();

二、类的继承简介(extends)和 super关键字

(function(){
    // 定义一个动物的类
    class Animal{
        name: string;
        age: number;

        constructor(name: string, age: number){
            this.name = name;
            this.age = age;
        }

        say(){
            console.log("动物在叫");
        }
    }
    /**
     * class Dog extends Animal
     * 此时 Animal 被称为父类，Dog 被称为子类
     * 继承父类后，子类会拥有父类所有的属性和方法
     * 通过继承我们可以把多个类中共有的代码写在一个父类中
     * 这样只需要写一次就能让所有的子类拥有父类的属性和方法
     */
    // 定义一个狗类
    // 使 Dog 类继承 Animal 类
    class Dog extends Animal{
        height: number;
        width: number;
        constructor(name: string, age: number, height: number, width: number){
            /**
             * 在子类中写了构造函数，则在子类的构造函数中必须调用 父类 的构造函数(通过super调用)
             */
            super(name, age);//调用父类的构造函数
            this.height = height;
            this.width = width;
        }
        run(){
            console.log(`${this.name},在愉快的奔跑。`);
            super.say();//调用父类的方法
        };
        /**
         * 如果子类中添加了和父类相同的方法，则子类的方法会覆盖父类的方法
         * 这种子类覆盖掉父类的形式，我们称之为方法的重写
         */
        say(){
            console.log("汪汪汪---")
        };
    }
    // 定义一个猫类
    // 使 Cat 类继承 Animal 类
    class Cat extends Animal{
        say(){
            console.log("喵喵喵---")
        };
    }
    let dog = new Dog("旺财", 4, 80, 100);
    console.log(dog);
    dog.say();
    dog.run();

    let cat = new Cat("菲菲", 3);
    console.log(cat);
    cat.say();
})();

三、抽象类

(function(){
    // 定义一个动物的类
    /**
     * 以 abstract 开头的类就是抽象类
     * 抽象类和其他的类差别不大，只是不能用来创建对象
     * 抽象类就是专门用来继承的类
     * 抽象类中可以添加抽象方法
     */
    abstract class Animal{
        name: string;
        age: number;

        constructor(name: string, age: number){
            this.name = name;
            this.age = age;
        }
        /**
         * 定义一个抽象方法
         * 抽象方法使用 abstract 开头，没有方法体
         * 抽象方法只能定义在抽象类中，子类必须对抽象方法进行重写 
         */
        abstract say(): void;
    }

    // 定义一个狗类
    class Dog extends Animal{
        height: number;
        width: number;
        constructor(name: string, age: number, height: number, width: number){
            super(name, age);//调用父类的构造函数
            this.height = height;
            this.width = width;
        }
        say(){
            console.log("汪汪汪---")
        };
    }
    let dog = new Dog("旺财", 4, 80, 100);
    console.log(dog);
    dog.say();
})();

四、接口

(function(){
    /**
     * 接口用来定义一个类结构，用来定义一个类中应包含那些属性和方法
     * 接口定义类的时候限制了类的结构
     * 属性: 接口中所有的属性都不能有实际的值
     *       接口只定义对象的结构，而不考虑实际值
     * 方法: 接口中所有的方法都是抽象方法
     */
    interface myInter{
        name: string;

        say(): void;
    }

    /**
     * 定义类时可以实现接口
     * 实现接口就是使类满足接口 定义的类结构
     */
    class MyClass implements myInter{
        name: string;

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

        say(): void{
            console.log("大家好！！！")
        }
    }
})();

五、属性的封装

(function(){
    // 定义一个人类
    class Person{
        /**
         * TS 可以在属性前添加属性修饰符
         * public 修饰的属性可以在任意位置访问（修改） 默认值
         * private 私有属性，只能在类内部进行访问（修改）
         *      通过在类中添加方法，使得私有属性可被外部访问
         * protected 受保护的属性，只能在当前类和当前类的子类中访问（修改）
         */
        private _name: string;
        private _age: number;
        protected height: number

        constructor(name: string, age: number, height: number){
            this._name = name;
            this._age = age;
            this.height = height;
        }

        // 定义一个方法,用来获取 age 属性
        getAge(){
            return this._age;
        }
        // 定义一个方法,用来设置 age 属性
        setAge(age: number){
            if(age >= 0){
                this._age = age;
            }
        }

        // TS中 getter 的方式获取属性
        get name(){
            return this._name;
        }
        // TS中 setter 的方式获取属性
        set name(name: string){
            this._name = name;
        }
    }

    class Students extends Person{
        getHeight(){
            return this.height;
        }
    }

    let stu = new Students("学生", 18, 176);
    console.log(stu.getHeight())
    
    /**
     * 现在属性值是在对象中设置的，属性值可以任意的的被修改
     * 属性值可以任意被修改将会导致对象中的数据非常不安全
     */
    let per = new Person("LBipanda", 18, 178)
    console.log(per);
    per.getAge();
    per.setAge(22);

    console.log(per.name);
    console.log(per.name = "wudi");
})();