设计模式：4-工厂方法模式和抽象工厂:Factory and Abstract Factory

文章来源本人的博客：http://codelifeliwan.github.io/ 转载请注明出处
查看[设计模式]系列内容请点击：https://www.jianshu.com/nb/45937362

工厂方法模式：

定义：(Factory)

定义一个创建产品对象的工厂接口，将实际创建性工作推迟到子类中

示例说明如下：

图片1

客户端调用关系说明：

图片2

我的理解：

使用统一的管理接口，但是具体的创建使用是根据实际情况选择的，而不是一开始就创建一个不一定用得着的产品，记住先有产品然后找工厂来创建它。

代码如下：

package com.codelifeliwan.factory;
 
//抽象产品
public interface IFruit {
    public void grow(); // fruit自己的方法接口
}

package com.codelifeliwan.factory;
 
//抽象工厂
public interface IGardener {
    public IFruit factory(); // 生产fruit的统一接口
}

package com.codelifeliwan.factory;
 
//具体产品
public class Apple implements IFruit {
    @Override
    public void grow() {
        System.out.println("Apple growing...");
    }
}

package com.codelifeliwan.factory;
 
//具体产品
public class Grape implements IFruit {
    @Override
    public void grow() {
        System.out.println("Grape growing...");
    }
}

package com.codelifeliwan.factory;
 
//具体工厂，用于生产特定的水果产品 
public class AppleGardener implements IGardener {
    @Override
    public IFruit factory() {
        return new Apple();
    }
}

package com.codelifeliwan.factory;
 
//具体工厂，用于生产特定的水果产品 
public class GrapeGardener implements IGardener {
    @Override
    public IFruit factory() {
        return new Grape();
    }
}

package com.codelifeliwan.factory;
 
//客户端
public class Client {
    public static void main(String args[]) {
        IGardener gardener = null; // 定义创建产品对象接口
 
        gardener = new AppleGardener();
        IFruit apple = gardener.factory(); // 实际的创建产品对象在子类中
        apple.grow();
 
        System.out.println("========这是美丽的分割线========");
 
        gardener = new GrapeGardener();
        IFruit grape = gardener.factory();// 实际的创建产品对象在子类中
        grape.grow();
    }
}

优点：

封装性良好，降低模块之间的耦合，调用者只需要关心工厂类或者产品类的接口而完全不需要关心内部实现细节

可扩展性好，在增加产品的情况下只需要适当修改工厂类或者扩展一个工厂类即可

使用场景：

工厂方法模式在项目中使用非常频繁，，当需要灵活的、可扩展的框架等的时候需要采用，在Java的设计中工厂方法很常见，比如ClassB classB=ClassBFactory.getInstance();的方式（有时候与Builder模式很像）

工厂方法模式与其他的一些模式混合使用能构造出很好的设计（比如最初最常用DAO设计模式和Java Web中的MVC模式）

抽象工厂：

定义：(Abstract Factory)

抽象工厂模式是工厂方法模式的一个升级版本，它与工厂方法模式的区别是：工厂方法模式一个工厂只创建一个产品，而一个抽象工厂能创建一组相关的产品，这些相关的产品不一定是同一类型的产品，详细见代码

类比就是有一个农夫同时管理一个果园和一个牧场，而工厂中一个农夫只管理一个果园而不管理牧场

package com.codelifeliwan.abstractfactory;
 
public interface ProductA {
    public void actionA();
}
 
 
package com.codelifeliwan.abstractfactory;
 
public interface ProductB {
    public void funcB();
}
 
 
package com.codelifeliwan.abstractfactory;
 
public class ProductA1 implements ProductA {
 
    @Override
    public void actionA() {
        System.out.println("===actionA-1");
    }
}
 
 
package com.codelifeliwan.abstractfactory;
 
public class ProductA2 implements ProductA {
 
    @Override
    public void actionA() {
        System.out.println("===actionA-2");
    }
}
 
 
package com.codelifeliwan.abstractfactory;
 
public class ProductB1 implements ProductB{
 
    @Override
    public void funcB() {
        System.out.println("===functionB-1");
    }
}
 
 
package com.codelifeliwan.abstractfactory;
 
public class ProductB2 implements ProductB {
 
    @Override
    public void funcB() {
        System.out.println("===functionB-2");
    }
}
 
 
package com.codelifeliwan.abstractfactory;
 
public interface AbstractFactory {
 
    public ProductA factoryA();
 
    public ProductB factoryB();
}
 
 
package com.codelifeliwan.abstractfactory;
 
public class Factory1 implements AbstractFactory {
 
    @Override
    public ProductA factoryA() {
        return new ProductA1();
    }
 
    @Override
    public ProductB factoryB() {
        return new ProductB1();
    }
}
 
 
package com.codelifeliwan.abstractfactory;
 
public class Factory2 implements AbstractFactory {
 
    @Override
    public ProductA factoryA() {
        return new ProductA2();
    }
 
    @Override
    public ProductB factoryB() {
        return new ProductB2();
    }
}
 
 
package com.codelifeliwan.abstractfactory;
 
public class Client {
    public static void main(String args[]) {
 
        // factory1生产ProductA1和ProductB1产品，其中这两个产品是相关产品
        AbstractFactory factory1 = new Factory1();
 
        // factory2生产ProductA2和ProductB2产品，其中这两个产品是相关产品
        AbstractFactory factory2 = new Factory2();
 
        ProductA a1 = factory1.factoryA();
        a1.actionA();
        ProductB b1 = factory1.factoryB();
        b1.funcB();
 
        System.out.println("==========这是美丽的分割线=============");
 
        ProductA a2 = factory2.factoryA();
        a2.actionA();
        ProductB b2 = factory2.factoryB();
        b2.funcB();
    }
}

使用场景：

一组相关的产品内存在约束，或者约束不公开的时候使用抽象工厂模式，避免数据破坏，减少了模块之间的耦合度
生产线的扩展容易，需要为一组产品建立新的生产线时只需要重新实现一个新的工厂将这些产品纳入进来即可