Typescript中类的使用

/*
* 基类
* */
class Base{
    constructor(obj=null) {
        if (obj){
            console.log('子类调用,基类构造函数',obj.a,obj.b);
        }else{
            console.log('基类构造函数');
        }

    }
    toString(obj){
        let [a,b]=[obj.a,obj.b];
        console.log('子类调用:toString()===>',a,b);
    }
}

/*
* 派生类,继承于Base
* */
class Framework extends Base{
    constructor({a=0,b=0}={}) {
        super({a,b});//向基类传入参数
        super.toString({a,b});//调用基类函数
    }
    //公有方法实现,默认下类的所有方法都是公有的
    getParentName(){

    }

    //类的私有方法实现
    _getParentName(){

    }
}

let base = new Base();//实例化基类
let framework = new Framework({a:8,b:9});//实例化派生类
//类实例是对象,类是函数
console.log('类对象的数据类型:',typeof base,typeof framework,'类的数据类型',typeof Base,typeof Framework);
console.log('类原型对象构造:',Framework.prototype.constructor,'类构造:',Framework.constructor);
console.log('类的原型对象prototype的constructor指向类名:',Framework.prototype.constructor===Framework);//类的原型对象prototype的constructor指向类名
console.log('类名:',Framework.name);
console.log(framework.constructor===Framework.prototype.constructor);

//通过类原型对象向类添加方法
Base.prototype.Add = function (x,y) {
    return x+y;
}
console.log('调用添加到基类原型对象上的方法:',base.Add(1,2));//调用添加到基类原型对象上的方法
console.log('派生类调用基类原型对象的方法:',framework.Add(5,6));//派生类调用基类原型对象的方法

// @ts-ignore
Base.prototype.test =()=> {
  console.log('test func');
};

console.log(Object.getOwnPropertyNames(Base.prototype));//取类所有方法名

//使用Object.assign为类添加方法
Object.assign(Base.prototype, {
    M1() {
        console.log('M1');
    },
    M2() {
        console.log('M2');
    },
    M3() {
        console.log('M3');
    }
});
//调用添加的方法
base.M1();
framework.M2();
framework.M3();

//注: 类内部定义的所有方法都是不可枚举的
console.log(Object.keys(Base.prototype));//constructor,toString这两个方法都在类内部定义,所以Object.keys无法枚举

//使用变量名定义类方法
let method = 'Done';
Object.assign( Base.prototype,{[method](){
    console.log('通过变量名定义的函数');
}});

console.log(Object.keys(Base.prototype));
base.Done();//通过方法名调用
Reflect.get(base,method)();//使用反射通过变量名调用
framework.Done();
console.log(Object.getOwnPropertyNames(Framework.prototype));
console.log('取当前类的继承对象',Object.getPrototypeOf(framework));
console.log('取当前类的继承对象的所有方法',Object.getPrototypeOf( Object.getPrototypeOf(framework)));
//根据子类取得基类,并调用基类方法
let p = Object.getPrototypeOf( Object.getPrototypeOf(framework))
p.Done();
console.log(Object.getOwnPropertyNames(p));
console.log(Reflect.ownKeys(p));
Reflect.get(p,method)();

console.log('base对象原型',base.__proto__,'framework对象原型:',framework.__proto__);


//通过表达式形式声明类
const ExpClass = class Exp {//此处Exp为类的别名,作用域只限于类内部定义
    constructor() {
        console.log('构造时打印类名:',Exp.name);
    }
    getClassName(){
        console.log('调用getClassName打印类名:');
        return Exp.name;
    }
}

let exp = new ExpClass();
console.log(exp.getClassName());

//立即执行类
let execClass = new class{
    constructor() {
        console.log('立即执行类');
    }
}();
//带参数的立即执行类
let execClassWithParam = new class{
    constructor(param) {
        console.log('立即执行类,参数:',param);
    }
}('RemoteDev');
//注: 类不存在变量提升,必须先声明后再实例化