设计模式之工厂模式

工厂模式

• 特点：实现了创建者和调用者的分离

  • 面向对象设计的基本原则：

    • OCP（开闭原则 ，Open-Closed Principle）一个软件的实体应当对外扩展开放，对修改关闭

      增加新功能时，尽量增加新的类来实现，不要修改原有的类

    • DIP（依赖倒转原则，Dependence Inversion Principe） 要求面向接口编程，不要针对实现编程

      依赖关系从具体转到抽象，尽量调用接口而不去继承实体类

    • LOD（迪米特法则，Law of Demeter） 只与你直接的朋友通信，而避免和陌生人通信

      可以实现解耦

  • 核心本质：

    实例化对象，用工厂方法代替new操作；将选择实现类、创建对象统一管理和控制，从而将调用者跟我们的实现类解耦。

• 分类：

  • 简单(静态)工厂模式（常用）

    工厂类一般使用静态方法，通过接受不同的参数返回不同的对象实例。

    用来生产同一等级结构中的任意产品，对于增加新的产品需要修改已有代码。

    测试代码：

    实体类：

    package com.wzg.factory.simplefactory;
    
    public interface Car {
    	void run();
    }
    

    package com.wzg.factory.simplefactory;
    
    public class Audi implements Car{
    
    	@Override
    	public void run() {
    		System.out.println("这是奥迪车");
    	}
    }
    

    package com.wzg.factory.simplefactory;
    
    public class BMW implements Car{
    
    	@Override
    	public void run() {
    		System.out.println("这是宝马车");
    	}
    }
    

    （1）未使用简单工厂模式：

    UML结构图：

    

    package com.wzg.factory.simplefactory;
    /**
     * 没有简单工厂模式情况下
     * @author wang
     * 既要知道接口类，又要知道实现类。要进行new创建
     */
    public class Client1 { // 调用者
    	public static void main(String[] args) {
    		Car c1 = new Audi();
    		Car c2 = new BMW();
    		
    		c1.run();
    		c2.run();
    	}
    }
    

    （2）简单工厂模式：

    UML示意图：

    

    创建者类：

    package com.wzg.factory.simplefactory;
    /**
     * 
     * @author wang
     * 小问题：
     * 		增加新功能时要修改原来的代码，比如下面增加新的车辆，要继续增加else if 等，
     * 		这样就违反了开闭原则。
     */
    public class CarFactory { //创建者
    	
    	public static Car createCar(String type) {
    		if ("奥迪".equals(type)) {
    			return new Audi();
    		} else if ("宝马".equals(type)) {
    			return new BMW();
    		} else {
    			return null;
    		}
    	}
    	
    //	// 另一种实现方式
    //	public static Car createAudi() {
    //		return new Audi();
    //	}
    //	public static Car createBMW() {
    //		return new BMW();
    //	}
    }
    

    调用者类：

    package com.wzg.factory.simplefactory;
    /**
     * 应用简单工厂模式
     * @author wang
     * 整体关系变复杂了，但是对于调用者来书变简单了。
     */
    public class Client2 { // 调用者
    	public static void main(String[] args) {
    		Car c1 = new CarFactory().createCar("奥迪");
    		Car c2 = new CarFactory().createCar("宝马");
    		
    		c1.run();
    		c2.run();
    	}
    }
    

  • 工厂方法模式

    用来生产同一等级结构中的固定产品，支持增加任意产品。

    • 为避免简单工厂模式的缺点，不完全满足于OCP
    • 工厂方法模式和简单工厂模式的最大不同在于，简单工厂模式只有一个（对于一个项目或一个独立的模块）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

    UML示意图：

    

    测试代码：

    工厂类：

    package com.wzg.factory.factorymethod;
    
    public interface CarFactory {
    	Car createCar();
    }
    

    package com.wzg.factory.factorymethod;
    
    public class AudiFactory implements CarFactory{
    	
    	@Override
    	public Car createCar() {
    		return new Audi();
    	}
    }
    

    package com.wzg.factory.factorymethod;
    
    public class BenzFactory implements CarFactory{
    	
    	@Override
    	public Car createCar() {
    		return new Benz();
    	}
    }
    

    调用者：

    package com.wzg.factory.factorymethod;
    
    public class Client {
    	public static void main(String[] args) {
    		Car c1 = new AudiFactory().createCar();
    		c1.run();
    		
    		Car c2 = new BMWFactory().createCar();
    		c2.run();
    	}
    }
    

    想要添加新的功能，只需添加新对应的类。例如添加Benz。

    首先添加实体类

    package com.wzg.factory.factorymethod;
    
    public class Benz implements Car{
    	@Override
    	public void run() {
    		System.out.println("这是奔驰车");
    	}
    }
    

    然后添加工厂类：

    package com.wzg.factory.factorymethod;
    
    public class BenzFactory implements CarFactory{
    	
    	@Override
    	public Car createCar() {
    		return new Benz();
    	}
    }
    

  • 抽象工厂模式

    用来生产不同产品族的全部产品。对于新增的产品，无能为力；支持增加产品族。

    抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

    例如：在下面的例子中，汽车简单有三部分：发动机，座椅，轮胎。则三个对应的接口组成了一个产品族。具体类型有LowEngine，LowSeat，LowTyre组成低端汽车，LuxuryEngine，LuxurySeat，LuxuryTyre组成高端汽车，等等或其他组合。

    UML结构示意图：

    

    package com.wzg.factory.abstractFactory;
    
    public interface Engine {
    	void run();
    	void start();
    }
    
    class LuxuryEngine implements Engine{
    	@Override
    	public void run() {
    		System.out.println("好的发动机run");
    	}
    	
    	@Override
    	public void start() {
    		System.out.println("好的发动机start");
    	}
    }
    
    class LowEngine implements Engine{
    	@Override
    	public void run() {
    		System.out.println("差的发动机run");
    	}
    	
    	@Override
    	public void start() {
    		System.out.println("差的发动机start");
    	}
    }
    

    package com.wzg.factory.abstractFactory;
    
    public interface Seat {
    	void massage();
    }
    
    class LuxurySeat implements Seat{
    	
    	@Override
    	public void massage() {
    		System.out.println("高端座椅");
    	}
    }
    
    class LowSeat implements Seat{
    	
    	@Override
    	public void massage() {
    		System.out.println("低端座椅");
    	}
    }
    

    package com.wzg.factory.abstractFactory;
    
    public interface Tyre {
    	void revolve();
    }
    
    class LuxuryTyre implements Tyre{
    	@Override
    	public void revolve() {
    		System.out.println("高端轮胎");
    	}
    }
    
    class LowTyre implements Tyre{
    	@Override
    	public void revolve() {
    		System.out.println("低端轮胎");
    	}
    }
    

    package com.wzg.factory.abstractFactory;
    
    public interface CarFactory {
    	Engine createEngine();
    	Seat createSeat();
    	Tyre createTyre();
    }
    

    package com.wzg.factory.abstractFactory;
    
    public class LowCarFactory implements CarFactory{
    	@Override
    	public Engine createEngine() {
    		return new LowEngine();
    	}
    	@Override
    	public Seat createSeat() {
    		return new LowSeat();
    	}
    	@Override
    	public Tyre createTyre() {
    		return new LowTyre();
    	}
    }
    

    package com.wzg.factory.abstractFactory;
    
    public class LuxuryCarFactory implements CarFactory{
    	@Override
    	public Engine createEngine() {
    		return new LuxuryEngine();
    	}
    	@Override
    	public Seat createSeat() {
    		return new LuxurySeat();
    	}
    	@Override
    	public Tyre createTyre() {
    		return new LuxuryTyre();
    	}
    }
    

    package com.wzg.factory.abstractFactory;
    
    public class Client {
    	public static void main(String[] args) {
    		CarFactory factory = new LowCarFactory();
    		Engine engine = factory.createEngine();
    		engine.run();
    		engine.start();
    	}
    }