网站建设夹夹虫公司,html常用标签,餐饮美食网站源码,博客网站建设基本流程文章目录 设计模式概述1、工厂模式概述1#xff09;特点#xff1a;2#xff09;主要角色#xff1a;3#xff09;工作流程#xff1a;4#xff09;优点5#xff09;缺点6#xff09;适用场景 2、简单工厂模式(静态工厂模式)1) 在简单工厂模式中#xff0c;有三个主要… 文章目录 设计模式概述1、工厂模式概述1特点2主要角色3工作流程4优点5缺点6适用场景 2、简单工厂模式(静态工厂模式)1) 在简单工厂模式中有三个主要角色2) 简单工厂模式的优点包括3) 简单工厂模式也有一些限制和考虑因素4) 简单工厂模式适用场景5) 简单工厂UML类图6) 代码示例 3、工厂方法模式1) 在工厂方法模式中有4个主要角色2) 工厂方法模式的工作流程3) 工厂方法模式适用场景4) 工厂方法模式UML类图5) 代码示例 4、抽象工厂模式1) 在抽象工厂模式中有4个主要角色2) 抽象工厂模式的工作流程3) 抽象工厂模式的优点4) 抽象工厂模式的缺点5) 抽象工厂模式适用场景6) 抽象工厂模式UML类图7) 代码示例 设计模式概述
创建型模式工厂方法、抽象方法、建造者、原型、单例。 结构型模式有适配器、桥接、组合、装饰器、外观、享元、代理。 行为型模式有责任链、命令、解释器、迭代器、中介、备忘录、观察者、状态、策略、模板方法、访问者。 常用设计模式 单例模式、工厂模式、代理模式、策略模式模板模式、门面模式、责任链模式、装饰器模式、组合模式、builder模式。
1、工厂模式概述
1特点
工厂模式Factory Pattern是一种创建型设计模式旨在提供一种统一的方式来创建对象将对象的实例化过程封装在一个单独的类中。工厂模式通过定义一个公共的接口来创建对象但允许子类决定实例化哪个类。这样可以将对象的实例化与客户端代码的耦合度降到最低同时也提供了一种可扩展的方式来创建对象。
2主要角色
抽象产品定义产品的通用接口具体产品类需要实现该接口。具体产品实现抽象产品接口的类代表实际的产品。抽象工厂定义创建产品的接口可以是抽象类或接口声明工厂方法。具体工厂实现抽象工厂的接口负责创建具体产品对象。
3工作流程
客户端通过抽象工厂请求产品实例。具体工厂类根据请求创建并返回对应的具体产品。客户端使用产品实例而不直接依赖具体产品类。
4优点
解耦将对象的创建与使用分离降低了客户端与具体产品的耦合度。易扩展可以通过新增具体产品和工厂轻松扩展系统而无需修改现有代码。灵活性可以动态替换产品实例提供灵活的对象创建方式。
5缺点
系统复杂性增加引入了多个类和接口增加了系统的复杂度。代码量增加添加新产品时需要创建新的具体产品类和对应的具体工厂类。类的爆炸性增长随着产品族增加具体工厂类的数量可能大幅增长。
6适用场景
需要统一管理对象创建过程的场景。系统需要频繁扩展和替换产品类的场景。
2、简单工厂模式(静态工厂模式)
简单工厂模式(Simple Factory Pattern) 是工厂模式的一种简化形式也被称为静态工厂模式。它通过一个专门的工厂类来创建对象而无需将对象的实例化过程放在客户端代码中。
1) 在简单工厂模式中有三个主要角色
抽象产品Abstract Product定义产品的通用接口所有具体产品类都应该实现这个接口。具体产品Concrete Product实现抽象产品接口的具体类。简单工厂Simple Factory负责创建具体产品的工厂类。它通常包含一个静态方法根据客户端的请求来创建并返回具体产品的实例。
2) 简单工厂模式的优点包括
将对象的创建过程集中在一个工厂类中减少了客户端代码与具体产品的直接耦合。可以通过简单工厂类的静态方法来创建产品简化了客户端的调用代码。可以轻松添加新的产品只需修改简单工厂类的创建方法而无需修改客户端代码。
3) 简单工厂模式也有一些限制和考虑因素
工厂类负责创建所有产品当产品种类较多时工厂类的代码可能会变得复杂。添加新产品时需要修改工厂类的代码违反了开闭原则。
4) 简单工厂模式适用场景
简单工厂模式适用于需要根据客户端请求来创建不同类型对象的场景但产品种类较少且不经常变化的情况。它提供了一种简单的方式来封装对象的创建过程降低了客户端代码与具体产品的耦合度。
5) 简单工厂UML类图 6) 代码示例
// 抽象产品类
abstract class Product {public abstract void use();
}// 具体产品类A
class ConcreteProductA extends Product {Overridepublic void use() {System.out.println(Using ConcreteProductA);}
}// 具体产品类B
class ConcreteProductB extends Product {Overridepublic void use() {System.out.println(Using ConcreteProductB);}
}// 简单工厂类
class SimpleFactory {public Product createProduct(String type) {if (type.equals(A)) {return new ConcreteProductA();} else if (type.equals(B)) {return new ConcreteProductB();} else {// 处理未知产品类型的情况return null;}}
}public class Main {public static void main(String[] args) {// 使用简单工厂创建产品SimpleFactory factory new SimpleFactory();Product productA factory.createProduct(A);if (productA ! null) {productA.use();}Product productB factory.createProduct(B);if (productB ! null) {productB.use();}Product unknownProduct factory.createProduct(C);if (unknownProduct null) {System.out.println(Unknown product type.);}}
}
3、工厂方法模式
工厂方法模式Factory Method Pattern 是一种创建型设计模式它提供了一种将对象的创建委托给子类的方式。在工厂方法模式中定义一个用于创建对象的接口但让子类决定实例化哪个类。这样可以将对象的创建与使用解耦使得系统在不修改具体产品类的情况下可以引入新的产品。
1) 在工厂方法模式中有4个主要角色
抽象产品Abstract Product定义产品的通用接口所有具体产品类都应该实现这个接口。具体产品Concrete Product实现抽象产品接口的具体类是工厂方法模式所创建的对象。抽象工厂Factory定义了工厂方法的接口负责创建抽象产品的对象。具体工厂Concrete Factory实现了抽象工厂接口具体工厂类根据具体业务逻辑创建具体产品的对象。
2) 工厂方法模式的工作流程
客户端通过调用具体工厂类的工厂方法来创建产品对象。具体工厂类根据客户端的请求调用具体产品类的构造方法创建具体产品对象。具体工厂类将创建的具体产品对象返回给客户端。
通过工厂方法模式客户端与具体产品类解耦客户端只需关心抽象产品和抽象工厂具体产品的创建由具体工厂类来完成。这样当需要引入新的产品时只需创建一个新的具体产品类和对应的具体工厂类而不需要修改客户端代码。
3) 工厂方法模式适用场景
当一个类无法预知它需要创建的对象的具体类时可以使用工厂方法模式。当一个类希望将对象的创建责任委托给多个子类中的某一个时可以使用工厂方法模式。当一个类需要通过其子类来指定创建对象时可以使用工厂方法模式。
总结来说工厂方法模式通过定义一个创建对象的接口将对象的实例化延迟到子类中去完成实现了对象的创建与使用的解耦提高了系统的可扩展性和灵活性。
4) 工厂方法模式UML类图 5) 代码示例
// 抽象产品类
abstract class Product {// 抽象方法public abstract void use();
}// 具体产品类A
class ConcreteProductA extends Product {Overridepublic void use() {System.out.println(Using ConcreteProductA);}
}// 具体产品类B
class ConcreteProductB extends Product {Overridepublic void use() {System.out.println(Using ConcreteProductB);}
}// 抽象工厂类
abstract class Factory {// 抽象工厂方法public abstract Product createProduct();// 打印产品使用信息public void print() {Product product createProduct();product.use();}
}// 具体工厂类A
class ConcreteFactoryA extends Factory {Overridepublic Product createProduct() {return new ConcreteProductA();}
}// 具体工厂类B
class ConcreteFactoryB extends Factory {Overridepublic Product createProduct() {return new ConcreteProductB();}
}public class Main {public static void main(String[] args) {// 使用工厂类创建产品Factory factoryA new ConcreteFactoryA();factoryA.print();Factory factoryB new ConcreteFactoryB();factoryB.print();}
}
运行结果
Using ConcreteProductA
Using ConcreteProductB4、抽象工厂模式
抽象工厂模式Abstract Factory Pattern 是一种创建型设计模式旨在提供一种统一的方式来创建一系列相关或相互依赖的对象而无需指定具体的类。它通过定义一个抽象工厂接口和一组具体工厂类来创建一族产品对象。
1) 在抽象工厂模式中有4个主要角色
抽象工厂Abstract Product定义了创建一族产品对象的接口。它通常包含一组用于创建不同产品的工厂方法。具体工厂Concrete Product实现了抽象工厂接口负责创建具体的产品对象。抽象产品Factory定义了一族产品对象的通用接口。具体产品类应实现这个接口。具体产品Concrete Factory实现了抽象产品接口是由具体工厂创建的对象。
2) 抽象工厂模式的工作流程
客户端通过抽象工厂接口来创建一族相关的产品对象。具体工厂类实现了抽象工厂接口负责创建具体的产品对象。抽象工厂的工厂方法根据具体工厂的实现创建并返回具体产品的实例。客户端使用返回的产品实例进行操作而无需关心具体产品的实现细节。
3) 抽象工厂模式的优点
将对象的创建和使用分离降低了客户端代码与具体产品的耦合度。提供了一种可替换的方式来创建一族相关产品使得系统更加灵活和可维护。符合开闭原则可以轻松添加新的具体工厂和产品类扩展系统功能。
4) 抽象工厂模式的缺点
当产品族的数量增加时抽象工厂和具体工厂的接口可能变得复杂需要谨慎设计和管理。添加新的产品族可能需要修改抽象工厂和所有具体工厂的代码违反了开闭原则。
5) 抽象工厂模式适用场景
抽象工厂模式适用于需要创建一族相关产品对象的场景其中产品之间存在一定的关联或依赖关系。它提供了一种统一的方式来管理产品的创建过程将对象的创建与客户端代码解耦同时也支持动态替换和扩展对象的创建。
6) 抽象工厂模式UML类图 7) 代码示例
// 抽象产品A
interface AbstractProductA {void use();
}// 具体产品A1
class ConcreteProductA1 implements AbstractProductA {Overridepublic void use() {System.out.println(Using ConcreteProductA1);}
}// 具体产品A2
class ConcreteProductA2 implements AbstractProductA {Overridepublic void use() {System.out.println(Using ConcreteProductA2);}
}// 抽象产品B
interface AbstractProductB {void eat();
}// 具体产品B1
class ConcreteProductB1 implements AbstractProductB {Overridepublic void eat() {System.out.println(Eating ConcreteProductB1);}
}// 具体产品B2
class ConcreteProductB2 implements AbstractProductB {Overridepublic void eat() {System.out.println(Eating ConcreteProductB2);}
}// 抽象工厂
interface AbstractFactory {AbstractProductA createProductA();AbstractProductB createProductB();
}// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {Overridepublic AbstractProductA createProductA() {return new ConcreteProductA1();}Overridepublic AbstractProductB createProductB() {return new ConcreteProductB1();}
}// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {Overridepublic AbstractProductA createProductA() {return new ConcreteProductA2();}Overridepublic AbstractProductB createProductB() {return new ConcreteProductB2();}
}// 主程序
public class Main {public static void main(String[] args) {// 使用具体工厂1创建产品族1AbstractFactory factory1 new ConcreteFactory1();AbstractProductA productA1 factory1.createProductA();AbstractProductB productB1 factory1.createProductB();productA1.use();productB1.eat();// 使用具体工厂2创建产品族2AbstractFactory factory2 new ConcreteFactory2();AbstractProductA productA2 factory2.createProductA();AbstractProductB productB2 factory2.createProductB();productA2.use();productB2.eat();}
}
运行结果
Using ConcreteProductA1
Eating ConcreteProductB1
Using ConcreteProductA2
Eating ConcreteProductB2
