设计模式之工厂模式

zoukankan html css js c++ java

设计模式之工厂模式
转载：http://blog.csdn.net/lemon_tree12138/article/details/46225213

简单工厂模式(Simple Factory Pattern)

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

对于简单的工厂模式，其实也可以将其理解成为一个创建对象的工具类。工具类的形式，可以仿造如下代码编写：
[java] view plain copy

print ?

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();

    }

}
```
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();
    }
}
```
测试代码如下：
[java] view plain copy

print ?

public class FactoryTest {



    public static void main(String[] args) {

        // 简单工厂模式测试

        SimpleFactory simpleFactory = new SimpleFactory();

        Broom broom = (Broom) simpleFactory.create(Broom.class);

        broom.run();

    }

}
```
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 工厂方法模式

抽象工厂：

我们的抽象工厂可以是类似这样的：
[java] view plain copy

print ?

public abstract class VehicleFactory {

    public abstract Moveable create();

}
```
public abstract class VehicleFactory {
    public abstract Moveable create();
}
```
具体工厂：

代码就是这样简单而美好。而它有一个具体的实现工厂类：
[java] view plain copy

print ?

public class BroomFactory extends VehicleFactory {



    @Override

    public Moveable create() {

        return new Broom();

    }



}
```
public class BroomFactory extends VehicleFactory {

    @Override
    public Moveable create() {
        return new Broom();
    }

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

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

抽象产品接口：

说到了产品，我们可以先试想一下这些具体的产品都会有什么样的性质。我们可以这样来定义它们：
[java] view plain copy

print ?

public interface Moveable {

    public void run();

}
```
public interface Moveable {
    public void run();
}
```
具体产品：

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

print ?

public class Broom implements Moveable {



    @Override

    public void run() {

        System.out.println("我是Broom.我在飞...");

    }



}
```
public class Broom implements Moveable {

    @Override
    public void run() {
        System.out.println("我是Broom.我在飞...");
    }

}
```
功能测试：

我们有工厂，并且知道了工厂要生产的产品了。那么我们就来生产一个 Broom 来试试吧：
[java] view plain copy

print ?

VehicleFactory factory = new BroomFactory();

Moveable moveable = factory.create();

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 抽象工厂模式

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

抽象工厂：
[java] view plain copy

print ?

public abstract class AbstractFactory {



    public abstract Flyable createFlyable();



    public abstract Moveable createMoveable();



    public abstract Writeable createWriteable();

}
```
public abstract class AbstractFactory {

    public abstract Flyable createFlyable();
    
    public abstract Moveable createMoveable();
    
    public abstract Writeable createWriteable();
}
```
具体工厂：

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

print ?

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();

    }



}
```
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。抽象的产品接口如下。
[java] view plain copy

print ?

public interface Flyable {



    public void fly(int height);

}
```
public interface Flyable {

    public void fly(int height);
}
```
具体产品：

具体的产品则是要去实现这个接口，并实现其中的方法，如下：
[java] view plain copy

print ?

public class Aircraft implements Flyable {



    @Override

    public void fly(int height) {

        System.out.println("我是一架客运机，我目前的飞行高度为：" + height + "千米。");

    }



}
```
public class Aircraft implements Flyable {

    @Override
    public void fly(int height) {
        System.out.println("我是一架客运机，我目前的飞行高度为：" + height + "千米。");
    }

}
```
功能测试：

有了这些东西，那么我们就来好好生产一些产品吧。
[java] view plain copy

print ?

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.");

    }

}
```
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链接。
查看全文

相关阅读:
C#获取局域网MAC地址
 查看Linux是32位还是64位的方法
 JS判断不能为空实例代码
 SQL2005数据库行列转换
 mysql 导入导出数据库、数据表的方法
 linux kill 关闭进程命令
 设置CentOS控制台分辨率图文详解
 Windows 2003 IIS 不支持ASP问题的解决方法
 稳聘App设计图分享
 Sql 中存储过程详细案例

原文地址：https://www.cnblogs.com/xiaolovewei/p/7736487.html

设计模式之工厂模式

简单工厂模式(Simple Factory Pattern)

测试代码如下：

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

工厂方法模式(Factory Method Pattern)

抽象工厂：

具体工厂：

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

抽象产品接口：

具体产品：

功能测试：

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

抽象工厂模式(Abstract Factory Pattern)

抽象工厂：

具体工厂：

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

抽象产品接口：

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

具体产品：

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

功能测试：

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

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

总结