[Live Example][1]

    (function _anonymouswrapper(undefined) {

        var Skillet = {
            constructor: function (options) {
                options && extend(this, options);
                return this; 
            },
            ingredient: "Bacon Strips",
            _isHot: true,
            fry: function fry(oliveOil) {
                this._addItem("\t\n Butter \n\t");
                this._addItem(oliveOil);
                this._addItem(this.ingredient);
                console.log("Frying " + this.ingredient);
            },
            _addItem: function addItem(item) {
                console.log("Adding " + item.toString().trim());
            }
        };
     
        var skillet = Object.create(Skillet).constructor();
            
        console.log(skillet.ingredient);
        skillet.fry("olive oil");
        
        var PrintableSkillet = extend(Object.create(Skillet), {
            constructor: function constructor(options) {
                options && extend(this, options);
                return this;
            },
            _amountOfGrease: "1 Cup",
            quantity: 12,
            toString: function toString() {
                console.log(this.quantity + " " +
                            this.ingredient + " & " +
                            this._amountOfGrease + " of Grease");
                console.log(this._isHot ? "Hot" : "Cold");
            }
        });
        
        var skillet = Object.create(PrintableSkillet).constructor();
            
        skillet.toString();
    
        function extend(target, source) {
            Object.getOwnPropertyNames(source).forEach(function (name) {
                var pd = Object.getOwnPropertyDescriptor(source, name);
                Object.defineProperty(target, name, pd);
            });
            return target;
        }
    }());

You can use a IIFE to emulate "module scope" around your code. Then you can just use objects as you normally do.

Don't "emulate" private state using closures as that has a large memory penalty.

If your writing an enterprise application and want to keep your memory usage under 1GB avoid closures like the plague.

  [1]: http://jsfiddle.net/Raynos/HFGg3/15/