江门找做公众号的网站,shuwon-成都网站建设-成都网站制作-成都网络公司-蜀美网络,网站空间格式asp,网站技术培训文章目录 概述工厂模式的优点包括工厂模式有几种主要的变体看一个具体需求使用传统的方式来完成传统的方式的优缺点 简单工厂模式基本介绍使用简单工厂模式简单工厂模式的优缺点优点#xff1a;缺点#xff1a; 工厂方法模式看一个新的需求思路 1思路 2工厂方法模式介绍工厂方… 文章目录 概述工厂模式的优点包括工厂模式有几种主要的变体看一个具体需求使用传统的方式来完成传统的方式的优缺点 简单工厂模式基本介绍使用简单工厂模式简单工厂模式的优缺点优点缺点 工厂方法模式看一个新的需求思路 1思路 2工厂方法模式介绍工厂方法模式应用案例 抽象工厂模式基本介绍抽象工厂模式应用实例 工厂模式小结 概述
工厂模式是一种创建型设计模式它提供了一种创建对象的接口但将对象的实例化过程推迟到子类或具体的实现类中。工厂模式的主要目的是将对象的创建与使用分离从而降低代码的耦合性增强代码的可维护性和可扩展性。
工厂模式的优点包括
对象的封装将对象的创建细节封装在具体的工厂类中使客户端不需要了解具体的创建过程只需通过工厂来获取所需的对象。代码重用由于对象的创建过程在工厂类中集中管理可以避免在多个地方重复创建相同类型的对象。易于扩展当需要添加新的产品或变体时只需创建新的具体工厂类和产品类而不需要修改现有代码。降低耦合客户端只与抽象工厂类进行交互不直接依赖于具体产品类从而降低了代码的耦合性。
工厂模式有几种主要的变体
简单工厂模式不是正式的设计模式更像是一种编程习惯将对象的创建封装在一个静态方法中。工厂方法模式定义了一个用于创建对象的抽象方法由具体的子类工厂来实现创建逻辑。抽象工厂模式提供一个创建一组相关或相互依赖对象的接口每个具体工厂类负责创建一组具体产品。
看一个具体需求
看一个披萨的项目要便于披萨种类的扩展要便于维护
披萨的种类很多(比如 GreekPizz、CheesePizz 等)披萨的制作有 preparebake, cut, box完成披萨店订购功能。
使用传统的方式来完成
思路分析(类图) 新建一个tradition.pizzastore包
编写 OrderPizza.java 去订购需要的各种 Pizza
代码展示
package com.lh.factory.tradition.pizzastore.order;import java.io.BufferedReader;import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.lh.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;public class OrderPizza {// 构造器public OrderPizza() {//比萨的Pizza pizza null;String orderType; // 订购披萨的类型do {orderType getType();if (orderType.equals(greek)) {pizza new GreekPizza();pizza.setName(胡椒披萨);} else if (orderType.equals(cheese)) {pizza new CheesePizza();pizza.setName(奶酪披萨);// 新写的代码} else if (orderType.equals(pepper)) {pizza new PepperPizza();pizza.setName(希腊披萨);} else {System.out.println(不存在);break;}// 输出 Pizza 制作过程pizza.prepare();pizza.bake();pizza.cut();pizza.box();} while (true);}// 写一个方法可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin new BufferedReader(new InputStreamReader(System.in));System.out.println(input pizza 种类:);String str strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return ;}}
}Pizza类作为抽象类功能参考类图
package com.lh.factory.tradition.pizzastore.pizza;//将Pizza 类做成抽象类
public abstract class Pizza {//名字protected String name;public void setName(String name) {this.name name;}//原材料不同的披萨不一样的原材料,做成抽象方法自定义实现public abstract void prepare();//烘烤public void bake() {System.out.println(name baking);}//切割public void cut() {System.out.println(name cuting);}//打包public void box() {System.out.println(name boxing);}
}三个子类继承Pizza类
package com.lh.factory.tradition.pizzastore.pizza;public class CheesePizza extends Pizza{Overridepublic void prepare() {System.out.println(给胡椒披萨制作原材料);}
}package com.lh.factory.tradition.pizzastore.pizza;public class GreekPizza extends Pizza{Overridepublic void prepare() {System.out.println(奶酪准备原材料);}
}package com.lh.factory.tradition.pizzastore.pizza;public class PepperPizza extends Pizza {Overridepublic void prepare() {System.out.println( 给希腊披萨 准备原材料 );}
}客户端
package com.lh.factory.tradition.pizzastore.order;//相当于一个客户端发出订购
public class PizzaStore {public static void main(String[] args) {//传统方法new OrderPizza();}
}传统的方式的优缺点
优点是比较好理解简单易操作。缺点是违反了设计模式的 ocp 原则即对扩展开放对修改关闭。即当我们给类增加新功能的时候尽量不修改代码或者尽可能少修改代码.比如我们这时要新增加一个 Pizza 的种类(Pepper 披萨)我们需要做如下修改.如果我们增加一个 Pizza 类只要是订购 Pizza 的代码都需要修改.
在orderType中新增的代码如下图参考上方的orderType代码代码块中有如下功能 改进的思路分析 分析修改代码可以接受但是如果我们在其它的地方也有创建 Pizza 的代码就意味着也需要修改而创建 Pizza的代码往往有多处。 思路把创建 Pizza 对象封装到一个类中这样我们有新的 Pizza 种类时只需要修改该类就可其它有创建到 Pizza对象的代码就不需要修改了.- 简单工厂模式
简单工厂模式基本介绍 简单工厂模式是属于创建型模式是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式 简单工厂模式定义了一个创建对象的类由这个类来封装实例化对象的行为(代码) 在软件开发中当我们会用到大量的创建某种、某类或者某批对象时就会使用到工厂模式
使用简单工厂模式
简单工厂模式的设计方案: 定义一个可以实例化 Pizaa 对象的类封装创建对象的代码。
uml类图如下 看代码示例
简单工厂模式的pizza包下的类均不做改动参考如上代码即可 需要细心观看哦
这里只展示修改后的OrderPizza和客户端了以及新的简单工厂模式
package com.lh.factory.simplefactory.pizzastore.order;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.lh.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;public class OrderPizza {SimlpleFactory simlpleFactory;Pizza pizza null;//构造器public OrderPizza(SimlpleFactory simlpleFactory) {//接受简单工厂setFactory(simlpleFactory);}public void setFactory(SimlpleFactory simlpleFactory) {String orderType ; // 用户输入的this.simlpleFactory simlpleFactory; // 设置简单工厂对象do {orderType getType();pizza this.simlpleFactory.createPizza(orderType);//输出pizzaif (pizza ! null) { //订购成功pizza.prepare();pizza.bake();pizza.cut();pizza.box();}else {System.out.println(订购披萨失败);break;}} while (true);}// 写一个方法可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin new BufferedReader(new InputStreamReader(System.in));System.out.println(input pizza 种类:);String str strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return ;}}
}好处只需要修改工厂类的代码即可不需要在业务场景下进行修改
下面的工厂类写了两个相同的方法没别的意思就是告诉大家简单工厂模式也叫静态工厂模式
package com.lh.factory.simplefactory.pizzastore.order;import com.lh.factory.simplefactory.pizzastore.pizza.CheesePizza;
import com.lh.factory.simplefactory.pizzastore.pizza.GreekPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.PepperPizza;
import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;//简单工厂类
public class SimlpleFactory {//返回对应的Pizza public Pizza createPizza(String orderType) {Pizza pizza null;if (orderType.equals(greek)) {pizza new GreekPizza();pizza.setName(希腊披萨);} else if (orderType.equals(cheese)) {pizza new CheesePizza();pizza.setName(奶酪披萨);// 新写的代码} else if (orderType.equals(pepper)) {pizza new PepperPizza();pizza.setName(胡椒披萨);}return pizza;}//简单工厂模式也叫静态工厂模式public static Pizza createPizza2(String orderType) {Pizza pizza null;System.out.println(使用简单工厂模式2);if (orderType.equals(greek)) {pizza new GreekPizza();pizza.setName(希腊披萨);} else if (orderType.equals(cheese)) {pizza new CheesePizza();pizza.setName(奶酪披萨);// 新写的代码} else if (orderType.equals(pepper)) {pizza new PepperPizza();pizza.setName(胡椒披萨);}return pizza;}
}
静态工厂模式的OrderPizza类静态工厂模式看起来更加方便减少了一部分代码
package com.lh.factory.simplefactory.pizzastore.order;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.simplefactory.pizzastore.pizza.Pizza;public class OrderPizza2 {Pizza pizza null;String orderType ;// 构造器public OrderPizza2() {// 接受简单工厂do {orderType getType();pizza SimlpleFactory.createPizza2(orderType);// 输出pizzaif (pizza ! null) { // 订购成功pizza.prepare();pizza.bake();pizza.cut();pizza.box();} else {System.out.println(订购披萨失败);break;}} while (true);}// 写一个方法可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin new BufferedReader(new InputStreamReader(System.in));System.out.println(input pizza 种类:);String str strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return ;}}}
简单工厂模式的优缺点
优点
封装对象的创建逻辑通过将对象的创建逻辑封装在静态工厂方法中客户端代码无需了解对象的具体创建过程降低了对象创建的复杂度。
代码组织简单工厂模式可以集中管理对象的创建逻辑使代码更加清晰、简洁并且易于维护。
灵活性如果需要更改或替换产品只需修改工厂方法的实现不会影响客户端代码从而实现了产品变化对客户端的透明性。
缺点
不符合开闭原则当需要添加新的产品类型时可能需要修改工厂方法的代码这违背了开闭原则对扩展开放对修改关闭。
工厂类职责过重工厂类通常负责创建多种不同类型的对象导致工厂类职责变得较重随着产品种类的增加工厂类会变得越来越复杂。
不支持多个工厂类在简单工厂模式中只有一个工厂类负责所有对象的创建这可能会导致工厂类变得庞大难以管理。
不够灵活由于所有对象的创建逻辑集中在一个工厂类中如果不同的产品有复杂的创建过程可能无法很好地适应。
工厂方法模式
看一个新的需求
披萨项目新的需求客户在点披萨时可以点不同口味的披萨比如 北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。
思路 1
使用简单工厂模式创建不同的简单工厂类比如 BJPizzaSimpleFactory、LDPizzaSimpleFactory 等等。从当前这个案例来说也是可以的但是考虑到项目的规模以及软件的可维护性、可扩展性并不是特别好 考验大家抽象能力
思路 2
使用工厂方法模式
工厂方法模式介绍
工厂方法模式设计方案将披萨项目的实例化功能抽象成抽象方法在不同的口味点餐子类中具体实现。工厂方法模式定义了一个创建对象的抽象方法由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。
工厂方法模式应用案例 披萨项目新的需求客户在点披萨时可以点不同口味的披萨比如 北京的奶酪 pizza、北京的胡椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza 思路分析图解 Pizza类与它的子类
package com.lh.factory.factorymethod.pizzastore.pizza;//将Pizza 类做成抽象类
public abstract class Pizza {//名字protected String name;//原材料不同的披萨不一样的原材料,做成抽象方法自定义实现public abstract void prepare();//烘烤public void bake() {System.out.println(name baking);}//切割public void cut() {System.out.println(name cuting);}//打包public void box() {System.out.println(name boxing);}public void setName(String name) {this.name name;}
}public class LDPepperPizza extends Pizza{Overridepublic void prepare() {setName(伦敦胡椒披萨...);System.out.println(伦敦胡椒pizza,准备原材料);}
}public class LDCheesePizza extends Pizza{Overridepublic void prepare() {setName(伦敦奶酪披萨...);System.out.println(伦敦奶酪pizza,准备原材料);}}public class BJPepperPizza extends Pizza{Overridepublic void prepare() {setName(北京胡椒披萨...);System.out.println(北京pizza,准备原材料);}
}public class BJCheesePizza extends Pizza{Overridepublic void prepare() {setName(北京奶酪披萨...);System.out.println(北京pizza,准备原材料);}
}工厂抽象类定义一个工厂的抽象方法让其子类自己实现这样可以不需要动工厂自身的代码如果想添加新的品种可以新创建一个继承工厂抽象类重写其方法就可以
package com.lh.factory.factorymethod.pizzastore.order;import java.io.BufferedReader;import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.factorymethod.pizzastore.pizza.Pizza;public abstract class OrderPizza {// 构造器public OrderPizza() {Pizza pizza null;String orderType; // 订购披萨的类型do {orderType getType();//抽象方法由工厂子类完成pizza createPizza(orderType);// 输出 Pizza 制作过程pizza.prepare();pizza.bake();pizza.cut();pizza.box();} while (true);}// 定义一个抽象方法createPizza,让各个工厂子类自己实现abstract Pizza createPizza(String orderType);// 写一个方法可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin new BufferedReader(new InputStreamReader(System.in));System.out.println(input pizza 种类:);String str strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return ;}}
}两个分工厂分别继承OrderPizza 类分别实现各自的功能
package com.lh.factory.factorymethod.pizzastore.order;import com.lh.factory.factorymethod.pizzastore.pizza.LDCheesePizza;
import com.lh.factory.factorymethod.pizzastore.pizza.LDPepperPizza;
import com.lh.factory.factorymethod.pizzastore.pizza.Pizza;public class LDOrderPizza extends OrderPizza{OverridePizza createPizza(String orderType) {Pizza pizza null;if (orderType.equals(cheese)) {pizza new LDCheesePizza();}else if (orderType.equals(pepper)) {pizza new LDPepperPizza();} return pizza;}
}package com.lh.factory.factorymethod.pizzastore.order;import com.lh.factory.factorymethod.pizzastore.pizza.BJCheesePizza;
import com.lh.factory.factorymethod.pizzastore.pizza.BJPepperPizza;
import com.lh.factory.factorymethod.pizzastore.pizza.Pizza;public class BJOrderPizza extends OrderPizza{OverridePizza createPizza(String orderType) {Pizza pizza null;if (orderType.equals(cheese)) {pizza new BJCheesePizza();}else if (orderType.equals(pepper)) {pizza new BJPepperPizza();}return pizza;}
}客户端
package com.lh.factory.factorymethod.pizzastore.order;public class PizzaStore {public static void main(String[] args) {//创建北京口味的各种Pizzanew BJOrderPizza();//创建伦敦口味的各种Pizzanew LDOrderPizza();}
}抽象工厂模式
基本介绍
抽象工厂模式定义了一个 interface 用于创建相关或有依赖关系的对象簇而无需指明具体的类抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。从设计层面看抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。将工厂抽象成两层AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应 的工厂子类。这样将单个的简单工厂类变成了工厂簇更利于代码的维护和扩展。类图 抽象工厂模式应用实例
Pizza类与它的子类与抽象工厂方法模式中的Pizza类和它的子类代码一样这里不做复制粘贴耐心可观看
工厂接口
package com.lh.factory.absfactory.pizzastore.order;import com.lh.factory.absfactory.pizzastore.pizza.Pizza;//一个抽象工厂模式的抽象层接口
public interface AbsFactory {//让下面的工厂子类具体实现Pizza createFactory(String orderType);}OrderType工厂类将业务需求写好之后不动此代码。直接调用即可
package com.lh.factory.absfactory.pizzastore.order;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;import com.lh.factory.absfactory.pizzastore.pizza.Pizza;public class OrderPizza {// 是聚合AbsFactory factory;//构造器public OrderPizza(AbsFactory factory) {setFactory(factory);}//指向子类实例化private void setFactory(AbsFactory factory) {Pizza pizza null;String orderType; // 用户输入披萨this.factory factory;do {orderType getType();//可能是北京或者是伦敦pizza factory.createFactory(orderType);if (pizza ! null) { //订购 okpizza.prepare();pizza.bake();pizza.cut();pizza.box();}else {System.out.println(订购失败);break;}} while (true);}// 写一个方法可以获取客户希望订购的披萨种类private String getType() {try {BufferedReader strin new BufferedReader(new InputStreamReader(System.in));System.out.println(input pizza 种类:);String str strin.readLine();return str;} catch (IOException e) {e.printStackTrace();return ;}}
}
两个工厂各自实现AbsFactory各自实现自己的功能
package com.lh.factory.absfactory.pizzastore.order;import com.lh.factory.absfactory.pizzastore.pizza.BJCheesePizza;
import com.lh.factory.absfactory.pizzastore.pizza.BJPepperPizza;
import com.lh.factory.absfactory.pizzastore.pizza.Pizza;//北京工厂子类
public class BJFactory implements AbsFactory{ Overridepublic Pizza createFactory(String orderType) {// TODO Auto-generated method stubSystem.out.println(使用的是抽象工厂模式);Pizza pizza null;if (orderType.equals(cheese)) {pizza new BJCheesePizza();}else if (orderType.equals(pepper)) {pizza new BJPepperPizza();}return pizza;}
}package com.lh.factory.absfactory.pizzastore.order;import com.lh.factory.absfactory.pizzastore.pizza.LDCheesePizza;
import com.lh.factory.absfactory.pizzastore.pizza.LDPepperPizza;
import com.lh.factory.absfactory.pizzastore.pizza.Pizza;//伦敦工厂子类
public class LDFactory implements AbsFactory{Overridepublic Pizza createFactory(String orderType) {// TODO Auto-generated method stubSystem.out.println(使用的是抽象工厂模式);Pizza pizza null;if (orderType.equals(cheese)) {pizza new LDCheesePizza();}else if (orderType.equals(pepper)) {pizza new LDPepperPizza();}return pizza;}
}工厂模式小结
工厂模式的意义 将实例化对象的代码提取出来放到一个类中统一管理和维护达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)设计模式的依赖抽象原则 创建对象实例时不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中并返回。有的书上说 变量不要直接持有具体类的引用。不要让类继承具体类而是继承抽象类或者是实现 interface(接口)不要覆盖基类中已经实现的方法。
