// class中由多个赋值表达式组成，如果赋值的是函数类型，则该函数的this指向实例对象，super指向父类
// constructor是一个预留的函数名，为构造方法，该方法必须以`super()`开头，调用父类的构造方法
class Person {
    age = 10;
    constructor = function(name, age) {
        super();
        this.name = name;
        this.age = age;
    }
    say = function() {
        print(this.name+ " is "+ this.age + " years old.");
    }
}

new Person("John", 20).say();
Copy

class A {
    int age = 1;
    public void printAge() {
        System.out.println(this.age);
    }
}

class B extends A {
    int age = 2;
    public void printAge() {
        super.printAge();
        System.out.println(this.age);
    }
}

new B().printAge();
Copy

<dependency>
    <groupId>org.apache.lucene</groupId>
    <artifactId>lucene-core</artifactId>
    <version>6.6.1</version>
</dependency>
Copy

var MyNumber = function(value) {
    this.valueOf = function() { return value};
}
MyNumber.prototype = Number.prototype;
const num = new MyNumber(100);

console.log(num instanceof MyNumber);  // true instanceof原理就是判断原型链上有没有MyNumber.prototype
console.log(num instanceof Number);    // true
console.log(num + 100); // 200
Copy

var MyNumber = function(value) {
    this.valueOf = function() { return value};
}
MyNumber.prototype = Object.create(Number.prototype); // 创建一个新对象，新对象原型指向Number.prototype
MyNumber.prototype.constructor = MyNumber;
const num = new MyNumber(100);
Copy

// es5写法
var MyNumber1 = function(value) {
    this.valueOf = function() { return value}; 
}
MyNumber1.prototype = Object.create(Number.prototype); // 创建一个新对象，新对象原型指向Number.prototype
MyNumber1.prototype.constructor = MyNumber;

// es6写法
class MyNumber2 extends Number {
}
Copy

export class Element {
    constructor(type) {
        this.type = type;
        // 普通对象的属性存到map
        this.map = new Map();
        // 类的属性存到pro
        this.$$pro$$ = new Map();
        this.$$pro$$.set("$$pro$$", new Map());
    }
    setPro(key, value) {
        this.$$pro$$.set(key, value);
    }
    set(key, value) {
        this.map.set(key, value);
    }
    get(key) {
        if (key == "type") return new StringElement(this.type);
        // 先从map中找
        if (this.map.get(key) != undefined) {
            return this.map.get(key);
        }
        // 再从原型中找
        if (this.$$pro$$.get(key) != undefined) {
            return this.$$pro$$.get(key);
        }
        // 原型链向上搜索
        var pro = this.$$pro$$.get("$$pro$$")
        while (pro != undefined) {
            if (pro.get(key) != undefined) {
                return pro.get(key);
            }
            pro = pro.get("$$pro$$");
        }
        // 最后还没找到返回nil
        return nil;
    }
    toString() {
        return `{ ${Array.from(this.map.entries()).map(it=>it[0]+":"+it[1].toString()).join(',')} }`;
    }
    toNative() {
        function elementToJsObject(element) {
            if (element instanceof Element) {
                switch(element.type) {
                    case "number":
                    case "boolean":
                    case "null":
                    case "string":
                    case "array":
                        return element.toNative();
                    default:
                        var iter = element.map.keys();
                        var res = {};
                        var item;
                        while (!(item = iter.next()).done) {
                            var key = item.value;
                            res[key] = elementToJsObject(element.map.get(key))
                        }
                        return res;
                }
            }
            return element;
        }
        return elementToJsObject(this);
    }
}
Copy

export class ProtoElement extends Element {
    // className: string;
    // parent: ProtoElement | null;
    // methods: Map<String, FunctionElement>;
    constructor(className, parent, methods) {
        super();
        this.className = className;
        // 如果有父类，则作为原型链存储
        if (parent != undefined) {
            this.setPro("$$pro$$", parent.$$pro$$);
        }
        if (methods) {
            methods.forEach((v, k) => {
                this.setPro(k, v ? v : nil);
            })
        }
    }
    toString() {
        return "PROTOTYPE"
    }
}
Copy

function evalStatement(statement, ctx) {
    //..........
    else if (statement instanceof ClassStatement) {
        var parent =  null;
        if (statement.parentIdentifierAstNode) {
            parent = ctx.get(statement.parentIdentifierAstNode.toString());
            if (!(parent instanceof ProtoElement)) {
                throw new RuntimeError("parent class " + 
                    statement.parentIdentifierAstNode.toString() + " must be a class")
            }
        }
        var className = statement.nameIdentifierAstNode.toString();
        // 在语法分析中，我们已经把类中的字段赋值的语法糖写法，转为了在constructor中赋值，所以类中只有方法。
        ctx.set(className, new ProtoElement(className, parent, statement.methods, ctx))
    } 
    //...........
}
Copy

function evalExpression(exp, ctx) {
    // .........
    if (exp instanceof NewAstNode) {
        var className = exp.clsIdentifierAstNode.toString();
        var args = exp.args.map((arg) => evalExpression(arg, ctx));
        var clsElement = ctx.get(className);
        if (!(clsElement instanceof ProtoElement)) throw new RuntimeError(`${className} is not a class`);
        // 1 创建空对象
        var _this = new Element(className);
        // 2 当前对象原型 指向 类的原型
        var curClsPro = _this.$$pro$$ = clsElement.$$pro$$;
        var parentClsPro = curClsPro.get("$$pro$$"); 
        // 3 this指向空对象，super指向一个只有父类方法（原型）的对象，这样super.只能调用父类方法
        var _super = new Element();
        _super.$$pro$$ = parentClsPro ? parentClsPro : new Map();


        // 4 运行构造方法，原型链一直往上找constructor构造方法，如果全都没有的话，就不执行任何操作
        if (clsElement.get("constructor") && clsElement.get("constructor") != nil) {
            if (!(clsElement.get("constructor") instanceof FunctionElement)) throw new RuntimeError(`${className}.constructor is not a function`); 
            // 运行构造方法，这里用到了call方法的第三第四个参数分别为this和super的指向
            clsElement.get("constructor").call("constructor", args, _this, _super, exp);
        }
        return _this;
    }
    // .........
}
Copy

// FunctionElement没有改动，只是回看一下_this和_super的处理。
export class FunctionElement extends Element {
    constructor(params, body, closureCtx) {
        super('function');
        this.params = params;
        this.body = body;
        this.closureCtx = closureCtx;
    }

    toString() {
        return `FUNCTION`
    }

    // name: string, args: Element[], _this: Element, _super: Element, exp: 打印异常堆栈相关
    call(name, args, _this, _super, exp) {
        var newCtx = new Context(this.closureCtx);
        if (_this) {
            newCtx.set("this", _this);
        }
        if (_super) {
            newCtx.set("super", _super);
        }
        newCtx.funCtx.name = name;
        this.params.forEach((param, index) => {
            newCtx.set(param, args[index] ? args[index] : nil);
        });
        try {
            evalBlockStatement(this.body, newCtx);
        } catch (e) {
            if (e instanceof RuntimeError) {
                if (e.element instanceof ErrorElement) {
                    e.element.updateFunctionName(name);
                    e.element.pushStack({position: `${exp.token.line}:${exp.token.pos}`})
                }
            }
            throw e;
        }
        return newCtx.funCtx.returnElement =  newCtx.funCtx.returnElement ?  newCtx.funCtx.returnElement : nil;
    }
}
Copy

    // 函数调用
    else if (exp instanceof FunctionCallAstNode) {
        var funcExpression = exp.funcExpression;
        // 去掉冗余的组
        while (funcExpression instanceof GroupAstNode) {
            funcExpression = funcExpression.exp;
        }
        var fname = null, _this = nil, _super = nil, funcElement = nil;
        // 全局方法
        if (funcExpression instanceof IdentifierAstNode) {
            fname = funcExpression.toString();
            // 注入一个print函数，来辅助调试
            if (fname == 'print') {
                console.log(...(exp.args.map((arg) => evalExpression(arg, ctx).toNative())));
                return nil;
            }
            if (fname == 'error') {
                if (exp.args.length == 0) {
                    throw new RuntimeError("error() takes at least 1 argument",`${exp.token.line}:${exp.token.pos}`);
                }
                var msg = evalExpression(exp.args[0], ctx);
                if (!(msg instanceof StringElement)) {
                    throw new RuntimeError("msg should be a String",`${exp.token.line}:${exp.token.pos}`);
                }
                return new ErrorElement(msg.toNative());
            }
            funcElement = evalExpression(funcExpression, ctx);
        } 
        // 对象方法
        else if (funcExpression instanceof InfixOperatorAstNode) {
            // xx.method() => 先对xx求值，结果赋值给_this；然后找到method这个functionElement
            if ((funcExpression.op.type === LEX.POINT && funcExpression.right instanceof IdentifierAstNode) ||
            (funcExpression.op.type === LEX.LBRACKET && funcExpression.right instanceof StringAstNode)) {
                _this = evalExpression(funcExpression.left, ctx)
                funcElement = _this.get(funcExpression.right.toString());
                fname = funcExpression.right.toString();
                var curClsPro = _this.$$pro$$;
                var parentClsPro = curClsPro ? curClsPro.get("$$pro$$") : null;
                _super = new Element(); // 临时的
                _super.$$pro$$ = parentClsPro ? parentClsPro : new Map();
                // super比较特殊，调用super.xx的时候，父类方法中的this指向自身，而是指向当前的对象
                if (funcExpression.left.toString() === 'super') {
                    _this = ctx.get("this");
                }
            } else {
                throw new RuntimeError("Method format invalid");
            }
        }
        // 其他形式，例如 "b()()",函数的返回值也是个函数，直接去调用
        else {
            funcElement = evalExpression(funcExpression, ctx);
        }
        if (funcElement instanceof FunctionElement) {
            return funcElement.call(fname, exp.args.map((arg) => evalExpression(arg, ctx)), _this, _super, exp);
        } else if (funcExpression.right && funcExpression.right.toString() == "constructor") {
            // 默认构造方法，啥也不做
            return nil;
        } else {
            throw new RuntimeError(`${funcExpression.toString()} is not a function`,`${exp.token.line}:${exp.token.pos}`);
        }
    }
Copy