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 里加代码,又要在具体的里面加代码。