zoukankan      html  css  js  c++  java
  • 设计模式之工厂模式

    转载:http://blog.csdn.net/lemon_tree12138/article/details/46225213

    简单工厂模式(Simple Factory Pattern)

      从简单的工厂模式开始说起的话,我们要知道工厂模式的目的是什么?工厂模式的目的在于程序的可扩展性。而对于简单工厂模式来说,它是为了让程序有一个更好地封装,降低程序模块之间的耦合程度。

      对于简单的工厂模式,其实也可以将其理解成为一个创建对象的工具类。工具类的形式,可以仿造如下代码编写:

    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. }  
    public class SimpleFactory {
    
        public Object create(Class<?> clazz) {
            if (clazz.getName().equals(Plane.class.getName())) {
                return createPlane();
            } else if (clazz.getName().equals(Broom.class.getName())) {
                return createBroom();
            }
            
            return null;
        }
        
        private Broom createBroom() {
            return new Broom();
        }
        
        private Plane createPlane() {
            return new Plane();
        }
    }

    测试代码如下:

    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. }  
    public class FactoryTest {
    
        public static void main(String[] args) {
            // 简单工厂模式测试
            SimpleFactory simpleFactory = new SimpleFactory();
            Broom broom = (Broom) simpleFactory.create(Broom.class);
            broom.run();
        }
    }

    正如之前所说的,简单的工厂模式,就是去创建一个创建对象的工具类。在这个工具类里面,我们就可以进行一些其他操作,比如对象的初始化。这样就避免了把对象初始化的大量代码(如果有大量代码的话)放在构造函数里了。

    工厂方法模式(Factory Method Pattern)

    之前说了简单的工厂模式,在简单的工厂模式里,我们创建了一个类似工具的类来创建相应的具体类对象。正因为其太过简单,有一点不成规范。所以,这里要对其做一些适当地封装。

    我们来看一下工厂方法模式的定义吧。工厂方法模式定义了一个创建对象的接口,但由子类决定要实例化哪一个。工厂方法让类把实例化推迟到了子类。(定义摘自《Head First设计模式》)

    图-1 工厂方法模式

    抽象工厂:

    我们的抽象工厂可以是类似这样的:

    1. public abstract class VehicleFactory {  
    2.     public abstract Moveable create();  
    3. }  
    public abstract class VehicleFactory {
        public abstract Moveable create();
    }

    具体工厂:

    代码就是这样简单而美好。而它有一个具体的实现工厂类:

    1. public class BroomFactory extends VehicleFactory {  
    2.   
    3.     @Override  
    4.     public Moveable create() {  
    5.         return new Broom();  
    6.     }  
    7.   
    8. }  
    public class BroomFactory extends VehicleFactory {
    
        @Override
        public Moveable create() {
            return new Broom();
        }
    
    }

    这个具体的实现工厂告诉我们,这里可以通过 create() 方法来创建一个 Broom 对象。

    我们可以这样来理解他们的关系:有一个大的工厂它就是 VehicleFactory,VehicleFactory工厂里又有很多生产车间,其中有一个就是 BroomFactory。我们的具体产品都是通过这些生产车间来负责生产的。

    抽象产品接口:

    说到了产品,我们可以先试想一下这些具体的产品都会有什么样的性质。我们可以这样来定义它们:

    1. public interface Moveable {  
    2.     public void run();  
    3. }  
    public interface Moveable {
        public void run();
    }

    具体产品:

    嗯,这是一些可以run(移动)的产品。就 BroomFactory 生产车间而言,它负责生产 Broom。这个 Broom 是具有 Moveable 的属性。那么它的实现可以这样来写:

    1. public class Broom implements Moveable {  
    2.   
    3.     @Override  
    4.     public void run() {  
    5.         System.out.println("我是Broom.我在飞...");  
    6.     }  
    7.   
    8. }  
    public class Broom implements Moveable {
    
        @Override
        public void run() {
            System.out.println("我是Broom.我在飞...");
        }
    
    }

    功能测试:

    我们有工厂,并且知道了工厂要生产的产品了。那么我们就来生产一个 Broom 来试试吧:

    1. VehicleFactory factory = new BroomFactory();  
    2. Moveable moveable = factory.create();  
    3. moveable.run();  
    VehicleFactory factory = new BroomFactory();
    Moveable moveable = factory.create();
    moveable.run();

    这样我就生产了一个 Broom 了。是不是 so easy?

    抽象工厂模式(Abstract Factory Pattern)

    从上面的工厂方法中的结构图中,我们可以看到其中的具体工厂A和B是两个完全独立的。两者除了都是抽象工厂的子类,没有任何其他的交集。

    但是,如果我们有这样一个需求:具体工厂A和B需要生产一些同类型的不同产品。那么我们就可以试试抽象工厂模式。

    我们来看看抽象工厂模式是怎么定义的:为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类。同样在下面的结构图中,我们可以更好地解释这一定义。我们的抽象工厂中包含一系列的去构造一个抽象产品的方法,而具体产品的实现则是放在了具体工厂(图中的A和B)中进行。

    图-2 抽象工厂模式

    现在我们看看代码中是如何实现的。

    抽象工厂:

    1. public abstract class AbstractFactory {  
    2.   
    3.     public abstract Flyable createFlyable();  
    4.       
    5.     public abstract Moveable createMoveable();  
    6.       
    7.     public abstract Writeable createWriteable();  
    8. }  
    public abstract class AbstractFactory {
    
        public abstract Flyable createFlyable();
        
        public abstract Moveable createMoveable();
        
        public abstract Writeable createWriteable();
    }

    具体工厂:

    从抽象工厂的代码中也可以看出,抽象工厂只是去“生产”一些抽象的东西。有点类似于底层机制的感觉。现在我们来看看具体工厂的实现。

    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. }  
    public class Factory1 extends AbstractFactory {
    
        @Override
        public Flyable createFlyable() {
            return new Aircraft();
        }
    
        @Override
        public Moveable createMoveable() {
            return new Car();
        }
    
        @Override
        public Writeable createWriteable() {
            return new Pen();
        }
    
    }

    抽象产品接口:

    在具体工厂里,我们就可以生产一些具体的产品了。就是这里的Aircraft、Car、Pen。抽象的产品接口如下。

    1. public interface Flyable {  
    2.   
    3.     public void fly(int height);  
    4. }  
    public interface Flyable {
    
        public void fly(int height);
    }

    具体产品:

    具体的产品则是要去实现这个接口,并实现其中的方法,如下:

    1. public class Aircraft implements Flyable {  
    2.   
    3.     @Override  
    4.     public void fly(int height) {  
    5.         System.out.println("我是一架客运机,我目前的飞行高度为:" + height + "千米。");  
    6.     }  
    7.   
    8. }  
    public class Aircraft implements Flyable {
    
        @Override
        public void fly(int height) {
            System.out.println("我是一架客运机,我目前的飞行高度为:" + height + "千米。");
        }
    
    }

    功能测试:

    有了这些东西,那么我们就来好好生产一些产品吧。

    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. }  
    public class FactoryTest {
    
        public static void main(String[] args) {
            AbstractFactory factory = new Factory1();
            Flyable flyable = factory.createFlyable();
            flyable.fly(1589);
            
            Moveable moveable = factory.createMoveable();
            moveable.run(87.6);
            
            Writeable writeable = factory.createWriteable();
            writeable.write("Hello World.");
        }
    }

      现在让我们来看一下,结果是否跟我们想的一样吧。

    图-3 抽象工厂模式运行结果图

     

    总结

    以上就是工厂模式的基本实现和详细说明。包括了简单工厂模式、工厂方法模式、抽象工厂模式。我们可以基于需求来选择合适的工厂模式。下面给出本文的所有代码的GitHub链接。

  • 相关阅读:
    Linux下替换默认版本的protobuf
    论文笔记——NEURAL ARCHITECTURE SEARCH WITH REINFORCEMENT LEARNING
    kafka 学习之初体验
    git命令01
    git 命令02
    SSH远程连接连接其他主机,等待时间过长的原因。
    lsof命令详解
    文本处理命令
    Windows Server 2008 远程桌面连接拒绝
    vim文本编辑工具—修改文件内容
  • 原文地址:https://www.cnblogs.com/xiaolovewei/p/7736487.html
Copyright © 2011-2022 走看看