工厂模式（创建型）

工厂模式是用工厂方法代替new操作的一种模式。工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量（降低耦合）。
一、简单工厂模式
简单工厂模式包含如下三种角色：
抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
具体产品：实现或者继承抽象产品的子类。
具体工厂：提供了创建产品的方法，使用者通过该方法来获取产品。
实例
//抽象产品角色

public interface Produce {
    void doProduce();
}

//产品实例 1

public class SpicyChickenHamburg implements Produce{
    @Override
    public void doProduce() {
        System.out.println("offer SpicyChickenHamburg ");
    }
}

//产品实例 2 鸡腿堡

public class ChickenDrumsticksHamburg implements  Produce{
    public void doProduce() {
        System.out.println("do ChickenDrumsticksHamburg ");
    }
}

//工厂

public class MacDonaldHamburgFactory {
    public Produce getProduct(String productName) {
        if ("SpicyChickenHamburg".equals(productName)) {
            return new SpicyChickenHamburg();
        } else if ("ChickenDrumsticksHamburg".equals(productName)) {
            return new ChickenDrumsticksHamburg();
        } else {
            return null;
        }
    }
}

优点：客户端免除了直接创建产品对象的责任，而仅仅负责“消费”产品
缺点：每增加一样商品，简单工厂就需要修改相应的商业逻辑和判断逻辑，这显自然是违背开闭原则的。
在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以对于复杂的业务环境可能不太适应。
由此引出工厂方法模式。
二.工厂方法模式(扩展不属于23种设计模式)
角色分析
抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。

抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
实例如下：
//抽象产品角色

public interface Produce{

void doProduce();

}

//产品实例 1-1 麦辣鸡翅汉堡

public class SpicyChickenHamburg implements Produce{

	public void doProduce() {
	
	System.out.println(“offer SpicyChickenHamburg ”);

	}
}

//产品实例 1-2 鸡腿堡

public class ChickenDrumsticksHamburg  implements Produce{
    @Override
    public void doProduce() {
            System.out.println("do ChickenDrumsticksHamburg ");
    }
}

//产品实例 2-1 小杯可乐

public class SmallCola implements Produce{
	public void doProduce() {
	System.out.println(“do SmallCola ”);
	}
}

//产品实例 2-2 大杯可乐

public class BigCola implements Produce{
	public void doProduce() {
	System.out.println(“do BigCola ”);
	}
}

//抽象工厂角色

public interface MacDonaldFactory{
  Produce getProduct(String productName);
}

//汉堡包工厂

public class HamburgFactory implements MacDonaldFactory{
    @Override
    public Produce getProduct(String productName) {
        if ("SpicyChickenHamburg".equals(productName)) {
            return new SpicyChickenHamburg();
        } else if ("ChickenDrumsticksHamburg".equals(productName)) {
            return new ChickenDrumsticksHamburg();
        } else {
            return null;
        }
    }
}

//可乐工厂

public class ColaFactory implements MacDonaldFactory{
    @Override
    public Produce getProduct(String productName) {
       if("SmallCola".equals(productName)){
           return new SmallCola();
       }else if("BigCola".equals(productName)){
           return new BigCola();
       }else{
           return null;
       }
    }

缺点：每一个产品应一个工厂子类，在创建具体产品对象时，实例化不同的工厂子类。但是，如果业务涉及的子类越来越多，难道每一个子类都要对应一个工厂类吗？这样会使得系统中类的个数成倍增加，增加了代码的复杂度。
为了缩减工厂实现子类的数量，不必给每一个产品分配一个工厂类，可以将产品进行分组，每组中的不同产品由同一个工厂类的不同方法来创建。于是引入了抽象工厂模式

三. 抽象工厂模式

//抽象产品Cola

public interface Cola {
    void doProduce();
}

//具体产品SmallCola

public class SmallCola implements Cola{
    @Override
    public void doProduce() {
        System.out.println("do SmallCola ");
    }
}

//具体产品BigCola

public class BigCola implements Cola{
    @Override
    public void doProduce() {
        System.out.println("do BigCola ");
    }
}

//抽象产品Hamburg

public interface Hamburg {
    void doProduce();
}

//具体产品ChickenDrumsticksHamburg

public class ChickenDrumsticksHamburg implements Hamburg{
    @Override
    public void doProduce() {
        System.out.println("do ChickenDrumsticksHamburg ");
    }
}

//具体产品SpicyChickenHamburg

public class SpicyChickenHamburg implements Hamburg{
    @Override
    public void doProduce() {
        System.out.println("offer SpicyChickenHamburg ");
    }
}

//抽象工厂AbtractFactory

public interface AbtractFactory {
    Cola doCola();
    Hamburg doHamburg();
}

//大汉堡工厂BigColaHamburgFactory

public class BigColaHamburgFactory implements AbtractFactory{
    @Override
    public Cola doCola() {
        return new BigCola();
    }

    @Override
    public Hamburg doHamburg() {
        return new SpicyChickenHamburg();
    }
}

//小汉堡工厂SmallColaHamburgFactory

public class SmallColaHamburgFactory implements AbtractFactory{
    @Override
    public Cola doCola() {
        return new SmallCola();
    }

    @Override
    public Hamburg doHamburg() {
        return new ChickenDrumsticksHamburg();
    }
}

测试

public class Test {
    public static void main(String[] args) {
        AbtractFactory abtractFactory=new BigColaHamburgFactory();
        abtractFactory.doCola().doProduce();
        abtractFactory.doHamburg().doProduce();
        AbtractFactory abtractFactory1=new SmallColaHamburgFactory();
        abtractFactory1.doCola().doProduce();
        abtractFactory1.doHamburg().doProduce();
    }
}