工厂模式学习笔记（详细）

工厂模式学习笔记（详细）

一、什么是工厂模式

工厂模式是一种创建型模式，它将创建对象逻辑封装起来，不会暴露给使用者，使用者只需要调用方法便可以获得完整的对象，符合迪米特法则

二、应用场景

工厂模式适用在生成复杂对象的时候，而生成简单对象时，比如new一个对象，则不需要使用工厂模式
工厂模式可以减少代码耦合，生成一个对象，需要增加许多依赖关系的时候，就可以使用工厂模式
spring通过BeanFactory和ApplicationContext创建Bean对象时就使用了工厂模式

三、三种实现方式

1. 简单工厂模式

简单工厂模式由两个部分组成

• 产品：一个产品接口和实现这个接口的产品
• 工厂： 一个生成产品的工厂类

工厂类可以有一个生成产品的方法，通过传参来判断生产哪个产品

用一个造车工厂做为例子

• 编写汽车接口Car

	public interface Car {
		void make();
	}

汽车接口有一个make()方法

• 编写汽车类BmwCar

	public class BmwCar implements Car{
	
	    public BmwCar(){}
	
	    @Override
	    public void make() {
	        System.out.println("制造一辆宝马");
	    }
	}

实现汽车接口，实现make()方法

• 编写汽车类PorscheCar

	public class PorscheCar implements Car {
	
	    public PorscheCar(){}
	
	    @Override
	    public void make() {
	        System.out.println("制造一辆保时捷");
	    }
	}

实现汽车接口，实现make()方法

• 编写工厂类CarFactory

	public class CarFactory {
	
	    public Car makeCar(String type){
	
	        if("bmwCar".equals(type)){
	            return new BmwCar();
	        }
	
	        if("porscheCar".equals(type)){
	            return new PorscheCar();
	        }
	        return null;
	
	    }
	}

通过传进来的type参数来判断生成哪个对象

• 编写执行类Run

	public class Run {
	
	    public static void main(String[] args) {
	
	        //工厂
	        CarFactory carFactory = new CarFactory();
	
	        //从工厂获取宝马对象
	        Car bmwCar = carFactory.makeCar("bmwCar");
	        bmwCar.make();
	
	        //从工厂获取保时捷对象
	        Car porscheCar = carFactory.makeCar("porscheCar");
	        porscheCar.make();
	    }
	
	}

• 执行结果
  

2. 工厂方法模式

工厂方法模式是在简单工厂模式上增加了抽象工厂类，抽象工厂有一个生成产品的方法，当新增一个产品时就创建一个工厂实现抽象工厂，简单来说，工厂方法模式就是一个工厂对应一个产品，通过工厂接口进行解耦

修改刚刚的工厂类

• 编写工厂接口AbstractFactory

	public interface AbstractFactory {
	
	    Car make();
	}

• 编写宝马工厂类BmwCarFactory

	public class BmwCarFactory implements AbstractFactory{
	
	    @Override
	    public Car makeCar() {
	        return new BmwCar();
	    }
	
	}

• 编写保时捷工厂类PorscheCarFactory

	public class PorcheCarFactory implements AbstractFactory {
	
	    @Override
	    public Car makeCar() {
	        return new PorscheCar();
	    }
	
	}

• 编写执行类Run2

	public class Run2 {
	
	    public static void main(String[] args) {
	
	        //工厂
	        AbstractFactory bmwCarFactory = new BmwCarFactory();
	        AbstractFactory porscheFactory = new PorcheCarFactory();
	
	        //从工厂获取宝马对象
	        Car bmw = bmwCarFactory.makeCar();
	        bmw.make();
	
	        //从工厂获取保时捷对象
	        Car porsche = porscheFactory.makeCar();
	        porsche.make();
	
	    }
	
	}

• 执行结果
  

2. 抽象工厂模式

抽象工厂模式，是在工厂方法模式上扩展，在一个工厂中支持制造多个产品

在刚刚的基础上新增一个产品，这里我们假设宝马和法拉利产商也制造飞机

• 编写飞机接口Plane

	public interface Plane {
	    void make();
	}

• 编写宝马飞机类BmwPlane

	public class BmwPlane implements Plane {
	
	    @Override
	    public void make() {
	        System.out.println("制造宝马飞机");
	    }
	
	}

• 编写保时捷飞机类PorschePlane

	public class PorschePlane implements Plane {
	
	    @Override
	    public void make() {
	        System.out.println("制造保时捷飞机");
	    }
	
	}

下面修改工厂相关的类

• 工厂接口AbstractFactory添加制造飞机方法makePlane()

	public interface AbstractFactory {
	
	    Car makeCar();
	    Plane makePlane();
	
	}

• 宝马工厂BmwFactory

	public class BmwFactory implements AbstractFactory{
	
	    @Override
	    public Car makeCar() {
	        return new BmwCar();
	    }
	
	    @Override
	    public Plane makePlane() {
	        return new BmwPlane();
	    }
	
	}

• 保时捷工厂PorcheFactory

	public class PorcheFactory implements AbstractFactory {
	
	    @Override
	    public Car makeCar() {
	        return new PorscheCar();
	    }
	
	    @Override
	    public Plane makePlane() {
	        return new PorschePlane();
	    }
	
	}

• 执行类Run2修改

	public class Run2 {
	
	    public static void main(String[] args) {
	
	        //工厂
	        AbstractFactory bmwFactory = new BmwFactory();
	        AbstractFactory porscheFactory = new PorcheFactory();
	
	        //从工厂获取宝马对象
	        Car bmwCar = bmwFactory.makeCar();
	        Plane bmwPlane = bmwFactory.makePlane();
	        bmwCar.make();
	        bmwPlane.make();
	
	        //从工厂获取保时捷对象
	        Car porscheCar = porscheFactory.makeCar();
	        Plane porschePlane = porscheFactory.makePlane();
	        porscheCar.make();
	        porschePlane.make();
	
	    }
	
	}

• 执行结果

四、总结（三种方式的区别）

这里先讲一下产品等级结构和产品族的概念

• 产品等级结构：是指由同一个产品接口派生出来的产品，比如上面抽象工厂模式讲的宝马车和保时捷车就是一个产品等级结构，保时捷车和保时捷飞机是另一个产品等级结构
• 产品族：是指不同的产品等级结构中功能相关联的产品组成的家族，比如上面抽象工厂模式讲的宝马车和保时捷车就是一个产品族，宝马飞机和保时捷飞机是另外一个产品族

然后讲一下三个工厂模式的区别

1. 简单工厂模式： 只有一个工厂类，通过传参数来获得决定获取哪个对象

• 优点：实现了对象的创建和使用的分离，降低了耦合
• 缺点：当产品增加的时候，需要增加工厂类的逻辑判断代码，使代码复杂度增加

3. 工厂方法模式： 在简单工厂模式上增加一个工厂接口，由这个工厂接口派生出工厂，一个工厂接口对应一个产品接口，一个工厂对应一个产品

• 优点：将创建产品实例的工作放到工厂子类上去实现，核心类只需要关注工厂接口的定义，降低代码间的耦合，当需要新增一个产品时，只需要新增工厂接口和具体的实现类，不需要改动原有的代码，提高了扩展性
• 缺点：在需要新增另一种类的产品时（新增产品接口），需要新增新的工厂接口和具体的实现类，当产品很多的时候，系统中类的数量就会变的很多

4. 抽象工厂模式： 在工厂方法模式上加上了产品族的概念，在新增另一种类的产品时（新增产品接口），与工厂方法的区别就在于，抽象工厂是在工厂接口里新加一个对应的方法，形成产品族，而不是新增一个工厂接口

• 优点：具备工厂方法的优点，并且可以在类的内部对同一产品族进行约束，同一产品族之间一般都会存在一些联系，这样不用再添加新的类进行管理，而且在新增产品时不需要新增工厂接口，减少了系统中类的数量
• 缺点：在扩展产品族时，几乎需要修改所有的工厂类