设计模式1-工厂模式

第一章 设计模式入门之工厂模式的使用

工厂模式可以分为三类：
简单工厂模式（Simple Factory）
工厂方法模式（Factory Method）
抽象工厂模式（Abstract Factory）
注：简单工厂不属于23种设计模式里

---

---

前言

创建型模式：创建型模式(Creational Pattern)对类的实例化过程进行了抽象，能够将软件模块中对象的创建和对象的使用分离。为了使软件的结构更加清晰，外界对于这些对象只需要知道它们共同的接口，而不清楚其具体的实现细节，使整个系统的设计更加符合单一职责原则。创建型模式在创建什么(What)，由谁创建(Who)，何时创建(When)等方面都为软件设计者提供了尽可能大的灵活性。创建型模式隐藏了类的实例的创建细节，通过隐藏对象如何被创建和组合在一起达到使整个系统独立的目的。工厂模式是创建型模式中比较重要的。工厂模式的主要功能就是帮助我们实例化对象。之所以名字中包含工厂模式四个字，是因为对象的实例化过程是通过工厂实现的，是用工厂代替new操作的。

一、简单工厂模式

使用手机产品类讲解

1. Phone类，手机产品类

public interface Phone {
    void make();
}

2. MiPhone类，生产小米手机

public class MiPhone implements Phone{
    @Override
    public void make() {
        System.out.println("生产小米手机");
    }
}

3. IPhone类，生产苹果手机

public class IPhone implements Phone{
    @Override
    public void make() {
        System.out.println("生产苹果手机");
    }
}

4. PhoneFactory 类，手机工厂类，负责加工各种手机

public class PhoneFactory {

    public static Phone make(String name){
        if("Mi".equals(name)){
            return new MiPhone();
        }else if("IPhone".equals(name)){
            return new IPhone();
        }
        return null;
    }

}

5. 简单调用

public class DemoTest {

    public static void main(String[] args) {
        System.out.println("----------------------简单工厂------------------------------------");
        Phone mi = PhoneFactory.make("Mi");
        mi.make();
        Phone iPhone = PhoneFactory.make("IPhone");
        iPhone.make();
        }

工厂模式的角色：

1. 工厂角色 ：如PhoneFactory ，负责生产具体的对象；
2. 抽象产品：如Phone，描述所有实例的公共接口；
3. 具体产品：如Iphone和MiPhone,实现抽象产品的接口，是工厂角色中要创建的具体实例。
   优点：使用简单工厂的客户端只需传入对应的参数，不需要关心创建对象的逻辑。
   缺点：违反了“开闭原则”，及对扩展开放，修改关闭，如果增加新的产品需要修改工厂代码。

---

二、工厂方法模式

1. Factory接口，工厂接口

public interface Factory {
    Phone  make();
}

2. IPhoneFactory类，苹果手机工厂类

public class IPhoneFactory implements Factory{
    @Override
    public Phone make() {
        return new IPhone();
    } 
}

3. MiPhoneFactory类，小米手机类

public class MiPhoneFactory implements Factory{
    @Override
    public Phone make() {
        return new MiPhone();
    }
 }

4. 测试

public class DemoTest {

    public static void main(String[] args) {
        System.out.println("----------------------工厂方法------------------------------------");
        IPhoneFactory iPhoneFactory = new IPhoneFactory();
        iPhoneFactory.make().make();
        MiPhoneFactory miPhoneFactory = new MiPhoneFactory();
        miPhoneFactory.make().make();
        }
        }

工厂方法模式而言，是通过扩展来新增具体类的，符合开闭原则，但是在客户端就必须要感知到具体的工厂类，也就是将判断逻辑由简单工厂的工厂类挪到客户端。
使用场景：日志记录器；数据库访问；

---

三、抽象方法模式

场景分析：工厂方法中，每个工厂只负责生产某一类产品，如果增加新的产品将会增加大量的工厂类，这时候考虑到将相关的产品组成一个产品族，由一个工厂统一生产。

1. 抽象产品

public interface Pc {
    void make();
}
public interface Phone {
    void make();
}

2. 具体产品

public class IPhone implements Phone{
    @Override
    public void make() {
        System.out.println("生产苹果手机");
    }
}
public class MiPhone implements Phone{
    @Override
    public void make() {
        System.out.println("生产小米手机");
    }
}

public class Mac implements Pc{
    @Override
    public void make() {
        System.out.println("生产苹果平板");
    }
}
public class MiPc implements Pc{
    @Override
    public void make() {
        System.out.println("生产小米pc");
    }
}

3. 抽象工厂

public interface Factory {
    Phone  make();
    Pc  makePc();
}

4. 具体工厂

public class IPhoneFactory implements Factory{
    @Override
    public Phone make() {
        return new IPhone();
    }

    @Override
    public Pc makePc() {
        return new Mac();
    }
}


public class MiPhoneFactory implements Factory{
    @Override
    public Phone make() {
        return new MiPhone();
    }
    @Override
    public Pc makePc() {
        return new MiPc();
    }
}

5. 测试

public class DemoTest {

    public static void main(String[] args) {
        System.out.println("----------------------抽象工厂------------------------------------");
        IPhoneFactory iPhoneFactory1 = new IPhoneFactory();
        iPhoneFactory1.make().make();
        iPhoneFactory1.makePc().make();
        MiPhoneFactory miPhoneFactory1 = new MiPhoneFactory();
        miPhoneFactory1.make().make();
        miPhoneFactory1.makePc().make();
    }
}

在抽象工厂模式中，增加新的产品族很方便，但是增加新的产品等级结构很麻烦

总结

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

抽象工厂模式：
多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类，可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例，也就是创建的是一个产品线下的多个产品。

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