在 dojo 中使用它通过父类访问子方法

Access child methods via parent class using this in dojo

本文关键字：父类 访问 子方法 dojo      更新时间：2023-09-26

给定类 A 和类 B，其中类 B 继承自类 A ...

// Define class A
dojo.declare("mynamespace.A",null,{
    myMethodA: function() { this.myMethodB() }
});
// Define class B
dojo.declare("mynamespace.B",mynamespace.A,{
    myMethodB: function() {}
});

在类 A(父类(的范围内调用 this.myMethodB(( 是否合法？我在软件中看到了这一点，但我不明白。我知道在 Java 中，除非您将 A 键入到 B，否则这是不可能的。但道场有什么不同吗？

你对这个问题的流行语是这个.inherited(参数(;你的问题是调用一个不在当前继承范围内的方法 - 并且会被真正的面向对象的程序员称为无效。但是(仍然(这是可能的，因为加载器在全局范围内声明了所有内容，例如，您可以通过mynamespace访问任何模块。X，然后添加原型。

一旦你像在 mynamespace 中一样拥有继承权。B A 和 B 的所有功能都是"这个"范围的。它就像一个合并的东西哈希，比如说for all methods and variables in A do set instance B[key] = property A[key].

但是，如果您遇到覆盖，其中属性同时为"类"A 和 B 进行原型化 - 声明/构造链中有一种机制允许调用"super"(或父类，遵循您的符号(。

对于特殊属性构造函数，继承冒泡[句点]就是这样。

对于任何只声明一次的方法，如果它不是继承的方法，你就不能调用它 - 然后可以通过"this"访问它

对于任何具有覆盖的方法，函数"this.inherited(arguments(;"将向上发送一个勾号到被调用方的当前父类。看看这里的扩展小提琴

var AClass = dojo.declare("mynamespace.A", null, {
    constructor: function(args) {
        this.overriddenMethod();
    },
    overriddenMethod: function() {
    }
});
var BClass = dojo.declare("mynamespace.B", [AClass], {
    constructor: function() {  },
    overriddenMethod: function() {
        // call super before anything else is processed in this method
        // by placing following call you can control function callflow
        this.inherited(arguments);
    }
});
// will call A.constructor, then A.overriddenMethod
new AClass();
// will call B.constructor, A.constructor, B.overriddenMethod and then
//  A.overriddenMethod via the call to super
//  in B.overriddenMethod which A.constructor 
//  calls (note that A.constructor callflow 'aims' B.override not A.override)
new BClass();

JavaScript 中没有静态编译，因此，正如@akonsu已经提到的，它在技术上是可行的，但这不是一个可以遵循的模式：

var a = new mynamespace.A();
a.myMethodA(); // ilegal: Uncaught TypeError: Object [object Object] has no method 'methodB' 
var b = new mynamespace.B();
b.myMethodA() // legal

你也可以在 JavaScript 的给定范围内执行方法/函数，即作为给定对象的方法：

a.myMethodA.call(b); // legal as `this` inside `myMethodA` will be referencing to object `b`

实际上，我认为mynamespace.A可以使用抽象方法模拟抽象类myMethodB就像您从 Java 中知道的那样。类mynamespace.A 当子类化时，子类应实现myMethodB。但是这样做非常容易出错，我会以更强大的方式做到这一点：

// Define class A
dojo.declare("mynamespaca.A", null, {
    myMethodA: function() {
        this.myMethodB();
    },
    myMethodB: function() {
        // abstract method
        console.warn("Abstract method [myMethodB] was not implemented.");
        // or: throw new Error("Abstract method [myMethodB] was not implemented.");
    }   
});

// Define class B
dojo.declare("mynamespace.B", mynamespace.A, {
    myMethodB: function() {
        // implement abstract method here
    }
});

您可以使用原型对象调用任何方法。

myMethodA: function() { mynamespace.B.prototype.myMethodB(); }

这是一个工作示例：

http://jsfiddle.net/cswing/7cBJm/

相关文章：