工厂模式
工厂模式有许多变体,其中最常见的有三种
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
简单工厂代码分析
UML图中我们可以清晰的看到代码结构 ,首先我们创建一个Car的汽车接口,定制汽车的基本规范,汽车可以的方法是可以跑,所以我们定义了一个抽象的run方法.
- 定义汽车接口Car
public interface Car { void run(); }
接着我们分别定义实现了汽车接口的不同车型
- 宝马类BMW
public class BMW implements Car{ @Override public void run() { System.out.println("宝马正在启动~~"); } }
- 奔驰类Benz
public class Benz implements Car{ @Override public void run() { System.out.println("奔驰正在启动~~"); } }
- 比亚迪类BYD
public class BYD implements Car{ @Override public void run() { System.out.println("比亚迪启动发现没电了~~"); } }
- 接着我们创建工厂类
public class CarFactory { public static Car createCar(String type){ if ("宝马".equals(type)){ return new BMW(); }else if ("奔驰".equals(type)){ return new Benz(); }else if ("比亚迪".equals(type)){ return new BYD(); }else{ return null; } } }
在上面这个工厂类中,我们通过传入的字符串equals我们要创建的车型是哪一款,匹配上的就创建并返回
- 编写测试类进行测试
public class Main { public static void main(String[] args) { //用工厂创建一辆宝马 Car car1 = CarFactory.createCar("宝马"); if (car1!=null){ car1.run(); }else { System.out.println("没有该车型，无法创建！"); } //用工厂创建一辆奔驰 Car car2 = CarFactory.createCar("奔驰"); if (car2!=null){ car2.run(); }else { System.out.println("没有该车型，无法创建！"); } //用工厂创建一辆宝骏 Car car3 =CarFactory.createCar("宝骏"); if (car3!=null){ car3.run(); }else { System.out.println("没有该车型，无法创建！"); } } }
运行结果
为什么工厂模式多种变体呢? 其实每一种变体都有优缺点,没有任何一种设计模式是完美的
对于简单工厂模式来说,他的工厂类是一般是静态的,因此可以直接用类名直接调用工厂方法,来创建实例对象
优点是实现简单,
缺点是缺点是当需要新增产品的时候,要修改工厂类的代码,不符合开闭原则.
工厂方法模式
工厂方法模式代码分析
在类图中,相比简单工厂模式,我们新增了一个工厂接口,不同的汽车厂商实现了工厂类
汽车接口和各个不同的品牌车代码同上
- 工厂接口
public interface Factory { Car creatCar(); }
我们在接口中声明了一个创建汽车的抽象方法
接下来,我们编写不同的汽车实现类
- 宝马汽车工厂类BMWFactory
public class BMWFactory implements Factory{ @Override public Car creatCar() { return new BMW(); } }
- 奔驰汽车工厂类BenzFactory
public class BenzFactory implements Factory{ @Override public Car creatCar() { return new Benz(); } }
- 比亚迪汽车工厂类BYDFactory
public class BYDFactory implements Factory{ @Override public Car creatCar() { return new BYD(); } }
以上三个类它们都实现了工厂接口
接下类我们编写测试方法,来创建汽车实例,并调用汽车的方法
public class Main { public static void main(String[] args) { BMWFactory bmwFactory = new BMWFactory(); Car BMWx5 = bmwFactory.creatCar(); BMWx5.run(); } }
运行结果
工厂方法模式定义一个抽象工厂接口，该接口中声明了一个用于创建产品的工厂方法，具体的产品类由具体的工厂类来实现。工厂方法模式可以有多个具体的工厂类，每个具体工厂类负责创建一种产品。
优点是符合开闭原则，当需要新增产品时，只需要新增具体的产品类和对应的具体工厂类即可，不需要修改抽象工厂接口和抽象工厂类的代码。
缺点是增加了系统的复杂程度
抽象工厂模式
为了方便包管理,我们将包进行了分类,如下
新增了一个包Logos,在该包中定义了一个名字叫做Logos的接口
- Logos接口
public interface Logos { void showLogos(); }
我们可以看到,这个接口的接口方法是用于创建车标的,接下类每一个实现它的类,都要重写这个接口方法
- BMWLogos类 (Logos的实现类,用于创建宝马车标)
public class BMWLogos implements Logos{ @Override public void showLogos() { System.out.println("我的LOGO是宝马"); } }
- BenzLogos类 (Logos的实现类,用于创建奔驰车标)
public class BuziLogos implements Logos{ @Override public void showLogos() { System.out.println("我的LOGO是奔驰~"); } }
- BYDLogos类 (Logos的实现类,用于创建BYD车标)
public class BYDLogos implements Logos{ @Override public void showLogos() { System.out.println("我的LOGO是 比亚迪"); } }
接着我们创建工厂接口
- 工厂接口Factory
public interface Factory { Car createCar(); Logos createLogos(); }
这个接口中,我们声明了两个接口方法,一个用于创建车辆,一个用于创建车标,接下来每一个实现工厂的接口都要进行重写这两个方法
- 宝马族工厂类 BMWFamilyFactory
public class BMWFamilyFactory implements Factory { @Override public Car createCar() { return new BMW(); } @Override public Logos createLogos() { return new BMWLogos(); } }
- 奔驰族工厂类 BenzFamilyFactory
public class BenzFamilyFactory implements Factory{ @Override public Car createCar() { return new Benz(); } @Override public Logos createLogos() { return new BuziLogos(); } }
- 比亚迪族工厂类 BYDFamilyFactory
public class BYDFamilyFactory implements Factory{ @Override public Car createCar() { return new BYD(); } @Override public Logos createLogos() { return new BYDLogos(); } }
细心的你会发现,相比于上面的工厂方法模式,这里的工厂实现类名字都会多一个Family,为什么呢?
因为抽象工厂方法模式是用来创建产品的一系列实例的,每个具体工厂类只能创建属于自己产品族的产品对象，不同产品族的产品对象不能混淆。
- 测试类
public class Main { public static void main(String[] args) { //创建奔驰工厂 Factory benzFamilyFactory = new BenzFamilyFactory(); benzFamilyFactory.createCar().run();//创建一辆奔驰并且使用run方法 benzFamilyFactory.createLogos().showLogos(); BMWFamilyFactory bmwFamilyFactory = new BMWFamilyFactory(); bmwFamilyFactory.createCar().run();//创建一辆奔驰并且使用run方法 bmwFamilyFactory.createLogos().showLogos();//创建一辆奔驰LOGO并且显示LOGO } }
运行结果
抽象工厂模式的优点在于，它能够保证创建的产品对象之间的兼容性。因为每个具体工厂类只能创建属于自己产品族的产品对象，所以不同产品族之间的产品对象不会产生冲突。此外，抽象工厂模式还支持增加新的产品族，而不需要修改已有的代码，符合开闭原则。但是，抽象工厂模式也有一些缺点。由于抽象工厂接口需要定义一组用于创建不同产品族的方法，因此当新增加一个产品族时，需要修改抽象工厂接口及其所有实现类，这可能会导致一定的代码修改工作量。
总结
简单工厂模式：
由一个工厂类根据传入的参数决定创建哪种产品类的实例。简单工厂模式将对象的创建和使用分离开来，客户端只需要传入参数，就可以得到所需的对象，无需关心对象的创建细节。
工厂方法模式：
定义一个创建产品对象的接口，由子类决定实例化哪一个产品类。工厂方法模式将对象的创建延迟到子类中去实现，客户端只需要知道所需产品的工厂类即可，无需关心具体的产品类。
抽象工厂模式：
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式可以看作是工厂方法模式的升级版，它支持创建一组相关的产品对象。抽象工厂模式能够保证创建的产品对象之间的兼容性，但是新增加一个产品族时需要修改抽象工厂接口及其所有实现类。
简单工厂模式：
优点：
- 工厂类中包含了必要的逻辑判断，可以根据客户端的请求动态地创建相关的产品对象，客户端无需知道具体的产品类。
- 简单工厂模式将对象的创建和使用分离开来，客户端只需要关心所需产品的参数，无需关心对象的创建细节。
缺点：
- 简单工厂模式工厂类职责过重，增加新的产品需要修改工厂类的判断逻辑，违背了开闭原则。
- 简单工厂模式只支持一种产品族的创建，不支持扩展。
工厂方法模式：
优点：
- 工厂方法模式将对象的创建延迟到子类中去实现，符合开闭原则，新增加产品时只需要添加对应的工厂类即可。
- 工厂方法模式支持扩展，可以创建多个产品族的对象。
缺点：
- 工厂方法模式需要新增加相应的工厂类，增加了代码的复杂度。
- 工厂方法模式增加了系统的抽象性和理解难度。
抽象工厂模式：
优点：
- 抽象工厂模式能够保证创建的产品对象之间的兼容性，因为每个具体工厂类只能创建属于自己产品族的产品对象，不同产品族的产品对象不能混淆。
- 抽象工厂模式支持增加新的产品族，而不需要修改已有的代码，符合开闭原则。
缺点：
- 抽象工厂模式需要新增加相应的接口及实现类，增加了代码的复杂度。
单工厂模式只支持一种产品族的创建，不支持扩展。工厂方法模式：
优点：
- 工厂方法模式将对象的创建延迟到子类中去实现，符合开闭原则，新增加产品时只需要添加对应的工厂类即可。
- 工厂方法模式支持扩展，可以创建多个产品族的对象。
缺点：
- 工厂方法模式需要新增加相应的工厂类，增加了代码的复杂度。
- 工厂方法模式增加了系统的抽象性和理解难度。
抽象工厂模式：
优点：
- 抽象工厂模式能够保证创建的产品对象之间的兼容性，因为每个具体工厂类只能创建属于自己产品族的产品对象，不同产品族的产品对象不能混淆。
- 抽象工厂模式支持增加新的产品族，而不需要修改已有的代码，符合开闭原则。
缺点：
- 抽象工厂模式需要新增加相应的接口及实现类，增加了代码的复杂度。
- 抽象工厂模式增加了系统的抽象性和理解难度。
