工厂模式

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

简单工厂模式中包含的角色及其相应的职责如下：

• 工厂角色（Creator）：这是简单工厂模式的核心，由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用，创建所需要的产品对象。
• 抽象（Product）产品角色：简单工厂模式所创建的所有对象的父类，注意，这里的父类可以是接口也可以是抽象类，它负责描述所有实例所共有的公共接口。
• 具体产品（Concrete Product）角色：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。

我的理解:
简单工厂模式就是有一个专门的类来负责实例的创建
把要生产的产品看着一系列的类 ,这些类全部实现一个接口,而工厂则生产满足条件的产品

一个例子
今天正好是七夕节,今天一个男生请众多女生吃饭,但是男孩子不会做饭或者是做饭不好吃,这就是不要自己去动手来获得食物,各美女了也有不同的爱好,于是男孩干脆就去餐厅去,从女生想吃什么就点什么,而餐厅就是生产食物的工厂,还也不要男孩子动手,也请了众多女生吃饭了,而男孩子所要做的就是买单,这就相当于是简单的工厂模式,今天祝大家和自己的女朋友过的愉快!虽然都说程序猿没有女朋友!

下面则简单工厂模式的列子:
1,创建一个食物的接口

public interface Food {
    /**
     * 获得相应的食物
     */
    public void get();
}

2.创建具体食物的类

/**
 * Created by yyt on 2016-08-09.
 * 薯条
 */
public class Chips implements Food {
    @Override
    public void get() {
        System.out.println("获得到一份薯条");
    }
}
//鸡块
public class McChicken implements Food{
    @Override
    public void get() {
        System.out.println("获得到一份鸡块");
    }
}

3.创建一个工厂类,专门生产食物

public class SimpleFactory {
    public static Food getFood(String type) throws IllegalAccessException, InstantiationException {
        if(type.equals("McChicken")){
            return  McChicken.class.newInstance();
        }else if(type.equals("Chips")){
            return  Chips.class.newInstance();
        }else{
            System.out.println("找不到相应的产品");
            return null;
        }
    }
}

4.测试简单工厂模式类

public class SimpleFactoryTest {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {

        Food mcChicken=SimpleFactory.getFood("McChicken");
        Food chips=SimpleFactory.getFood("Chips");
        Food egg=SimpleFactory.getFood("egg");

        if(mcChicken!=null){
            mcChicken.get();
        }
        if(chips!=null){
            chips.get();
        }
        if(egg!=null){
            egg.get();
        }
    }
}

5.打印结果

简单工厂模式的优缺点:

• 优点:工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的职责和权利，有利于整个软件体系结构的优化。

• 缺点:由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求．这种对条件的判断和对具体产品类型的判断交错在一起，很难避免模块功能的蔓延，对系统的维护和扩展非常不利；

多个工厂方法模式

是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。其他的抽象类和具体类不变!

public class SimpleFactory2 {
    /**
     * 获得鸡块
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public  Food getMcChicken() throws IllegalAccessException, InstantiationException {
        return McChicken.class.newInstance();
    }

    /**
     * 获得薯条
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public Food getChips() throws IllegalAccessException, InstantiationException {
        return Chips.class.newInstance();
    }
}
//测试方法
public class SimpleFactory2Test {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {

        SimpleFactory2 simpleFactory2=new SimpleFactory2();
        Food mcChicken=simpleFactory2.getMcChicken();
        Food chips=simpleFactory2.getChips();
        if(mcChicken!=null){
            mcChicken.get();
        }
        if(chips!=null){
            chips.get();
        }
    }
}

打印的结果:

静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

更改代码处

public class SimpleFactory2 {
    /**
     * 获得鸡块
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static  Food getMcChicken() throws IllegalAccessException, InstantiationException {
        return McChicken.class.newInstance();
    }

    /**
     * 获得薯条
     * @return
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    public static Food getChips() throws IllegalAccessException, InstantiationException {
        return Chips.class.newInstance();
    }
}
//测试方法
public class SimpleFactory2Test {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        Food mcChicken=SimpleFactory2.getMcChicken();
        Food chips=SimpleFactory2.getChips();
        if(mcChicken!=null){
            mcChicken.get();
        }
        if(chips!=null){
            chips.get();
        }
    }
}

打印结果和上面是一样的,总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

抽象工厂模式（Abstract Factory）
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解.

代码例子

//抽象工厂类
public interface InterFaceFactory {
    public Food getFood();
}
//两个实现工厂类
public class ChipsFactory implements InterFaceFactory {
    @Override
    public Food getFood() {
        return new Chips();
    }
}
public class McChickenFactory implements InterFaceFactory {
    @Override
    public Food getFood() {
        return new McChicken();
    }
}
//产品接口
public interface Food {
    public void get();
}
//产品实现类
public class Chips implements Food {
    @Override
    public void get() {
        System.out.println("获得一份薯条");
    }
}

public class McChicken implements Food {
    @Override
    public void get() {
        System.out.println("获得一份鸡块");
    }
}

//测试

public class Test {
    public static void main(String[] args) {
        InterFaceFactory mcChickenFactory=new McChickenFactory();
        Food mcChicken= mcChickenFactory.get();
        if(mcChicken!=null){
            mcChicken.get();
        }

        InterFaceFactory chipsFactory=new ChipsFactory();
        Food chips=chipsFactory.get();
        if(chips!=null){
            chips.get();
        }
    }

}

打印结果

其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好！