工厂模式

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

工厂模式中包括简单工厂模式、工厂方法模式和抽象工厂模式。下面就用简单的例子对这几种模式进行简要说明。

一、简单工厂模式

简单工厂模式属于类的创建型模式，又叫做静态工厂方法模式（工厂中的方法可以为静态）。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都有共同的父类。接下来以生产手机的为例，对简单工厂模式简要说明。

1.创建手机接口Phone

/** 手机接口*/
public interface Phone {
     void create();
}

2.创建华为手机类Huawei并实现Phone接口，负责生产华为手机

/** 华为手机类*/
public class HuaWei implements Phone {
    @Override
    public void create() {
        System.out.println("生产一部华为手机");
    }
}

3.创建苹果手机类Iphone并实现Phone接口，负责生产苹果手机

/**苹果手机类*/
public class IPhone implements Phone {
    @Override
    public void create() {
        System.out.println("生产一部苹果手机");
    }
}

4.创建手机工厂PhoneFactory，负责生产手机

/** 手机工厂类 */
public class PhoneFactory {
    public static Phone getPhone(String type){
        if (type.equals("iphone")) {
//            return IPhone.class.newInstance();
            return  new IPhone();

        }else if(type.equals("huawei")){
//            return  HuaWei.class.newInstance();
            return new HuaWei();
        }else{
            return  null;
        }
    }
}

 5.对简单工厂模式测试

public class testSimpleFactory {
    public static void main(String[] args) {
        Phone iphone= PhoneFactory.getPhone("iphone");
        Phone huawei=PhoneFactory.getPhone("huawei");
        iphone.create();
        huawei.create();
    }
}

生产一部苹果手机
生产一部华为手机

 对应的UML类图如下

 总结：

（一）简单工厂模式中包含的角色和职责：

①工厂角色（PhoneFactory):简单工厂模式的核心，它负责创建所有实例的 内部逻辑。工厂类可以直接被外界调用，创建各自所需要的对象。

②抽象角色（Phone）:简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

③具体产品角色（Iphone、Huawei）：简单工厂模式所创建的具体实例对象。

（二）简单工厂模式的优缺点：

在这个模式中工厂类是整个模式的关键所在。它包含必要的判断逻辑，能够根据外界给定的信息，究竟应该创建哪个具体类的对象。用户在使用时可以根据工厂类直接去创建所需要的实例，而无需了解这些对象是如何创建和如何组织的。有利于整个软件体系的优化。不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有对象的创建逻辑，所以无法很好的体现“高内聚”。另外，当系统中的产品不断增多时，需要对工厂类也要做相应的修改，扩展性不好。不能很好的体现“开放-关闭”原则。

二、工厂方法模式

 工厂方法模式同样属于类的创建型模式又被称为多态工厂模式。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际的创建工作推迟到 子类当中。核心工厂类不在负责产品的创建，这样核心类 成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是是的工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。 

在简单工厂模式的基础上，若在来一款新的产品小米手机，Phone、Huawei、Iphone三个类均不需要做改变，新增小米手机的类及其工厂，以下作简要说明。

1.创建小米手机类（XiaoMi），并实现Phone接口

/** 小米手机类 */
public class XiaoMi implements Phone {
    @Override
    public void create() {
        System.out.println("生产一部小米手机");
    }
}

     2.创建工厂接口PhoneFactory，负责创建不同产品

/** 抽象手机工厂 */
public interface PhoneFactory {
    public Phone createPhone();
}

 3.创建三个具体工厂类IphoneFactory、HuaweiFactory、XiaoMiFactory并实现PoneFactory接口，分别单独负责创建华为手机、苹果手机、小米手机

/** 华为手机工厂类 */
public class HuaWeiFactory implements  PhoneFactory{

    @Override
    public  Phone createPhone() {
        return new HuaWei();
    }
}

/** 苹果手机工厂类 */
public class IPhoneFactory implements PhoneFactory {
    @Override
    public Phone createPhone() {
        return new IPhone();

    }
}
 
/** 小米手机工厂类 */
public class XiaoMiFactory implements  PhoneFactory{
    @Override
    public  Phone createPhone() {
        return new XiaoMi();
    }
}

  4.工厂方法模式测试

public class testFactoryMethod {
    public static void main(String[] args) {
        PhoneFactory huaWeiFactory = new HuaWeiFactory();
        huaWeiFactory.createPhone().create();
        PhoneFactory iPhoneFactory = new IPhoneFactory();
        iPhoneFactory.createPhone().create();
        PhoneFactory xiaomiFactory=new XiaoMiFactory();
        xiaomiFactory.createPhone().create();
    }
}

生产一部华为手机
生产一部苹果手机
生产一部小米手机

 对应的UML类图如下图所示

 总结

（一）工厂方法模式中包含的角色和职责

①抽象工厂角色（PhoneFactory）：抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口

②具体工厂角色（IPhoneFatory、HuaweiFactory、XiaoMiFactory）：具体工厂类是抽象工厂的实现，负责实例化产品对象

③抽象角色（Phone）：工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口

④具体产品角色（Huawei、Iphone、XiaoMI）：工厂方法模式所创建的具体实例对象

（二）工厂方法模式的应用场景

①客户只知道创建产品的工厂名，而不知道具体的产品名。如 华为手机工厂、苹果手机工厂等

②创建对象的任务由多个具体子工厂中的某一个完成，而抽象工厂只提供创建产品的接口

③客户不关心创建产品的细节，只关心产品的品牌

（三）工厂方法模式和简单工厂模式的比较

①工厂方法模式与简单工厂模式在结构上的的不同不是很明显。工厂方法的核心是一个抽象工厂类。而简单工厂模式把核心放在一个具体类上。

②工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂都有共同的接口，或者有共同的抽象父类。

③当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有的工厂对象不需要进行任何的修改，也不需要修改客户端，很好的符合了“开放-关闭”原则。而简单工厂模式在添加新的产品对象后不得不修改工厂方法，扩张性不好。

④工厂方法模式退化后可以演变成简单工厂模式。

 三、抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品类型的情况下，能够创建多个产品族的产品对象。抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

在上面的手机例子中，都是涉及到的手机（Phone）产品，此时若有新来的产品手表（后续可能还会有更多的产品），（假如）新产品的生产厂商也是上面所涉及的华为、小米、苹果等。那么此时就可以考虑使用抽象工厂模式，将所有的在产品抽象为接口，当有新产品时，只需要修改抽象类

1.创建手表抽象类（Watch）

/** 手表接口 */
public abstract class Watch {
    public abstract void createWatch();
}

2.分别创建华为手表类（HuaweiWatch）、小米手表类（Xiaomiatch），并继承手表抽象类

/** 华为手表类 */
public class HuaWeiWatch extends Watch {
    @Override
    public void createWatch() {
            System.out.println("生产一部华为手表");
    }
}

/** 小米手表类 */
public class XiaoMiWatch extends Watch {
    @Override
    public void createWatch() {
        System.out.println("生产一部小米手表");
    }
}

3.创建顶层的抽象工厂（AbsractFactory），负责生产不同的产品

/** 抽象工厂 */
public abstract class AbstractFactory {
    public abstract Phone getPhone();

    public abstract  Watch getWatch();
}

4.创建具体工厂类（HuaweiFactory、XiaomiFactory），负责生产具体的产品

/** 华为工厂类 */
public  class HuaweiFactory extends  AbstractFactory {
    @Override
    public  Phone getPhone(){
        return  new HuaWeiPhone();
    }
    @Override
    public Watch getWatch() {
        return new HuaWeiWatch();
    }
}

/** 小米工厂类 */
public  class XiaoMiFactory extends  AbstractFactory {
    @Override
    public  Phone getPhone(){
        return  new XiaoMiPhone();
    }
    @Override
    public Watch getWatch() {
        return new XiaoMiWatch();
    }
}

5.测试抽象工厂模式 

public class testAbstractFactory {
    public static void main(String[] args) {
        AbstractFactory huawei=new HuaweiFactory();
        huawei.getPhone().createPhone();
       huawei.getWatch().createWatch();

        AbstractFactory xiaomi=new XiaoMiFactory();
        xiaomi.getPhone().createPhone();
        xiaomi.getWatch().createWatch();
    }
}

生产一部华为手机
生产一部华为手表
生产一部小米手机
生产一部小米手表

对应的UML类图如下图所示

总结

（一）抽象工厂模式中的角色和职责

①抽象工厂角色（AbstractFactory）：抽象工厂模式对的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。

②具体工厂角色（HuaweiFactory、XiaomiFactory）：具体工厂类是抽象工厂的一个实现，负责实例化某个 产品族中的  产品对象。

③抽象角色（Phone、Watch）：抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

④具体产品角色（HuaweiPhone、XiaomiWatch）:抽象模式所创建的具体实例对象 。

（二）抽象工厂模式的应用场景

①当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。

②系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。

③系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。

（三）抽象工厂模式的优缺点

当增加一个新的产品族时只需增加一个新的具体工厂，不需要修改原代码，满足开闭原则。但是当产品族中需要增加一个新种类的产品时，则所有的工厂类都需要进行修改，不满足开闭原则。

 

写在最后：以上代码可能没有贴全，已上传github，地址：https://github.com/sherwin8/design-pattern，后续代码会陆续更新