工厂设计模式

工厂设计模式

该设计模式解决的问题是:将类实例化的操作与使用对象的操作分开,让使用者不用知道具体参数就可以实例化出所需要的产品类,从而避免了在客户端代码中显式指定,实现了解耦。

该设计模式分为三种实现

  1. 简单工厂设计模式
  2. 工厂方法实现模式
  3. 抽象工厂实现模式

简单工厂设计模式

一个汽车工厂生产汽车。有特斯拉、大众、五菱

车的接口

1
2
3
public interface Car {
void printName();
}

大众

1
2
3
4
5
6
public class DaZhong implements Car{
@Override
public void printName() {
System.out.println("大众");
}
}

特斯拉

1
2
3
4
5
6
public class TeSiLa implements Car{
@Override
public void printName() {
System.out.println("特斯拉");
}
}

五菱

1
2
3
4
5
6
public class WuLin implements Car{
@Override
public void printName() {
System.out.println("五菱宏光");
}
}

工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
public class CarFactory {
public static Car getCar(String carName){
if("大众".equals(carName)){
return new DaZhong();
}else if("五菱宏光".equals(carName)){
return new WuLin();
}else if("特斯拉".equals(carName)){
return new TeSiLa();
}else {
return null;
}
}
}

缺点:很难横向拓展,如果我后期需要加新的车型,需要改变原来的代码,不符合开闭原则(OOP七大原则)

优点:简单易懂

可以简单优化

1
2
3
4
5
6
7
8
9
10
11
public class CarFactory {
public static Car getWuLin(){
return new WuLin();
}
public static Car getDaZhong(){
return new DaZhong();
}
public static Car getTeSiLa(){
return new TeSiLa();
}
}

工厂方法实现模式

还是简单工厂的模型,我们来换个工厂

这一次我们定义一个汽车工厂的接口

1
2
3
public interface CarFactory {
Car getCar();
}

特斯拉工厂

1
2
3
4
5
6
public class TeSiLaCarFactory implements CarFactory{
@Override
public Car getCar() {
return new TeSiLa();
}
}

大众工厂

1
2
3
4
5
6
public class DaZhongCarFactory implements CarFactory{
@Override
public Car getCar() {
return new DaZhong();
}
}

五菱工厂

1
2
3
4
5
6
public class WuLinCarFactory implements CarFactory{
@Override
public Car getCar() {
return new WuLin();
}
}

缺点:当汽车类型很多的时候,会有很多很多很多各自的工厂,没有必要

抽象工厂实现模式

这次我们换一个场景:小米和华为都有路由器和手机的产品

路由器接口

1
2
3
4
public interface Router {
void doConfig();
void printInfo();
}

手机接口

1
2
3
4
public interface MobilePhone {
void sendMsg();
void callUp();
}

厂家接口

1
2
3
4
public interface ProductFactory {
MobilePhone getMobilePhone();
Router getRouter();
}

华为手机

1
2
3
4
5
6
7
8
9
10
11
public class HuaWeiMobilePhone implements MobilePhone {
@Override
public void sendMsg() {
System.out.println("华为手机发信息");
}

@Override
public void callUp() {
System.out.println("华为手机打电话");
}
}

华为路由器

1
2
3
4
5
6
7
8
9
10
11
public class HuaWeiRouter implements Router {
@Override
public void doConfig() {
System.out.println("华为路由器配置");
}

@Override
public void printInfo() {
System.out.println("华为路由器打印详细信息");
}
}

小米路由器

1
2
3
4
5
6
7
8
9
10
11
public class XiaoMiRouter implements Router {
@Override
public void doConfig() {
System.out.println("小米路由器配置");
}

@Override
public void printInfo() {
System.out.println("小米路由器打印详细信息");
}
}

小米手机

1
2
3
4
5
6
7
8
9
10
11
public class XiaoMiMobilePhone implements MobilePhone {
@Override
public void sendMsg() {
System.out.println("小米手机发信息");
}

@Override
public void callUp() {
System.out.println("小米手机打电话");
}
}

华为厂商

1
2
3
4
5
6
7
8
9
10
11
public class HuaWeiFactory implements ProductFactory {
@Override
public MobilePhone getMobilePhone() {
return new HuaWeiMobilePhone();
}

@Override
public Router getRouter() {
return new HuaWeiRouter();
}
}

小米厂商

1
2
3
4
5
6
7
8
9
10
11
public class XiaoMiFactory implements ProductFactory {
@Override
public MobilePhone getMobilePhone() {
return new XiaoMiMobilePhone();
}

@Override
public Router getRouter() {
return new XiaoMiRouter();
}
}

两个维度,第一个维度是产品族(路由器、手机),第二个维度是具体厂商(华为,小米)。

根据这两种维度分别设计了接口,抽象的工厂定义生产哪些产品族,具体的工厂具体实现自己的产品族

给作者买杯咖啡吧~~~