java 工厂模式

工厂模式简介

工厂模式（Factory Pattern）是Java中最常用的设计模式之一，它属于创建型模式，提供了一种创建对象的最佳方式，使得客户从具体的产品对象中被解耦。
工厂模式可以将对象的创建与使用代码分离开，这样创建对象时候的就不会对客户端暴露创建逻辑，并且是通过一个共同的接口来指向新创建的对象。

核心本质：

实例化对象不使用new，用工厂方法创建对象
使用工厂统一管理对象的创建，将调用者跟实现类解耦

三种工厂模式

1.简单工厂模式

工厂模式就是使用工厂去创建需要的对象，简单工厂模式就是使用一个工厂类去创建实现了同一个接口的对象，这样只用调用这个工厂类就可以实现不同的对象创建。

1、首先创建一个接口：（相当于是一个抽象的产品，作为产品的共同接口，里面有产品共同的方法）

public interface Phone {
    void brand();
}

2、然后用不同的类实现这个接口：（相当于具体的产品，在该类里面定义了具体产品的特定行为以及属性）

class IPhone implements Phone{

    @Override
    public void brand() {
        System.out.println("红色的手机");
    }
}

class MPhone implements Phone{
    
    @Override
    public void brand() {
        System.out.println("银白色的手机");
    }
}

3、创建一个工厂类，在这个工厂类里面可以创建出不同的产品出来：

class Factory{
    public static Phone getPhone(String type){
        if(type.equals("iph")){
            return new IPhone();
        }else if(type.equals("mph")){
            return new MPhone();
        }else{
            return null;
        }
    }
}

4、测试 使用工厂类，通过传递不同的信息来获取实体类的对象。

 public static void main(String[] args) {
        Phone phone1= Factory.getPhone("iph");
        Phone phone2=Factory.getPhone("mph");
        phone1.brand();
        phone2.brand();
    }

输出：

红色的手机
银白色的手机

总结： 简单工厂模式还存在很多缺点，对象的创建是由工厂类来具体实现的，如果想要扩展程序，必须去修改工厂类，这违反了设计模式的开闭原则。

2.普通工厂模式

普通工厂模式是在简单工厂模式上的改进，将工厂类也拆分成抽象工厂与具体工厂类，每个具体的工厂类只实现一个具体的产品类实例。

UML图如下：

工厂接口：（抽象工厂，里面有创建产品的方法，但是还需要不同的类去具体地实现）

public interface Factory {
    Phone getPhone();
}

具体工厂实现，在各自的工厂中生产各自的产品：

class IPhoneFactory implements Factory {
    public Phone getPhone(){
        return new IPhone();
    }
}
class MPhoneFactory implements Factory {
    public Phone getPhone(){
        return new MPhone();
    }
}

使用具体的工厂去生产具体的产品：

public static void main(String[] args) {
        Factory factory=new IPhoneFactory();
        Factory factory1=new MPhoneFactory();

        Phone phone1= factory.getPhone();
        Phone phone2=factory1.getPhone();
        phone1.brand();
        phone2.brand();
    }

使用工厂模式只需要创建不同的工厂对象，每个具体的工厂去生产一个对应的具体的产品，若是想要扩展程序，比如想要生产一个新的产品，只需要再创建一个实现这个产品的工厂类，而不需要修改原来的代码，满足了开闭原则，使程序的扩展性能更好。

3.抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式中有一个产品族的概念，产品族是指位于不同产品等级结构中功能相关联的产品组成的家族。抽象工厂模式所提供的一系列产品组成一个产品族，而工厂方法提供的一系列产品称为一个等级结构。

对于上述代码中生产手机的例子来说，工厂类是用来生产手机的。但是在日常中的情况往往会更加复杂一些，手机的生产有很多厂家，而每个手机的生产厂家可能也会生产除了手机以外的其他产品。
比如华为生产的所有产品，手机，电脑等称为华为的产品族；华为手机，小米手机等各种手机称为一个产品等级。

在工厂模式中，一个工厂创建一个产品，一个具体工厂对应一个具体产品，但有时候我们需要一个工厂能够提供多个产品对象，而不是单一的对象，这个时候我们就需要使用抽象工厂模式。

抽象工厂模式会围绕一个超级工厂创建其他工厂，每个工厂生产不同类型的产品。

一个华为公司和小米公司生产手机和电脑的例子：

UML图：

1、创建超级工厂接口：（抽象工厂）

public interface SuperFactory {
    //生产手机
    Phone getPhone();
    //生产笔记本电脑
    Pc getPc();
}

2、创建手机接口和电脑接口：（抽象产品）

public interface Phone {
    void brand();
}

public interface Pc {
    void brandPc();
}

3、分别实现手机接口和电脑接口：（具体产品）

//实现手机接口 实现华为手机
class IPhone implements Phone{

    @Override
    public void brand() {
        System.out.println("华为手机");
    }
}

//实现手机接口 实现小米手机
class MPhone implements Phone{

    @Override
    public void brand() {
        System.out.println("小米手机");
    }
}

//实现PC接口 实现华为笔记本电脑
class IPc implements Pc{

    @Override
    public void brandPc() {
        System.out.println("华为笔记本");
    }
}

//实现PC接口 实现小米笔记本电脑
class MPc implements Pc{

    @Override
    public void brandPc() {
        System.out.println("小米笔记本");
    }
}

4、实现超级工厂接口，创建华为工厂和小米工厂，在华为工厂中生产华为产品，在小米工厂中实现小米产品。（具体工厂）

//华为工厂实现
class IFactory implements SuperFactory{

    @Override
    public Phone getPhone() {
        return new IPhone();  //生产华为手机
    }

    @Override
    public Pc getPc() {
        return new IPc(); //生产华为电脑
    }
}

//小米工厂实现
class MFactory implements SuperFactory{

    @Override
    public Phone getPhone() {
        return new MPhone();  //生产小米手机
    }

    @Override
    public Pc getPc() {
        return new MPc();  //生产小米电脑
    }
}

5、测试，创建各自的工厂，并生产产品：

public static void main(String[] args) {
        System.out.println("华为工厂生产开始：");
        SuperFactory iFactory=new IFactory(); //创建华为工厂
        iFactory.getPhone().brand();  //生产华为手机
        iFactory.getPc().brandPc();  //生产华为电脑

        System.out.println("小米工厂生产开始：");
        SuperFactory mFactory=new MFactory();  //创建小米工厂
        mFactory.getPhone().brand();  //生产小米手机
        mFactory.getPc().brandPc();  //生产小米电脑
    }

输出：

总结： 我们可以这样来理解，产品族就是横向的某个品牌的一系列产品，而产品等级就是纵向的各种品牌的某种产品。
抽象工厂模式比工厂模式多了产品族这个概念，同时也就是多了一个维度，抽象工厂模式下的工厂可以对产品族也具有扩展性，当市场上出现了一个新的厂家生产手机和电脑的时候，我们只用添加一个新的工厂实现类就可以解决问题，满足开闭原则。
但同时也具有一些缺点，当产品族中需要添加一个新的产品时，所有的工厂类都需要进行修改，增加了系统的抽象性和理解难度。

使用抽象工厂模式一般要满足以下条件。

• 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
• 系统一次只可能消费其中某一族产品，即同族的产品一起使用。