// in my/Person.js
define(['dojo/_base/lang', 'dojo/_base/declare'], function(lang, declare){
  return declare(null, {
    constructor: function(name, age, residence){
      this.name = name;
      this.age = age;
      this.residence = residence;
    }
  });
});

// elsewhere
require(['my/Person'], function(Person){
  var folk = new Person("phiggins", 42, "Tennessee");
});

// in my/Person.js
define(['dojo/_base/lang', 'dojo/_base/declare'], function(lang, declare){
  return declare(null, {
    name: "Anonymous",
    age: null,
    residence: "Universe A",

    constructor: function(/*Object*/ kwArgs){
      lang.mixin(this, kwArgs);
    },

    moveTo: function(/*string*/ residence){
      this.residence = residence;
    }
  });
});

// elsewhere
require(['my/Person'], function(Person){
  var anon  = new Person(),
      alice = new Person({ name: "Alice", age: 42, residence: "Universe 1" });

  console.log(anon.name, alice.name); // "Anonymous", "Alice"
  console.log(anon.residence, alice.residence); // "Universe A", "Universe 1"
  alice.moveTo("Universe 420");
  console.log(alice.residence); // "Universe 420"
});

// in my/Demo.js
define(['dojo/_base/declare', 'my/Foo'], function(declare, Foo){
  return declare(null, {
    arr: [ 1, 2, 3, 4 ], // object. shared by all instances!
    num: 5,              // non-object. not shared.
    str: "string",       // non-object. not shared.
    obj: new Foo(),      // object. shared by all instances!

    constructor: function(){
      this.arr = [ 1, 2, 3, 4 ]; // per-instance object.
      this.obj = new Foo();      // per-instance object.
    }
  });
});

define(['dojo/_base/declare'], function(declare){
  var Demo = declare("my.Demo", null, {
    constructor: function(){
      console.debug("this is Demo object #" + Demo.counter++);
    }
  });

  Demo.counter = 0;

  return Demo;
});

// in my/Employee.js
define(['dojo/_base/declare', 'my/Person'], function(declare, Person){
  return declare(Person, {
    constructor: function(name, age, residence, salary){
      // The "constructor" method is special: the parent class (Person)
      // constructor is called automatically before this one.

      this.salary = salary;
    },

    askForRaise: function(){
      return this.salary * 0.02;
    }
  });
});

// in my/Boss.js
define(['dojo/_base/declare', 'my/Employee'], function(declare, Employee){
  return declare(Employee, {
    askForRaise: function(){
      return this.salary * 0.25;
    }
  });
});

// elsewhere
require(['my/Employee', 'my/Boss'], function(Employee, Boss){
  var kathryn = new Boss("Kathryn", 26, "Minnesota", 9000),
      matt    = new Employee("Matt", 33, "California", 1000);

  console.log(kathryn.askForRaise(), matt.askForRaise()); // 2250, 20
});

// in my/Boss.js
define(['dojo/_base/declare', 'my/Employee'], function(declare, Employee){
  return declare(Employee, {
    // override the askForRaise function from the Employee class
    askForRaise: function(){
      return this.inherited(arguments) * 20; // boss multiplier!
    }
  });
});

// elsewhere
require(['my/Employee', 'my/Boss'], function(Employee, Boss){
  var kathryn = new Boss("Kathryn", 26, "Minnesota", 9000),
      matt    = new Employee("Matt", 33, "California", 1000);

  console.log(kathryn.askForRaise(), matt.askForRaise()); // 3600, 20
});

this.inherited(arguments, [ customArg1, customArg2 ]);

// in my/ingredients.js
define(['dojo/_base/declare'], function(declare){
  return {
    VanillaSoftServe: declare(null, {
      constructor: function(){
        console.debug ("adding soft serve");
      }
    }),

    OreoMixin: declare(null, {
      constructor: function(){
        console.debug("mixing in oreos");
      },
      kind: "plain"
    }),

    CookieDoughMixin: declare(null, {
      constructor: function(){
        console.debug("mixing in cookie dough");
      },
      chunkSize: "medium"
    });
  };
});

// in my/Blizzard.js
define(['dojo/_base/declare', 'my/ingredients'], function(declare, ingredients){
  return declare([ ingredients.VanillaSoftServe, ingredients.OreoMixin, ingredients.CookieDoughMixin ], {
    constructor: function(){
      console.debug("A blizzard with " +
        this.kind + " oreos and " +
        this.chunkSize + "-sized chunks of cookie dough."
      );
    }
  });
});

// elsewhere
require(['my/Blizzard'], function(Blizzard){
  // This will print to console:
  // "adding soft serve",
  // "mixing in oreos",
  // "mixing in cookie dough",
  // "A blizzard with plain oreos and medium-sized chunks of cookie dough."
  var yummyTreat = new Blizzard();
});

require(['dojo/_base/declare'], function(declare){
  var A = declare(null);
  var B = declare(null);
  var C = declare([A, B]);
  var D = declare([B, A]);
  var E = declare([C, D]);
});

require(['dojo/_base/declare'], function(declare){
  // the first batch
  var A = declare(null);
  var B = declare(A);
  var C = declare(B);

  // the second batch
  var D = declare(null);
  var E = declare([D, B]);

  // the quirky case
  var F = declare([C, E]);
});

C -> B -> A
E -> B -> D

F -> C -> B -> D -> A

require(['dojo/_base/declare', 'dojo/dom-construct'], function(declare, domConstruct){
  var A = declare(null, {
    "-chains-": {
      init:    "after",
      destroy: "before"
    },
    init: function(token){
      this.initialized = true;
      this.token = token;
      this.node = dojo.create("div", null, dojo.body());
      console.log("A.init");
    },
    destroy: function(){
      domConstruct.destroy(this.node);
      this.node = null;
      console.log("A.destroy");
    }
  });
  var B = declare(A, {
    init: function(token){
      console.log("B.init");
      // more code
    },
    destroy: function(){
      console.log("B.destroy");
      // more code
    }
  });

  var x = new B();
  x.init(42);
  x.destroy();
});

// prints:
// A.init
// B.init
// B.destroy
// A.destroy

require(['dojo/_base/lang', 'dojo/_base/declare'], function(lang, declare){
  // plain vanilla constructor
  var A = function(){
    this.a = 42;
  };
  A.prototype.m1 = function(){
    // ...
  };

  // another plain vanilla constructor
  var B = function(){
    this.b = "abc";
  };
  lang.extend(B, {
    m2: function(){
      // ...
    }
  });

  var C = declare([A, B], {
    m1: function(){
      return this.inherited(arguments);
    },
    m2: function(){
      return this.inherited(arguments);
    }
  });

  var x = new C();
  // both A and B will be called at this point

  console.log(x.isInstanceOf(A)); // true
  console.log(x.isInstanceOf(B)); // true

  x.m1(); // A.m1 will be called via this.inherited()
  x.m2(); // B.m2 will be called via this.inherited()
});

dojo.declare( /* String: */ className,  /* Function|Function[]: */ superclass,  /* Object: */ props)

        // properties to be added to the class prototype
        someValue: 2,
        // initialization function
        constructor: function(){
                this.myComplicatedObject = new ReallyComplicatedObject();
        },
        // other functions
        someMethod: function(){
                doStuff();
        }
});

        // constructor, properties, and methods go here
        // ...
});
var MyClass1 = dojo.declare(MyBase, {
        // constructor, properties, and methods go here
        // ...
});
var MyClass2 = dojo.declare(MyBase, {
        // constructor, properties, and methods go here
        // ...
});
var MyDiamond = dojo.declare([MyClass1, MyClass2], {
        // constructor, properties, and methods go here
        // ...
});

F.prototype.method = function(){
        console.log("raw method");
};
var A = dojo.declare(F, {
        constructor: function(){
                console.log("A.constructor");
        },
        method: function(){
                console.log("before calling F.method...");
                this.inherited(arguments);
                console.log("...back in A");
        }
});
new A().method();
// will print:
// raw constructor
// A.constructor
// before calling F.method...
// raw method
// ...back in A

        "-chains-": {
                destroy: "before"
        }
});
var B = dojo.declare(A, {
        constructor: function(){
                console.log("B.constructor");
        },
        destroy: function(){
                console.log("B.destroy");
        }
});
var C = dojo.declare(B, {
        constructor: function(){
                console.log("C.constructor");
        },
        destroy: function(){
                console.log("C.destroy");
        }
});
new C().destroy();
// prints:
// B.constructor
// C.constructor
// C.destroy
// B.destroy

        "-chains-": {
                constructor: "manual"
        }
});
var B = dojo.declare(A, {
        constructor: function(){
                // ...
                // call the base constructor with new parameters
                this.inherited(arguments, [1, 2, 3]);
                // ...
        }
});

        "-chains-": {
                m1: "before"
        },
        m1: function(){
                console.log("A.m1");
        },
        m2: function(){
                console.log("A.m2");
        }
});
var B = dojo.declare(A, {
        "-chains-": {
                m2: "after"
        },
        m1: function(){
                console.log("B.m1");
        },
        m2: function(){
                console.log("B.m2");
        }
});
var x = new B();
x.m1();
// prints:
// B.m1
// A.m1
x.m2();
// prints:
// A.m2
// B.m2