Java设计模式——工厂模式

前言
  工厂模式是一种比较常见的创建模式。有时，可能你使用了工厂模式而你却还不知道你已经使用了它。至少我感觉下面说的第一种简单工厂模式，你是已经很熟悉了。并且是经常使用的。不信，就继续向下看。
 
版权说明
著作权归作者所有。
商业转载请联系作者获得授权，非商业转载请注明出处。
本文作者：Coding-Naga
发表日期： 2016年4月14日
来源：CSDN
更多内容：分类 >> 设计模式
 
简单工厂模式(Simple Factory Pattern)
  从简单的工厂模式开始说起的话，我们要知道工厂模式的目的是什么？工厂模式的目的在于程序的可扩展性。而对于简单工厂模式来说，它是为了让程序有一个更好地封装，降低程序模块之间的耦合程度。
  对于简单的工厂模式，其实也可以将其理解成为一个创建对象的工具类。工具类的形式，可以仿造如下代码编写：
[java] view plain copy
  1. public class SimpleFactory {  
  2.   
  3.     public Object create(Class<?> clazz) {  
  4.         if (clazz.getName().equals(Plane.class.getName())) {  
  5.             return createPlane();  
  6.         } else if (clazz.getName().equals(Broom.class.getName())) {  
  7.             return createBroom();  
  8.         }  
  9.           
  10.         return null;  
  11.     }  
  12.       
  13.     private Broom createBroom() {  
  14.         return new Broom();  
  15.     }  
  16.       
  17.     private Plane createPlane() {  
  18.         return new Plane();  
  19.     }  
  20. }  
测试代码如下：
[java] view plain copy
  1. public class FactoryTest {  
  2.   
  3.     public static void main(String[] args) {  
  4.         // 简单工厂模式测试  
  5.         SimpleFactory simpleFactory = new SimpleFactory();  
  6.         Broom broom = (Broom) simpleFactory.create(Broom.class);  
  7.         broom.run();  
  8.     }  
  9. }  
正如之前所说的，简单的工厂模式，就是去创建一个创建对象的工具类。在这个工具类里面，我们就可以进行一些其他操作，比如对象的初始化。这样就避免了把对象初始化的大量代码(如果有大量代码的话)放在构造函数里了。
 
工厂方法模式(Factory Method Pattern)
之前说了简单的工厂模式，在简单的工厂模式里，我们创建了一个类似工具的类来创建相应的具体类对象。正因为其太过简单，有一点不成规范。所以，这里要对其做一些适当地封装。
我们来看一下工厂方法模式的定义吧。工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化哪一个。工厂方法让类把实例化推迟到了子类。（定义摘自《Head First设计模式》）
 
图-1 工厂方法模式
抽象工厂：
我们的抽象工厂可以是类似这样的：
[java] view plain copy
  1. public abstract class VehicleFactory {  
  2.     public abstract Moveable create();  
  3. }  
具体工厂：
代码就是这样简单而美好。而它有一个具体的实现工厂类：
[java] view plain copy
  1. public class BroomFactory extends VehicleFactory {  
  2.   
  3.     @Override  
  4.     public Moveable create() {  
  5.         return new Broom();  
  6.     }  
  7.   
  8. }  
这个具体的实现工厂告诉我们，这里可以通过 create() 方法来创建一个 Broom 对象。
我们可以这样来理解他们的关系：有一个大的工厂它就是 VehicleFactory，VehicleFactory工厂里又有很多生产车间，其中有一个就是 BroomFactory。我们的具体产品都是通过这些生产车间来负责生产的。
抽象产品接口：
说到了产品，我们可以先试想一下这些具体的产品都会有什么样的性质。我们可以这样来定义它们：
[java] view plain copy
  1. public interface Moveable {  
  2.     public void run();  
  3. }  
具体产品：
嗯，这是一些可以run(移动)的产品。就 BroomFactory 生产车间而言，它负责生产 Broom。这个 Broom 是具有 Moveable 的属性。那么它的实现可以这样来写：
[java] view plain copy
  1. public class Broom implements Moveable {  
  2.   
  3.     @Override  
  4.     public void run() {  
  5.         System.out.println("我是Broom.我在飞...");  
  6.     }  
  7.   
  8. }  
功能测试：
我们有工厂，并且知道了工厂要生产的产品了。那么我们就来生产一个 Broom 来试试吧：
[java] view plain copy
  1. VehicleFactory factory = new BroomFactory();  
  2. Moveable moveable = factory.create();  
  3. moveable.run();  
这样我就生产了一个 Broom 了。是不是 so easy？
 
抽象工厂模式(Abstract Factory Pattern)
从上面的工厂方法中的结构图中，我们可以看到其中的具体工厂A和B是两个完全独立的。两者除了都是抽象工厂的子类，没有任何其他的交集。
但是，如果我们有这样一个需求：具体工厂A和B需要生产一些同类型的不同产品。那么我们就可以试试抽象工厂模式。
我们来看看抽象工厂模式是怎么定义的：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。同样在下面的结构图中，我们可以更好地解释这一定义。我们的抽象工厂中包含一系列的去构造一个抽象产品的方法，而具体产品的实现则是放在了具体工厂（图中的A和B）中进行。
 
图-2 抽象工厂模式
现在我们看看代码中是如何实现的。
抽象工厂：
[java] view plain copy
  1. public abstract class AbstractFactory {  
  2.   
  3.     public abstract Flyable createFlyable();  
  4.       
  5.     public abstract Moveable createMoveable();  
  6.       
  7.     public abstract Writeable createWriteable();  
  8. }  
具体工厂：
从抽象工厂的代码中也可以看出，抽象工厂只是去“生产”一些抽象的东西。有点类似于底层机制的感觉。现在我们来看看具体工厂的实现。
[java] view plain copy
  1. public class Factory1 extends AbstractFactory {  
  2.   
  3.     @Override  
  4.     public Flyable createFlyable() {  
  5.         return new Aircraft();  
  6.     }  
  7.   
  8.     @Override  
  9.     public Moveable createMoveable() {  
  10.         return new Car();  
  11.     }  
  12.   
  13.     @Override  
  14.     public Writeable createWriteable() {  
  15.         return new Pen();  
  16.     }  
  17.   
  18. }  
抽象产品接口：
在具体工厂里，我们就可以生产一些具体的产品了。就是这里的Aircraft、Car、Pen。抽象的产品接口如下。
[java] view plain copy
  1. public interface Flyable {  
  2.   
  3.     public void fly(int height);  
  4. }  
具体产品：
具体的产品则是要去实现这个接口，并实现其中的方法，如下：
[java] view plain copy
  1. public class Aircraft implements Flyable {  
  2.   
  3.     @Override  
  4.     public void fly(int height) {  
  5.         System.out.println("我是一架客运机，我目前的飞行高度为：" + height + "千米。");  
  6.     }  
  7.   
  8. }  
功能测试：
有了这些东西，那么我们就来好好生产一些产品吧。
[java] view plain copy
  1. public class FactoryTest {  
  2.   
  3.     public static void main(String[] args) {  
  4.         AbstractFactory factory = new Factory1();  
  5.         Flyable flyable = factory.createFlyable();  
  6.         flyable.fly(1589);  
  7.           
  8.         Moveable moveable = factory.createMoveable();  
  9.         moveable.run(87.6);  
  10.           
  11.         Writeable writeable = factory.createWriteable();  
  12.         writeable.write("Hello World.");  
  13.     }  
  14. }  
  现在让我们来看一下，结果是否跟我们想的一样吧。
图-3 抽象工厂模式运行结果图
 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/qi-dian-ao/p/8463540.html