var myInstance = new Twitter({
    username: "sitepen"
});

如上所述， 继承是被定义在declare函数中的第二个参数内，新的类会从左到右继承父类的属性和方法。 后面类的属性和方法具有最高的优先权。 看看以下的例子：

// Define class A
var A = declare(null,{
    // A few properties...
    propertyA: "Yes",propertyB: 2
});
 
// Define class B
var B = declare(A,{
    // A few properties...
    propertyA: "Maybe",propertyB: 1,propertyC: true
});
 
// Define class C
var C = declare([mynamespace.A,mynamespace.B],{
    // A few properties...
    propertyA: "No",propertyB: 99,propertyD: false
});

这个继承类的属性结果是：

// Create an instance
var instance = new C();
 
// instance.propertyA = "No" // overridden by B,then by C
// instance.propertyB = 99 // overridden by B,then by C
// instance.propertyC = true // kept from B
// instance.propertyD = false // created by C

这里需要理解原型继承非常重要。 当检索一个对象实例的属性时， 会首先检查实例自已的定义的属性。 如果没有， 会查找原型链， 如果原型链中的第一个对象有定义该属性，直接返回。 当一个值是赋值给一个对象实例时，它只在这个实例上有效，而不会是原型链。 这样的话，所有共享同一个原型的对象，会获得原型上相同的值。除非是对象实例上的值。 这使得在你的类声明中很容易给原始类型（number,string,boolean) 定义默认的值， 然后在实例对像中可以直接修改。 可是，如果你给原型上的属性分配的是一个对象（Object,Array)， 那么每一个实例会共享同一个值。

var MyClass = declare(null,{
    primitiveVal: 5,objectVal: [1,2,3]
});
 
var obj1 = new MyClass();
var obj2 = new MyClass();
 
// both return the same value from the prototype
obj1.primitiveVal === 5; // true
obj2.primitiveVal === 5; // true
 
// obj2 gets its own property (prototype remains unchanged)
obj2.primitiveVal = 10;
 
// obj1 still gets its value from the prototype
obj1.primitiveVal === 5; // true
obj2.primitiveVal === 10; // true
 
// both point to the array on the prototype,// neither instance has its own array at this point
obj1.objectVal === obj2.objectVal; // true
 
// obj2 manipulates the prototype's array
obj2.objectVal.push(4);
// obj2's manipulation is reflected in obj1 since the array
// is shared by all instances from the prototype
obj1.objectVal.length === 4; // true
obj1.objectVal[3] === 4; // true
 
// only assignment of the property itself (not manipulation of object
// properties) creates an instance-specific property
obj2.objectVal = [];
obj1.objectVal === obj2.objectVal; // false

为了避免非故意的修改共享的数组或者对象， 对象的属性应该声名为null 然后在构造函数中对它初始化。

declare(null,{
    // not strictly necessary,but good practice
    // for readability to declare all properties
    memberList: null,roomMap: null,constructor: function () {
        // initializing these properties with values in the constructor
        // ensures that they ready for use by other methods
        // (and are not null or undefined)
        this.memberList = [];
        this.roomMap = {};
    }
});

参考 dojo/_base/declare 文档获得更多信息

虽然完成重写一个方法确实有用， 但每一个类的的构造函数都应该执行它继承链中的父类构造函数，以保持它原始的功能。 这样this.inherited(arguments)语句就派上用场了。 this.inherited(arguments)语句调用父类的同名方法。 考虑下面的例子：

var A = declare(null,{
    myMethod: function(){
        console.log("Hello!");
    }
});
 
// Define class B
var B = declare(A,{
    myMethod: function(){
        // Call A's myMethod
        this.inherited(arguments); // arguments provided to A's myMethod
        console.log("World!");
    }
});
 
// Create an instance of B
var myB = new B();
myB.myMethod();
 
 
// Would output:
//      Hello!
//      World!

！* this.inherited 方法可在子类代码中的任何时间调用。 不管你是在子函数的中部，甚至是底部调用都是允许的（ Java中都是在最顶部通过 super调用）， 这就是说，你不应该在构造函数内调用它。

declare函数是创建一个模块的关键， 使得Dojo Toolkit可以重用类。 declare允许通过多重继承和其它的一些属性和方法来重新创建一个复杂的类。 更好的是， declare很容易使用， 避免开发者重复的写相同的代码。

关于更多 declare 和 创建类的细节， 查看以下资源：

• dojo/declare
• dojo/_base/lang::mixin
• Writing Your Own Widget