1.简介

工厂模式（Factory Pattern）：是日常开发中非常常用的一种设计模式，属于创建型模式。在Java编程中使用new关键字来实例化一个对象。但是这就带来一个问题，一个对象在创建时候，可能要为这个对象配置辅助的功能，然后经过一系列的步骤，才能真正创建完成，而我们在调用时候并不关心它是如何配置，仅仅只需要这个对象就而已，工厂模式为对象创建提供一种最佳的创建方式，工厂模式分为两种模式。
抽象工厂模式（Abstract Factory Pattern）：是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂，属于创建型模式。
解决问题： 提供一个工厂，创建对象实例，外部调用不需要关系对象具体创建流程，使创建对象与具体过程隔离起来。
分类： 工厂模式分为两种：

1.简单工厂模式（Simple Factory）
2.工厂方法模式（Factory Method）

2.实现

2.1.概要

2.1.1.例子

我们用手机为例子，如下所示：

普通工厂模式：假设有一个iPhone手机代工生产商，一个工厂生产iPhone手机，客户想要iPhone8就生产iPhone8，想要iPhoneX就生产iPhoneX。
工厂方法模式：iPhone手机代工厂又投入一笔钱，开了一个新工厂，一个工厂生产iPhone8，一个工厂生产iPhoneX。即具体工厂只能创建一个具体产品，这样这个手机代工厂就有iPhone8工厂和iPhoneX工厂。（简单工厂模式其实是工厂方法一种特例）。
抽象工厂模式：不过这个时候，这个手机代工厂发现客户买iPhoneX必须配耳机，于是又开始生产耳机，这时候手机和耳机已经属于两种不同产品了。

2.1.2.区别

工厂方法模式：

1.一个抽象产品类，可以派生出多个具体产品类。
2.一个抽象工厂类，可以派生出多个具体工厂类。
3. 每个具体工厂类只能创建一个具体产品类的实例

抽象工厂模式：

1.多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
2.一个抽象工厂类，可以派生出多个具体工厂类。
3. 每个具体工厂类可以创建多个具体产品类的实例。

区别：

1.工厂方法模式只有一个抽象产品类（手机），而抽象工厂模式有多个抽象产品类（手机、耳机）。
2. 工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

2.2.实例

2.2.1.简单工厂模式

角色：

Factory：工厂类，负责创建所有实例。
IProduct：抽象产品类，具体产品的父类。
Product：具体产品类。

//step1.创建抽象的手机类
public abstract class IPhone {
    public abstract void play();
}

//step2.实现手机类
//iPhone8
public class IPhone8 extends IPhone {
    @Override
    public void play() {
        System.out.println("玩iPhone8");
    }
}
//iPhoneX
public class IPhoneX extends IPhone {
    @Override
    public void play() {
        System.out.println("玩iPhoneX");
    }
}

//step3.创建工厂类
public class IPhoneFactory {
    public static IPhone createIPhone(String type) {
        IPhone iPhone = null;
        switch (type) {
            case "iPhone8":
                iPhone = new IPhone8();
                break;
            case "iPhoneX":
                iPhone = new IPhoneX();
                break;
        }
        return iPhone;
    }
}

//step4.使用
@Test
 public void factory(){
     IPhone iPhone8 = IPhoneFactory.createIPhone("iPhone8");
     iPhone8.play(); //输出： “玩iPhone8”
     IPhone iPhoneX= IPhoneFactory.createIPhone("iPhoneX");
     iPhoneX.play(); //输出： “玩iPhoneX”
 }

2.2.1.1.优点：

1.调用者想创建一个对象，只要知道其名称就可以了。
2.屏蔽产品的具体实现，调用者只关心产品的接口。

2.2.1.2.缺点：

1.每增加一个具体产品，需要更改工厂类，里面case分支判断，违背开闭原则。

2.2.2.工厂方法模式

角色：

Product：抽象的产品类。
ConcreteProduct：具体产品类。
Factory：抽象工厂类。
ConcreteFactory：具体工厂类。

//step1.创建抽象的手机类
public abstract class IPhone {
    public abstract void play();
}

//step2.实现手机类
//iPhone8
public class IPhone8 extends IPhone {
    @Override
    public void play() {
        System.out.println("玩iPhone8");
    }
}
//iPhoneX
public class IPhoneX extends IPhone {
    @Override
    public void play() {
        System.out.println("玩iPhoneX");
    }
}

//step3.创建一个生产工厂接口
public interface IIPhoneFactory {
    IIPhone createIPhone(String type);
}

//step2.实现生产工厂接口
//iPhone8具体工厂
public class IPhone8Factory implements IIPhoneFactory {
    @Override
    public IIPhone createIPhone(String type) {
        return new IPhone8();
    }
}
//iPhoneX具体工厂
public class IPhoneXFactory implements IIPhoneFactory {
    @Override
    public IIPhone createIPhone(String type) {
        return new IPhoneX();
    }
}
//step4.使用
@Test
public void factory(){
     new IPhone8Factory().createIPhone().play(); //输出： “玩iPhone8”
     new IPhoneXFactory().createIPhone().play(); //输出： “玩iPhoneX”
}

2.2.2.1.优点：

1.调用者想创建一个对象，调用其工厂就可以。
2.屏蔽产品的具体实现，调用者只关心产品的接口。

2.2.2.2.缺点：

1.每次增加一个产品时，都需要增加一个具体类和对象实现工厂，增加系统复杂度。

2.2.3.抽象工厂模式

//step1.创建产品抽象类
//耳机抽象类
public abstract class Earsphone {
   public abstract void color();
}
//iPhoneX抽象类
public abstract class IPhoneX {
   public abstract void color();
}

//step2.实现产品抽象类
//白色耳机
public class WhiteEarsphone extends Earsphone{
    public WhiteEarsphone () {
        this.color();
    }
    @Override
    public void color() {
        System.out.println("白色耳机");
    }
}
//黑色耳机
public class BlackEarsphone extends Earsphone{
    public BlackEarsphone () {
        this.color();
    }
    @Override
    public void color() {
        System.out.println("黑色耳机");
    }
}
//白色iPhoneX
public class WhiteIPhoneX extends IPhoneX {
    public WhiteIPhoneX () {
        this.color();
    }
    @Override
    public void color() {
        System.out.println("白色iPhoneX");
    }
}
//黑色iPhoneX
public class BlackIPhoneX extends IPhoneX {
    public BlackIPhoneX () {
        this.color();
    }
    @Override
    public void color() {
        System.out.println("白色iPhoneX");
    }
}

//step3.总的抽象类
public abstract class AbstractFactory {
    public abstract IPhoneX createIPhoneX();
    public abstract Earsphone createEarsphone();
}

//step4.实现
//带有白色耳机的iPhoneX
public class WhiteIPhoneXFactory extends AbstractFactory {
    @Override
     public IPhoneX createIPhoneX() {
        return new WhiteIPhoneX();
    }
    @Override
    public  Earsphone createEarsphone(){
        return new WhiteEarsphone ();
    }
}
//带有黑色耳机的iPhoneX
public class BlackIPhoneXFactory extends AbstractFactory {
    @Override
     public IPhoneX createIPhoneX() {
        return new BlackIPhoneX();
    }
    @Override
    public  Earsphone createEarsphone(){
        return new BlackEarsphone ();
    }
}
//step4.使用
 @Test
 public void factory() {
     AbstractFactory factory = new BlackIPhoneXFactory ();
     factory.createIPhoneX();
     factory.createEarsphone();
}

2.2.3.1.优点：

1.当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。。

2.2.3.2.缺点：

1.产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

soleil雪寂

发布了8 篇原创文章 · 获赞 11 · 访问量 3万+

私信关注

Java设计模式：工厂模式+抽象工厂模式