设计模式 --- 工厂模式原理及使用场景（含代码）

目录

1.什么是工厂模式

2.三种工厂模式的应用场景和利弊

①、简单工厂模式(又叫静态工厂模式)

②、工厂方法模式

③、抽象工厂模式

---

1.什么是工厂模式

工厂模式提供了一种将对象的实例化过程封装在工厂类中的方式。通过使用工厂模式，可以将对象的创建与使用代码分离，提供一种统一的接口来创建不同类型的对象。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

2.三种工厂模式的应用场景和利弊

工厂模式分为简单工厂模式、工厂方法模式和抽象工厂模式

①、简单工厂模式(又叫静态工厂模式)

• 定义：是由一个工厂对象决定创建出哪一种产品类的实例。
• 简单工厂模式三个角色：
  • 对象工厂（Factory）
  • 要生产的对象的接口（AbstractProduct）
  • 要生产的对象（Product1,Product2）
• 核心思想：简单工厂模式中你不需要关心产品是怎么生产出来的，里面所需的零件又是怎么制造的，这些都交给工厂去处理，你只需要买产品就好了
• UML
• 具体实现（手机生产）

//手机规范标准类         

public interface Phone {
    void make();
}

 //小米手机

public class MiPhone implements Phone {
    public MiPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi phone!");
    }
}

//苹果手机
public class IPhone implements Phone {
    public IPhone() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make iphone!");
    }
} 

//手机代工厂
public class PhoneFactory {
    public Phone makePhone(String phoneType) {
        if(phoneType.equalsIgnoreCase("MiPhone")){
            return new MiPhone();
        }
        else if(phoneType.equalsIgnoreCase("iPhone")) {
            return new IPhone();
        }
        return null;
    }
}

//实现
public class Demo {
    public static void main(String[] arg) {
        PhoneFactory factory = new PhoneFactory();
        Phone miPhone = factory.makePhone("MiPhone");            // make xiaomi phone!
        IPhone iPhone = (IPhone)factory.makePhone("iPhone");    // make iphone!
    }
}

②、工厂方法模式

• 定义：定义一个用于创建对象的接口，让子类决定实例化哪个类。和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂

• 核心思想：讨论的仍然是如何构建同一类型产品（都实现同一个接口）的问题，只不过是通过为每一种要生产的产品配备一个工厂，就是说每个工厂只生产一种特定的产品。这样做的好处就是当以后需要增加新的产品时，直接新增加一个对应的工厂就可以了，而不是去修改原有的工厂，符合编程原则的开闭原则。

  工厂方法模式为每一种产品生成一个对应的工厂，从而替换掉简单工厂方法模式中那个静态工厂方法。

• UML
• 具体实现

 //生产不同产品的工厂的抽象类

public interface AbstractFactory {
    Phone makePhone();
}

 //生产小米手机的工厂（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

 //生产苹果手机的工厂（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

 //实现

public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        appleFactory.makePhone();        // make iphone!
    }
}

③、抽象工厂模式

• 定义：抽象工厂为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定他们的具体类
• 核心思想：抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干。
• UML
• 具体实现

 //定义PC产品的接口(AbstractPC)

public interface PC {
    void make();
}

 //MiPC类：定义小米电脑产品(MIPC)

public class MiPC implements PC {
    public MiPC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make xiaomi PC!");
    }
}

 //MAC类：定义苹果电脑产品(MAC)

public class MAC implements PC {
    public MAC() {
        this.make();
    }
    @Override
    public void make() {
        // TODO Auto-generated method stub
        System.out.println("make MAC!");
    }
}

修改工厂相关的类 

 //AbstractFactory类：增加PC产品制造接口

public interface AbstractFactory {
    Phone makePhone();
    PC makePC();
}

 //XiaoMiFactory类：增加小米PC的制造（ConcreteFactory1）

public class XiaoMiFactory implements AbstractFactory{
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
    @Override
    public PC makePC() {
        return new MiPC();
    }
}

 //AppleFactory类：增加苹果PC的制造（ConcreteFactory2）

public class AppleFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
    @Override
    public PC makePC() {
        return new MAC();
    }
}

//实现
public class Demo {
    public static void main(String[] arg) {
        AbstractFactory miFactory = new XiaoMiFactory();
        AbstractFactory appleFactory = new AppleFactory();
        miFactory.makePhone();            // make xiaomi phone!
        miFactory.makePC();                // make xiaomi PC!
        appleFactory.makePhone();        // make iphone!
        appleFactory.makePC();            // make MAC!
    }
}