设计模式之 工厂模式

      工厂模式是创建型模式之一。简单的说，工厂模式就是为了减少代码的工作量，方便测试和扩展。在工厂模式中，创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。创建工厂类，接收不同的参数生成不同的对象的过程。由于简单工厂模式，抽象工厂模式，工厂方法模式依次递进且很相似，所以放在一起总结。

一、定义

        工厂模式定义一个用于创建对象的接口，这个接口由子类决定实例话哪一个类。该模式是一个类的实例话延迟到了子类。而子类可以重写接口方法便于创建不同类型的对像

二、分类

       简单工厂模式

       简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单 工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

        优点：

            1、简单工厂模式实现了责任分离

            2、工厂类中包含了对象生成的必要逻辑判断，根据客户端的选择条件实例化不同的对象，所以客户端没有创建对象所需要的条件

            3、客户端不直接创建产品类的对象，客户端只作为消费者，具体逻辑代码交由工厂类处理

        缺点：

            1、工厂类必须知道怎么样创建每一个对象，当增加一个对象时必须改动工厂类的逻辑代码，所以简单工厂模式不符合开闭原则。

            2、因为工厂类中的工厂方法是静态的，所以工厂类中的方法不能被重写，工厂类只是一个单独的类，它不能成为一个层次的类

       抽象工厂模式

     抽象工厂模式(Abstract Factory Pattern)：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

        优点：

            1、更符合开闭原则，增加创建对象时只需要修改相应的产品类和工厂子类

            2、符合单一职责原则，每个产品都有相应的工厂负责

            3、不使用静态工厂方法，可以形成基于继承的等级结构。

        缺点：

            1、没有完全符合开闭原则，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩 展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。

       工厂方法模式（工厂模式）

        优点：

        缺点：

三、基本结构

       简单工厂模式

        简单工厂模式定义三个角色：

         · 工厂角色（Factory）: 负责创建实例的具体逻辑。

      · 抽象产品角色（Product）：是所有创建对象的的父类，拥有所有创建对象的公共接口。

      · 具体产品角色（CreateProduct）：具体产品角色是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

        

       抽象工厂模式

        AbstractFactory：抽象工厂
        ConcreteFactory：具体工厂
        AbstractProduct：抽象产品
        Product：具体产品

         

       工厂方法模式

        Product：抽象产品

        ConcreteProduct：具体产品

        Factory：抽象工厂

        ConcreteProduct：具体工厂

        

四、时序图

       简单工厂模式

        

       抽象工厂模式

      工厂方法模式

     

五、代码实现

       简单工厂模式

            1.工厂角色

public class FruitFactory {
    public static Fruit newInstance(String name) throws BadFruitException {
        if ("apple".equalsIgnoreCase(name)) {
            return new Apple()；       
        } else if ("grape".equalsIgnoreCase(name)) {
            return new Grape();
        } else if ("strawberry".equalsIgnoreCase(name)) {
            return new Strawberry();
        // 其它情况，则抛出异常。
        } else {
            throw new BadFruitException("Bad fruit request!");
        }
    }
}

         2.抽象产品角色

public abstract class Fruit { 
    //公共属性
    abstract void grow();    // 生长
    abstract void harvest(); // 收获
    abstract void plant();   // 种植
 }

        3.具体产品角色

               由三个角色 apple、grape、strawberry都继承抽象产品角色，重写其中的方法表现出每个产品不一样的行为

        4.客户端代码

public class Client {

    public static void main(String[] args) {
        try {
            Fruit apple = FruitFactory.newInstance("Apple");
            apple.plant();
            apple.grow();
            apple.harvest();

            Fruit grape = FruitFactory.newInstance("Grape");
            grape.plant();
            grape.grow();
            grape.harvest();

            Fruit strawberry = FruitFactory.newInstance("strawberry");
            strawberry.plant();
            strawberry.grow();
            strawberry.harvest();

            Fruit error = FruitFactory.newInstance("error");
            error.plant();
            error.grow();
            error.harvest();
        } catch (BadFruitException e) {
            e.printStackTrace();
        }
    }
}

        抽象工厂模式     

           1、抽象工厂            

abstract class Factory{
   public abstract Product ManufactureContainer();
    public abstract Product ManufactureMould();
}

            2、具体工厂

//A厂 - 生产模具+容器产品
class FactoryA extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductA();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductA();
    }
}

//B厂 - 生产模具+容器产品
class FactoryB extends Factory{

    @Override
    public Product ManufactureContainer() {
        return new ContainerProductB();
    }

    @Override
    public Product ManufactureMould() {
        return new MouldProductB();
    }
}

            3、抽象产品族   

abstract class AbstractProduct{
    public abstract void Show();
}

            4、抽象产品  

//容器产品抽象类
abstract class ContainerProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

//模具产品抽象类
abstract class MouldProduct extends AbstractProduct{
    @Override
    public abstract void Show();
}

            5、具体产品

//容器产品A类
class ContainerProductA extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品A");
    }
}

//容器产品B类
class ContainerProductB extends ContainerProduct{
    @Override
    public void Show() {
        System.out.println("生产出了容器产品B");
    }
}

//模具产品A类
class MouldProductA extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品A");
    }
}

//模具产品B类
class MouldProductB extends MouldProduct{

    @Override
    public void Show() {
        System.out.println("生产出了模具产品B");
    }
}

            6、客户端

//生产工作流程
public class AbstractFactoryPattern {
    public static void main(String[] args){
        FactoryA mFactoryA = new FactoryA();
        FactoryB mFactoryB = new FactoryB();
        //A厂当地客户需要容器产品A
        mFactoryA.ManufactureContainer().Show();
        //A厂当地客户需要模具产品A
        mFactoryA.ManufactureMould().Show();

        //B厂当地客户需要容器产品B
        mFactoryB.ManufactureContainer().Show();
        //B厂当地客户需要模具产品B
        mFactoryB.ManufactureMould().Show();

    }
}

六、应用

       简单工厂模式    

        1、工厂类负责创建的对象比较少：由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂。

         2、客户端只知道传入工厂类的参数，对于如何创建对象不关心：客户端既不需要关心创建细节，甚至连类名都不需要记住，只需要知道类型所对应的参数。

        抽象工厂模式

      1、一个系统不要求依赖产品类实例如何被创建、组合和表达的表达，这点也是所有工厂模式应用的前提。

       2、这个系统有多个系列产品，而系统中只消费其中某一系列产品

       3、系统要求提供一个产品类的库，所有产品以同样的接口出现，客户端不需要依赖具体实现。