【Java设计模式详解】工厂模式

前言：

什么是设计模式？

设计模式：是前人他们的代码设计经验的总结，一套代码被反复使用

它与框架、架构有啥区别？

设计模式是设计重用，框架是代码重用。而架构则介于两者之间。
简而言之：框架是大智慧，对软件设计进行分工，设计模式是小技巧，对具体问题提出解决方案。提高代码复用率，降低耦合度。

什么是工厂模式？

工厂模式是用来创建对象的一种最常用的设计模式。我们不暴露创建对象的具体逻辑，而是将逻辑封装在一个函数中，那么这个函数就可以被视为一个工厂。

它又分为：

• 简单工厂
• 工厂方法
• 抽象工厂

光说不实践没啥用，下面我结合示例来讲解工厂到底是干啥用的
简单工厂：
新建个宝马卡车类：

public class BnwTrunck  implements Trunck(){
   void run(){
   	System.out.println("宝马卡车启动")
   }
}

新建个宝奥迪卡车类：

public class AodiTrunck implements Trunck(){
   void run(){
   	System.out.println("奥迪卡车启动")
   }
}

新建个客户端：

public class Customer(){
   public static void main(String[] args) {
   	
   }
}

新建个抽象（卡车）类：

public Interface Trunck(){
	void run();
}

新建个卡车工厂：

public class TrunckFactory(){
	static Trunck produceTrunck(String message){
		if(message.equals("宝马")){
			return new BnwTrunck();
		} else if(message.equals("奥迪")){
			return new AodiTrunck ();
		} else {
			 throw new RunntimeExecption("抱歉本厂商没有该卡车，可能在火星上")
		}
	}
}

新建个测试类：

public class CustomerTest {
	public static void main(String[] args) {
		TrunckFactory.produceTrunck("宝马").run();
		TrunckFactory.produceTrunck("奥迪").run();
	}
}

这样就实现了一个工厂，
它的优点：开闭原则分析工厂模式
缺点：违反了开闭原则，扩展性差

工厂方法：由于时间问题，略过。。。

抽象工厂：
新建个手机类：

public interface Phone {
	void openPhone();
}

新建个显示器类：

public interface Monitor {
	void openMonitor();
}

新建个华为手机类：

public class HuaWeiPhone implements Phone {

	@Override
	public void openPhone() {
		System.err.println("华为手机启动");
	}

}

新建个Vivo手机类：

public class VivoPhone implements Phone {

	@Override
	public void openPhone() {
		System.err.println("Vivo手机启动");
	}

}

新建个华为显示器类：

public class HuaWeiMonitor implements Monitor {

	@Override
	public void openMonitor() {
		System.err.println("华为显示器启动");
	}

}

新建个Vivo显示器类：

public class VivoMonitor implements Monitor {

	@Override
	public void openMonitor() {
		System.err.println("Vivo显示器启动");
	}

}

新建个华为工厂类：

/**
 * 
 * ProjectName: AaronTest
 * ClassName: HuaWeiFactory 
 * @Description: 具体工厂继承抽象工厂（华为）
 * @author Aaron
 * @date 2019年7月11日
 */
public class HuaWeiFactory implements InternetProduceFactory {

	@Override
	public Phone producePhone() {
		return new HuaWeiPhone();
	}

	@Override
	public Monitor produceMonitor() {
		return new HuaweiMonitor();
	}

}

新建个Vivo工厂类：

/**
 * 
 * ProjectName: AaronTest
 * ClassName: HuaWeiFactory 
 * @Description: 具体工厂继承抽象工厂（华为）
 * @author Aaron
 * @date 2019年7月11日
 */
public class VivoFactory implements InternetProduceFactory {

	@Override
	public Phone producePhone() {
		return new VivoPhone();
	}

	@Override
	public Monitor produceMonitor() {
		return new VivoMonitor();
	}

}

新建抽象工厂类：

/**
 * 
 * ProjectName: AaronTest
 * ClassName: InternetProduceFactory 
 * @Description: 抽象工厂
 * @author Aaron
 * @date 2019年7月11日
 */
public interface InternetProduceFactory {
	public Phone producePhone();
	Monitor produceMonitor();
}

新建个客户类：

public class CustomerTest {

	public static void main(String[] args) {
		InternetProduceFactory huaw = new HuaWeiFactory();
		huaw.producePhone().openPhone();
		huaw.produceMonitor().openMonitor();
	}

}

它的优点：符合开闭原则，符合单一职责
缺点：在增加新产品时需要新增一个产品类和具体的子工厂，给系统造成负担，产品太过单一。

由于时间问题，后续我会讲单例模式