TS类型5

    1.类 (字段: 字段是类里面声明的变量，字段表示对象有关的数据; 构造函数: 类实例化时调用, 可以为类的对象分配内存; 方法: 方法为对象要执行的操作)
        class className {
            // 类作用域
        }
        
    class Car {
        engine: string;  // 字段
        
        // 构造函数
        constructor(engine: string) {
            this.engine = engine
        }
        // 方法
        disp():void {
            console.log('发动机: this.engine')
        }
        
    }
    
    // 创建实例化对象:
        1.//我们使用new关键字来实例化类的对象
        const objCar = new Car()
        2.// 类实例化时候会调用构造函数
        const objCar = new Car ('bob')
        
        3.类的字段属性和方法可以使用.号来访问
        objCar.engine       objCar.disp()
        
    // 类的继承: (子类除了不能继承父类的私有成员(方法和属性)和构造函数, 其他都可以继承，也是使用关键字extends)
    class parent {
        area: number
        constructor(a:number) {
            this.area =  a
        }
    }
    
    class Chilren extends parent {
        disp():void {
            console.log('圆的面积', this.area)
        }
    }
    
    const objClass = new Chidren(223)  objClass.disp() // 
    
    
    // 需要注意子类只能继承一个父类, ts不支持继承多个类, 但支持继承多重类
    class Root {
        str: string
    }
    
    class Child extends Root {}
    class Leaf extends Child {}  // 多重继承, 继承了Child和Root类
    const objClass = new Leaf() 
    objClass.str = 'hello'
    
    // 继承类的方法重写(类继承后，子类可以对父类的方法重新定义, 这个过程称为方法重写, 其中super关键字是对父类的直接引用, 该关键字可以引用父类的属性和方法)
    class PrintClass {
        doPrint():void {
            console.log('父类的doPrint方法')
        }
    }
    
    class StringPrint extends PrintClass {
        doPrint():void {
            super.doPrint()  // 调用父类的函数
            console.log('子类doprint方法)
        }
    }
    
    
    // static 关键字: static 关键字用于定义类的数据成员(属性和方法)为静态的，静态成语可以直接通过类名调用
    class StaticNum {
        static num: nubmer;
        static disp():void {
            console.log('num值为静态属性'+ 'disp为静态方法')
        }
    }
    StaticNum.num  = 12
    StaticNum.disp() // 调用静态方法
    
    
    
    // instanceof 运算符 (用于判断对象是否是指定的类型, 如果是返回true, 否则返回false)
    class Person {}
    const obj = new Person()
    const isPerson =  obj instanceof Person     // true
    
    // 访问控制修饰符(控制对于类，变量，方法，构造函数的访问)
    public(共有,可以在任何地方访问)
    protected(受保护, 可以被其自身以及子类访问)
    private(私有, 只能被其定义所在的类访问)
    
    class caspsulate {
        str1: string = 'hello'
        private str2: string = 'world'
    }
    
    const obj = new caspsulate()
    obj.str1 可以访问 obj.str2 //编译错误
    
    
    // 类和接口(类可以实现接口, 使用关键字implements, 并将interest字段作为类属性使用)
    interface Iloan {
        interest: number
    }
    class AgriLoan implements Iloan {
        interest: number
        rebate: number
        constructor(interest: number, rebate: number) {
            this.interest= interest
            this.rebate = rebate
        }
    }
    
  const obj = new AgriLoan(10, 1) console.log('fsdfsfsfs')