js 抽象工厂模式A

var Interface = function(name, methods) {
	if (arguments.length != 2) {
		throw new Error("Interface constructor called with " + arguments.length
				+ "arguments, but expected exactly 2.");
	}

	this.name = name;
	this.methods = [];
	for (var i = 0, len = methods.length; i < len; i++) {
		if (typeof methods[i] !== 'string') {
			throw new Error("Interface constructor expects method names to be "
					+ "passed in as a string.");
		}
		this.methods.push(methods[i]);
	}
};
Interface.ensureImplements = function(object) {
	if (arguments.length < 2) {
		throw new Error("Function Interface.ensureImplements called with "
				+ arguments.length + "arguments, but expected at least 2.");
	}

	for (var i = 1, len = arguments.length; i < len; i++) {
		var v_interface = arguments[i];
		if (v_interface.constructor !== Interface) {
			throw new Error("Function Interface.ensureImplements expects arguments "
					+ "two and above to be instances of Interface.");
		}

		for (var j = 0, methodsLen = v_interface.methods.length; j < methodsLen; j++) {
			var method = v_interface.methods[j];
			if (!object[method] || typeof object[method] !== 'function') {
				throw new Error("Function Interface.ensureImplements: object "
						+ "does not implement the " + v_interface.name
						+ " interface. Method " + method + " was not found.");
			}
		}
	}
};

function extend(subClass, superClass) {
	var F = function() {
	};
	F.prototype = superClass.prototype;
	subClass.prototype = new F();
	subClass.prototype.constructor = subClass;

	subClass.superclass = superClass.prototype;
	if (superClass.prototype.constructor == Object.prototype.constructor) {
		superClass.prototype.constructor = superClass;
	}
}

var AbstractFactory = function() {
};
AbstractFactory.prototype = {
	chooesFactory : function(mode) {
		var factory = null;
		switch (mode) {
			case 'giant' :
				factory = new GiantFactory();
				break;
			case 'cnforever' :
				factory = new CnforeverFactory();
				break;
			case 'merida' :
				factory = new MeridaFactory();
				break;
			default :
				throw new Error("mode not found");
		}
		return factory;
	},
	createBicycle : function() {
		throw new Error('Unsupported operation on an abstract class:createBicycle');
	}
};
var GiantFactory = function() {
};
extend(GiantFactory, AbstractFactory);
GiantFactory.prototype = {
	createBicycle : function() {
		var giantBicycle = new GiantBicycle();
		Interface.ensureImplements(giantBicycle, Bicycle);
		return giantBicycle;
	}
};
var Bicycle = new Interface("Bicycle", ['assemble', 'wash', 'ride', 'repair']);
var GiantBicycle = function() {

};
GiantBicycle.prototype = {
	assemble : function() {
		alert('清洗');
	},
	wash : function() {
		alert('组装');
	},
	ride : function() {

	},
	repair : function() {

	}
};

var BicycleShop = function() {
};
BicycleShop.prototype = {
	sellBicycle : function(mode) {
		var abstractFactory = new AbstractFactory();
		var factory = abstractFactory.chooesFactory(mode);
		var bicycle = factory.createBicycle();
		bicycle.assemble();
		bicycle.wash();;
		return bicycle;
	}
}

var bicycleShop = new BicycleShop();
bicycleShop.sellBicycle('giant');