1.首先给出工厂方法的****定义：

定义一个创建对象的接口，让子类决定实例化哪一类，使一个类的实例化延迟到其子类。因为每一个具体产品类对应着一个具体的工厂类，故增加具体产品时只需要增加一个具体工厂类.。工厂方法模式是简单工厂模式的进一步抽象和推广，克服了简单工厂的违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点。

2.为什么要用工厂方法模式

工厂方法模式与简单工厂模式的区别在于工厂方法模式比简单工厂模式多出一个抽象工厂接口，每一个具体工厂实现某个具体产品的实现。比如生成每本书都需要许多信息，书名，出版社，生成时间和生成顺序，但是不同的书籍信息要求不确定。

3.简单工厂模式与工厂方法模式的区别

工厂方法模式与简单工厂模式的区别在于工厂方法模式比简单工厂模式多出一个抽象工厂接口，每一个具体工厂实现某个具体产品的实现
4.简单的举个例子：

我们将水果园比作一个工厂，在简单工厂模式下，水果园是一个具体的工厂，直接用来生产各种各样的水果。那么在工厂方法模式下，水果园是一个抽象工厂，那么苹果树，香蕉树等就相当于是具体工厂，生产苹果、香蕉等水果。每有一种新的水果要生产，则需要种植生产这种水果植物，即创建生产具体水果的工厂。

如下图：



苹果和香蕉的都实现水果接口类中的get()方法，负责生产苹果和香蕉的具体工厂实现水果这个抽象工厂接口。在工厂方法模式下如果想要生产新的水果，即创建新的类。比如生产梨子，需要新建一个梨子类实现水果类的get()方法，创建梨子工厂实现水果工厂来生产梨子。


接下来我们用代码来解释一下：

首先顶一个水果类：

Fruit(interface):
//水果类
public interface Fruit {
    public void get();
}

Apple类:
//苹果类
public class Apple implements Fruit{
    //实现并重写父类的get()方法
    public void get() {
        System.out.println("采集苹果");
    }
}

4.创建FruitFactory接口、AppleFactory类等
FruitFactory(interface):

public interface FruitFactory {
    public Fruit getFruit();
}

AppleFactory类:
public class AppleFactory implements FruitFactory {
    @Override
    public Fruit getFruit() {
        return new Apple();
    }
}

5.生产水果

MainClass:
public class MainClass {
    public static void main(String[] args){
        //创建苹果工厂
        FruitFactory appleFactory = new AppleFactory();
        //通过苹果工厂生产苹果实例
        Fruit apple = appleFactory.getFruit();
        apple.get();

    //创建香蕉工厂
    FruitFactory bananaFactory = new BananaFactory();
    //通过香蕉工厂生产香蕉实例
    Fruit banana = bananaFactory.getFruit();
    banana.get();
    
    //新添加的梨子工厂
    FruitFactory pearFactory = new PearFactory();
    Fruit pear = pearFactory.getFruit();
    pear.get();
}

}

　　这里用到Java面向对象的三大特性之一–多态。在新建工厂时，由FruitFactory接口指向具体的工厂(AppleFactory)。通过具体的工厂生产水果时，由Fruit接口指向具体的实例对象(Apple)。

1 简单工厂

根据参数由工厂类来创建对象

/**
 * 简单工厂
 * 目的：根据参数获取对象
 * 缺点：新增实现类时，需要修改代码，不好动态扩展（可参考工厂方法）
 */
public class SimpleFactoryDP {

    public final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
    }

    //抽象产品
    public interface Product {
        void show();
    }

    //具体产品：ProductA
    static class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }

    //具体产品：ProductB
    static class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    public static class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }

    void test(){
        Product product = SimpleFactory.makeProduct(1);
        product.show();
    }

}


2 工厂方法

解决简单工厂不能动态扩展实现类（开闭原则）

/**
 *  工厂方法
 *  单个工厂提供单个实现类，方便扩展更多实现类
 *  目的：优化简单工厂不好扩展新的类。这里只需要新增工厂类既能扩展
 *  缺点：有时需要工厂类能够同时提供多个不同对象（可参考抽象工厂）
 */
public class FactoryMethodDP {
    //抽象产品：提供了产品的接口
    interface Product {
        public void show();
    }
    //具体产品1：实现抽象产品中的抽象方法
    class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具体产品1显示...");
        }
    }
    //具体产品2：实现抽象产品中的抽象方法
    class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具体产品2显示...");
        }
    }

    //抽象工厂：提供了厂品的生成方法
    interface AbstractFactory {
        public Product newProduct();
    }
    //具体工厂1：实现了厂品的生成方法
    class ConcreteFactory1 implements AbstractFactory {
        public Product newProduct() {
            System.out.println("具体工厂1生成-->具体产品1...");
            return new ConcreteProduct1();
        }
    }
    //具体工厂2：实现了厂品的生成方法
    class ConcreteFactory2 implements AbstractFactory {
        public Product newProduct() {
            System.out.println("具体工厂2生成-->具体产品2...");
            return new ConcreteProduct2();
        }
    }

    void test() {
        AbstractFactory abstractFactory = new  ConcreteFactory1();
        abstractFactory.newProduct().show();
    }


}


3 抽象工厂

解决工厂方法 单个工厂不能同时创建多个不同的实现类

/**
 * 抽象工厂
 * 工厂可以产生多个不同对象，实现对象可以扩展，工厂类也可以动态组装
 */
public class AbstractFactoryDP {

    interface ProductA{
        void aEat();
    }
    class Aimpl1 implements ProductA{
        @Override
        public void aEat() {
            System.out.println("class is Aimpl1");
        }
    }
    class Aimpl2 implements ProductA{
        @Override
        public void aEat() {
            System.out.println("class is Aimpl2");
        }
    }

    interface ProductB{
        void bUse();
    }
    class Bimpl1 implements ProductB{
        @Override
        public void bUse() {
            System.out.println("class is Bimpl1");
        }
    }
    class Bimpl2 implements ProductB{
        @Override
        public void bUse() {
            System.out.println("class is Bimpl2");
        }
    }

    interface AbstractProductFactory{
        ProductA createA();
        ProductB createB();
    }

    class ProductFactoryImplA implements  AbstractProductFactory{
        @Override
        public ProductA createA() {
            return new Aimpl1();
        }
        @Override
        public ProductB createB() {
            return new Bimpl1();
        }
    }

    class ProductFactoryImplB implements  AbstractProductFactory{
        @Override
        public ProductA createA() {
            return new Aimpl2();
        }
        @Override
        public ProductB createB() {
            return new Bimpl2();
        }
    }

    void test(){
        AbstractProductFactory productFactory = new ProductFactoryImplA();
        ProductA productA = productFactory.createA();
        productA.aEat();
        ProductB productB = productFactory.createB();
        productB.bUse();
    }

}


 

1、定义


工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪个类
抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类


2、工厂方法与抽象工厂方法的区别





3、简单工厂方法、工厂方法以及抽象工厂方法的区别

这里以一个种菜的例子来说明：
刚开始，规模小，只种植一种根茎类蔬菜，所以采用简单工厂模式，在简单工厂模式下，考虑的是种植萝卜还是土豆





随着种植厂的发展以及市场的需求，需要增加一种叶子类型的蔬菜进行种植，由于根茎类和叶子类的种植方式不同，需要两个专门的种植工厂来管理，这时候就采用工厂模式，一个工厂负责一种作物的种植，这个时候产品可以理解为仍然在一个层次。在工厂模式下，考虑的是种植根茎类蔬菜还是叶子类蔬菜


但是随着科技的发展，我们逐步要种植转基因与非转基因食品了，在以前的蔬菜种类上又增加了一个层次，这个时候无法将其作为一个层次来解决，所以必须采用抽象工厂的方式来解决。在抽象工厂模式下，考虑的是种植转基因蔬菜还是非转基因蔬菜


具体选用哪种工厂模式，需要仔细分析产品的层次等级结构


Demo下载地址：http://download.csdn.net/detail/s003603u/9577132

模式简介

工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类：

1. 简单工厂模式(Simple Factory)

2. 工厂方法模式(Factory Method)

3. 抽象工厂模式(Abstract Factory)



工厂方法模式是对简单工厂模式的抽象升级，定义一个用于创建对象的接口，让子类决定实例哪个类。工厂方法使一个类实例化延迟到其子类。

与简单工厂模式相比，简单工厂模式使得工厂的负担过重，而且每次添加新产品，都需要修改工厂，不符合开闭原则。

工厂方法模式的重点就在这个工厂接口了。目标可以无限扩展，工厂类也要随之扩展，一对一存在，满足了开闭原则，但如果目标实现较多，工厂实现类也会增多，不简洁。

实际应用场景

MyBatis中使用的比较多，事务模块和数据源模块都使用了工厂方法模式。


UML类图



案例：汽车生产

Car

/**
 * @Author l'amour solitaire
 * @Description 汽车
 * @Date 2020/11/19 下午1:58
 **/
public interface Car {

    /**
     * 汽车品牌
     **/
    String carName();
}

BenzCar

/**
 * @Author l'amour solitaire
 * @Description 奔驰
 * @Date 2020/11/19 下午2:09
 **/
public class BenzCar implements Car {

    @Override
    public String carName() {
        return "Benz";
    }
}

BmwCar

/**
 * @Author l'amour solitaire
 * @Description 宝马
 * @Date 2020/11/19 下午2:09
 **/
public class BmwCar implements Car {

    @Override
    public String carName() {
        return "BMW";
    }
}

CarFactory

/**
 * @Author l'amour solitaire
 * @Description 汽车工厂
 * @Date 2020/11/19 下午2:02
 **/
public interface CarFactory {

    /**
     *
     **/
    Car createCar();
}

BeezCarFactory

/**
 * @Author l'amour solitaire
 * @Description 奔驰汽车工厂
 * @Date 2020/11/19 下午2:03
 **/
public class BeezCarFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new BenzCar();
    }
}

BmwCarFactory

/**
 * @Author l'amour solitaire
 * @Description 宝马汽车工厂
 * @Date 2020/11/19 下午2:03
 **/
public class BmwCarFactory implements CarFactory {
    
    @Override
    public Car createCar() {
        return new BmwCar();
    }
}

 

测试

@SpringBootTest
class DesignApplicationTests {

    @Test
    void test() {
        CarFactory carFactory = new BeezCarFactory();
        System.out.println(carFactory.createCar().carName());
        carFactory = new BmwCarFactory();
        System.out.println(carFactory.createCar().carName());
    }

}

 



欢迎关注公众号《JAVA拾贝》回复: 设计模式 即可获取