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)。

 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。 在这些情况,新对象的建立就是一个 “过程”，不仅是一个操作，像一部大机器中的一个齿轮传动。

 

模式的问题：你如何能轻松方便地构造对象实例，而不必关心构造对象实例的细节和复杂过程呢？

解决方案：建立一个工厂来创建对象

实现：

一、引言

    1）还没有工厂时代：假如还没有工业革命，如果一个客户要一款宝马车,一般的做法是客户去创建一款宝马车，然后拿来用。

    2）简单工厂模式：后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车，这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。

    3）工厂方法模式时代：为了满足客户，宝马车系列越来越多，如320i，523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。

   4）抽象工厂模式时代：随着客户的要求越来越高，宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。

   最终是客户只要对宝马的销售员说：我要523i空调车，销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车.

   这就是工厂模式。

二、分类 

        工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 

工厂模式可以分为三类： 

1）简单工厂模式（Simple Factory） 

2）工厂方法模式（Factory Method） 

3）抽象工厂模式（Abstract Factory） 

 这三种模式从上到下逐步抽象，并且更具一般性。 

        GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。

        将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。 

三、区别 

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。   

一个抽象工厂类，可以派生出多个具体工厂类。   

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。   

一个抽象工厂类，可以派生出多个具体工厂类。   

每个具体工厂类可以创建多个具体产品类的实例。   

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。   

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

两者皆可。 

 四、简单工厂模式 

建立一个工厂（一个函数或一个类方法）来制造新的对象。

分布说明引子：从无到有。客户自己创建宝马车，然后拿来用。

 

 

public class BMW320 {
	public BMW320(){
		System.out.println("制造-->BMW320");
	}
}

public class BMW523 {
	public BMW523(){
		System.out.println("制造-->BMW523");
	}
}

public class Customer {
	public static void main(String[] args) {
		BMW320 bmw320 = new BMW320();
		BMW523 bmw523 = new BMW523();
	}
}


客户需要知道怎么去创建一款车,客户和车就紧密耦合在一起了.为了降低耦合,就出现了工厂类,把创建宝马的操作细节都放到了工厂里面去,客户直接使用工厂的创建工厂方法,传入想要的宝马车型号就行了,而不必去知道创建的细节.这就是工业革命了：简单工厂模式

即我们建立一个工厂类方法来制造新的对象。如图：



产品类：

abstract class BMW {
	public BMW(){
		
	}
}

public class BMW320 extends BMW {
	public BMW320() {
		System.out.println("制造-->BMW320");
	}
}
public class BMW523 extends BMW{
	public BMW523(){
		System.out.println("制造-->BMW523");
	}
}


工厂类：

public class Factory {
	public BMW createBMW(int type) {
		switch (type) {
		
		case 320:
			return new BMW320();

		case 523:
			return new BMW523();

		default:
			break;
		}
		return null;
	}
}



客户类：

public class Customer {
	public static void main(String[] args) {
		Factory factory = new Factory();
		BMW bmw320 = factory.createBMW(320);
		BMW bmw523 = factory.createBMW(523);
	}
}


   简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。 

      先来看看它的组成： 

         1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品

         2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。         

         3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。 

        

        下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。当客户不再满足现有的车型号的时候，想要一种速度快的新型车，只要这种车符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createBMW(int type)方法需要新增case），这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。 

        我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。

        于是工厂方法模式作为救世主出现了。 工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。
五、工厂方法模式 

        工厂方法模式去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。这样在简单工厂模式里集中在工厂方法上的压力可以由工厂方法模式里不同的工厂子类来分担。 

工厂方法模式组成： 

       1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 

       2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 

       3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 

       4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 

       工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有 的代码。可以看出工厂角色的结构也是符合开闭原则的！ 

代码如下： 

产品类：

abstract class BMW {
	public BMW(){
		
	}
}
public class BMW320 extends BMW {
	public BMW320() {
		System.out.println("制造-->BMW320");
	}
}
public class BMW523 extends BMW{
	public BMW523(){
		System.out.println("制造-->BMW523");
	}
}



创建工厂类：

interface FactoryBMW {
	BMW createBMW();
}

public class FactoryBMW320 implements FactoryBMW{

	@Override
	public BMW320 createBMW() {

		return new BMW320();
	}

}
public class FactoryBMW523 implements FactoryBMW {
	@Override
	public BMW523 createBMW() {

		return new BMW523();
	}
}




客户类：

public class Customer {
	public static void main(String[] args) {
		FactoryBMW320 factoryBMW320 = new FactoryBMW320();
		BMW320 bmw320 = factoryBMW320.createBMW();

		FactoryBMW523 factoryBMW523 = new FactoryBMW523();
		BMW523 bmw523 = factoryBMW523.createBMW();
	}
}



 工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。

参考http://blog.csdn.net/hguisu/article/details/7505909

 

以上就是简单工厂模式，工厂方法模式，抽象工厂模式在这里。

 

更多设计模式：23种设计模式系列



作者：jason0539

博客：http://blog.csdn.net/jason0539（转载请说明出处）

 

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

}


 

模式简介

工厂模式主要是为创建对象提供了接口。工厂模式按照《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拾贝》回复: 设计模式 即可获取