JavaScript高级进阶之设计模式 抽象工厂模式

抽象工厂模式

负责同一类的产品，但是不对负责某一个产品的实例，实例的任务交给创建某个产品的方法

/**
 * @param {Object} fun 需要抽象的方法体 函数
 * @param {Object} funName 抽象方法的函数名称
 */
let vehicleFactory = function(fun,funName){
		// console.log(fun,funName);
		// console.log(vehicleFactory[funName]);
		// vehicleFactory.xxx = function（）{}
		
	if(typeof vehicleFactory[funName] === 'function'){
		
		//缓存类 这里可以理解为子类
		function f(){}
		//继承父类的属性和方法
		
		// 缓存类（prototype）原型指向传入进来的函数 这里因为传入进来的是一个构造函数需要实例化
		// 构造函数的理解： 构造函数为 需要实例化的，prototype原型有方法 如果不实例化就不能使用 原型上面的属性方法
		f.prototype = new vehicleFactory[funName]();
		// 传入进来的子类 的工造函数指向 传入进来的子类，防止this像问题，导致函数出现BUG
		fun.constructor = fun;
		//
		console.log(fun.prototype,new f());
		// 把传入进来的构造函数 的 prototype 原型指向缓存类（上面缓存类的原型已经实例化了为传入进来的构造函数）
		fun.prototype = new f();
	}else{
		throw new Error('没有创建抽像类')
	}
	
}

// 直接通过方法名称 点 方法名  这个叫静态方法 不需要实例化就开以调用，所以在抽象工厂里面是通过 vehicleFactory[funName] 来判断是不是一个 function 如果不是直接就抛出异常了
vehicleFactory.Car = function(){
	this.tyep = 'Car'
}
vehicleFactory.Car.prototype = {
	get(){
		return new Error('抽象方法 Car 不能使用')
	},
	set(){
		return new Error('抽象方法 Car 不能使用')
	}
} 

vehicleFactory.Bus = function(){
	this.tyep = 'Bus'
}
vehicleFactory.Bus.prototype = {
	get(){
		return new Error('抽象方法 Bus 不能使用')
	},
	set(){
		return new Error('抽象方法 Bus 不能使用')
	}
} 


var BMW = function(price,speed){
	this.price = price;
	this.speed = speed
}

vehicleFactory(BMW,'Car')
 
 // BMW 的原型子类方法只能写到抽象工厂模式调用之后，如果写到 调用 vehicleFactory 抽象工厂模式之前会抛出抽象前面定义的原型抛出的异常，因为我们要重新抽象工厂的子方法 如果写到前面就直接触发到了抛出的异常
 BMW.prototype.get = function(){
	 return this.price
 }
 BMW.prototype.set = function(){
 	 return this.speed
 }
 
  
 
let vehicle =  new BMW('宝马',1000)

console.log(vehicle.get()); // 宝马
console.log(vehicle.set()); // 1000