工厂设计模式
它提供了一种创建对象的最佳方式，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象
工厂模式实现方式
- 简单工厂模式：通过传入相关的类型来返回相应的类，这种方式比较单一，可扩展性相对较差
- 工厂方法模式：通过实现类现实相应的方法来决定相应的返回结果，这种方式可扩展性比较强
- 抽象工厂模式：及时上述两种模式的拓展，且支持细化产品，是工厂方法模式的升级版，当需要创建的产品有多个产品线时使用抽象工厂模式是比较好的选择
应用场景
- 解耦：分离职责，把复杂对象的创建和使用过程分开
- 复用代码，降低维护成本
- 如果对象创建复杂且多处需用到，如果每处都进行编写，则很多重复代码，如果业务逻辑发生改变，需到处修改
- 使用工厂模式统一创建，则只要修改工厂类即可，降低成本
简单工厂模式
- 简单工厂模式，又称静态工厂方法，可以根据参数的不同，返回不同类的实例，专门定义一个类来辅助创建其他类的实例，被创建的实例通常都具有共同的父类
- 由于工厂方法是静态方法，可以通过类名直接调用，而且只需要传入简单的参数即可
- 优点：
- 将对象的创建和对象本身业务处理分离可以降低系统的耦合度，使得两者修改起来都相对容易
- 缺点：
- 工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，这一点与开闭原则相违背
- 开闭原则，对扩展开发，对修改关闭，程序需要进行扩展的时候，不能去修改原有的代码，实现一个热插拔的效果
- 将会增加系统中类的个数，在一定程度上增加了系统的复杂度和理解难度，不利于系统的扩展和维护，创建简单对象就不用该模式
组成要素
-
Factory：工厂类，简单工厂模式的核心，它负责实现创建所有实例的内部逻辑
-
IProcduct：抽象产品类，简单工厂模式所创建的所有对象的父类，描述所有实例所共有的公共接口
-
Product：具体产品类，是简单工厂模式的创建目标
实现步骤
- 创建抽象产品类，里面有产品的抽象方法，由具体的产品类去实现
- 创建具体产品类，继承他们的父类，并实现具体方法
- 创建工厂类，提供一个静态方法createXXX用来生产产品，只需要传入你想要的产品名称
实现案例
创建抽象产品类
public abstract class IProduct {
/**
* 打印产品名
*/
abstract void print();
}
创建具体产品类
public class ProductA extends IProduct {
@Override
void print() {
System.out.println("产品A");
}
}
public class ProductB extends IProduct {
@Override
void print() {
System.out.println("产品B");
}
}
创建工厂类
public class Factory {
public static IProduct createProduct(String name) {
if ("A".equals(name)) {
return new ProductA();
} else if ("B".equals(name)) {
return new ProductB();
}
throw new RuntimeException("产品不存在");
}
}
测试
public class Test {
public static void main(String[] args) {
IProduct product = Factory.createProduct("A");
product.print();
}
}
工厂方法模式
- 工厂方法模式，又称工厂模式，是对简单工厂模式的进一步抽象，其好处是可以使系统在不修改原来代码的情况下引入新的产品，即满足开闭原则
- 通过工厂父类定义负责创建产品的公共接口，通过子类来确定所需要创建的类型
- 相比简单工厂而言，此种方法具有更多的可扩展性和复用性，同时也增强了代码的可读性
- 将类的实例化（具体产品的创建）延迟到工厂类的子类（具体工厂）中完成，即由子类决定应该实例化哪一个类。
- 优点：
- 符合开闭原则，增加一个产品类，只需要实现其具体的产品类和具体的工厂类
- 符合单一职责原则，每个工厂只负责生产对应的产品
- 使用者只需要知道产品的抽象类，无需关心其他实现类，满足迪米特法则、依赖倒置原则和里式替换原则
- 迪米特法则：最少知道原则，实体应当尽量少的与其他实体之间发生相互作用
- 依赖倒置原则：针对接口编程，依赖于抽象而不依赖于具体
- 里式替换原则：俗称LSP，任何基类可以出现的地方，子类一定可以出现，对实现抽象化的具体步骤规范
- 缺点：
- 增加一个产品，需要实现对应的具体工厂类和具体的产品类
- 每个产品需要对于的具体工厂类和具体的产品类
组成要素
- IProduct：抽象产品类，描述所有实例所共有的公共接口
- Product：具体产品类，实现抽象产品类的接口，从工厂类创建对象，如果有多个需要定义多个
- IFactory：抽象工厂类，描述具体工厂的公共接口
- Factory：具体工厂类，实现创建产品类对象，实现抽象工厂类的接口，如果有多个需要定义多个
实现步骤
- 创建抽象产品类，里面有产品的抽象方法，由具体的产品类去实现
- 创建具体产品类，继承他们的父类，并实现具体方法
- 创建抽象工厂类，里面抽象创建产品方法
- 创建具体工厂类，提供一个静态方法createXXX用来生产产品，工厂与产品对应
实现案例
创建抽象产品类
public abstract class IProduct {
/**
* 打印具体产品
*/
abstract void print();
}
创建具体产品类
public class ProductA extends IProduct {
@Override
void print() {
System.out.println("产品A");
}
}
public class ProductB extends IProduct {
@Override
void print() {
System.out.println("产品B");
}
}
创建抽象工厂类
public abstract class IFactory {
/**
* 获取产品抽象方法
* @return
*/
abstract IProduct createProduct();
}
创建具体工厂类
public class FactoryA extends IFactory {
@Override
IProduct createProduct() {
return new ProductA();
}
}
public class FactoryB extends IFactory {
@Override
IProduct createProduct() {
return new ProductA();
}
}
测试
public class Test {
public static void main(String[] args) {
IFactory factory = new FactoryA();
IProduct product = factory.createProduct();
product.print();
}
}
抽象工厂模式
- 抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
- 工厂模式中的每一个形态都是针对一定问题的解决方案，工厂方法针对的是多个产品系列结构；而抽象工厂模式针对的是多个产品族结构，一个产品族内有多个产品系列。
- 背景
- 工厂方法模式引入工厂等级结构，解决简单工厂模式中工厂类职责过重的问题
- 工厂方法模式中每个工厂只创建一类具体类的对象，后续发展可能会导致工程类过多，因此将一些相关的具体类组成一个具体类族，由同一个工厂来统一生产，强调的是一系列相关产品对象。
- 优点
- 当一个产品族中的多个对象被设计成一起工作时，它能保证使用始终只使用同一个产品族中的对象
- 缺点
- 产品族扩展困难，要增加一个系列的某一产品，既要在抽象的工厂和抽象的产品里修改代码，又要在具体的产品里面增加代码，不符合开闭原则
- 增加了系统的抽象性和理解的难度
组成要素
- IProduct：抽象产品类，描述所有实例所共有的公共接口
- Product：具体产品类，实现抽象产品类的接口，从工厂类创建对象，如果有多个需要定义多个
- IFactory：抽象工厂类，描述具体工厂的公共接口
- Factory：具体工厂类，实现创建产品类对象，实现抽象工厂类的接口
- FactoryProducer： 工厂创造器/生成器类 ，通过工厂名获取具体工厂
实现步骤
- 创建抽象产品类，里面有产品的抽象方法，由具体的产品类去实现
- 创建具体产品类，继承他们的父类，并实现具体方法
- 创建抽象工厂类，该工厂为超级工厂，可以通过该工厂创建其他工厂
- 创建具体工厂类，提供一个静态方法createXXX用来生产产品，工厂与产品对应
- 创建 工厂创造器/生成器类 ，通过工厂名获取具体工厂
实现案例
实现案例
案例类图
创建抽象产品类
口罩
public abstract class IMaskProduct {
/**
* 打印口罩名
*/
abstract void printMask();
}
手机
public abstract class IPhoneProduct {
/**
* 打印手机名
*/
abstract void printPhone();
}
创建具体产品类
口罩
public class KN95Mask extends IMaskProduct {
@Override
void printMask() {
System.out.println("KN95");
}
}
public class N95Mask extends IMaskProduct {
@Override
void printMask() {
System.out.println("N95");
}
}
手机
public class HuaWeiPhone extends IPhoneProduct {
@Override
void printPhone() {
System.out.println("华为手机");
}
}
public class PingGuoPhone extends IPhoneProduct {
@Override
void printPhone() {
System.out.println("苹果手机");
}
}
public class XiaoMiPhone extends IPhoneProduct {
@Override
void printPhone() {
System.out.println("小米手机");
}
}
public class YiJiaPhone extends IPhoneProduct {
@Override
void printPhone() {
System.out.println("一加手机");
}
}
创建抽象工厂类
public abstract class IFactory {
/**
* 获取产品抽象方法
* @return
*/
abstract IPhoneProduct createPhoneProduct(String name);
/**
* 获取产品抽象方法
* @return
*/
abstract IMaskProduct createMaskProduct(String name);
}
创建具体工厂类
public class BeiJingFactory extends IFactory {
@Override
IPhoneProduct createPhoneProduct(String name) {
if ("华为".equals(name)) {
return new HuaWeiPhone();
} else if ("苹果".equals(name)) {
return new PingGuoPhone();
}
throw new RuntimeException("无此类产品");
}
@Override
IMaskProduct createMaskProduct(String name) {
if ("N95".equals(name)) {
return new N95Mask();
}
throw new RuntimeException("无此类产品");
}
}
public class GuangDonFactory extends IFactory {
@Override
IPhoneProduct createPhoneProduct(String name) {
if ("小米".equals(name)) {
return new XiaoMiPhone();
} else if ("一加".equals(name)) {
return new YiJiaPhone();
}
throw new RuntimeException("无此类产品");
}
@Override
IMaskProduct createMaskProduct(String name) {
if ("KN95".equals(name)) {
return new KN95Mask();
}
throw new RuntimeException("无此类产品");
}
}
工厂创造器
public class FactoryProducer {
public static IFactory getFactory(String name){
if("BeiJing".equals(name)){
return new BeiJingFactory();
} else if("GuangDon".equals(name)){
return new GuangDonFactory();
}
return null;
}
}
测试
public class Test {
public static void main(String[] args) {
IFactory factory = FactoryProducer.getFactory("BeiJing");
IMaskProduct n95 = factory.createMaskProduct("N95");
n95.printMask();
IPhoneProduct huawei = factory.createPhoneProduct("华为");
huawei.printPhone();
}
}
ew GuangDonFactory();
}
return null;
}
}
### 测试
```java
public class Test {
public static void main(String[] args) {
IFactory factory = FactoryProducer.getFactory("BeiJing");
IMaskProduct n95 = factory.createMaskProduct("N95");
n95.printMask();
IPhoneProduct huawei = factory.createPhoneProduct("华为");
huawei.printPhone();
}
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
