企业网站wordpress,茶叶公司网站源码,建设项目自主验收网站,seo免费课程视频文章目录 五.工厂模式5.1 概述5.2简单工厂模式5.2.1 概述5.2.2 结构5.2.3 实现5.2.4 优缺点5.2.5 扩展—静态工厂 5.3 工厂方法模式5.3.1概述5.3.2 结构5.3.3 实现5.3.4 优缺点 5.4 抽象工厂模式5.4.1 概述5.4.2 结构5.4.3 实现5.4.4 优缺点5.4.5 使用场景 5.5 工厂模式扩展 五… 文章目录 五.工厂模式5.1 概述5.2简单工厂模式5.2.1 概述5.2.2 结构5.2.3 实现5.2.4 优缺点5.2.5 扩展—静态工厂 5.3 工厂方法模式5.3.1概述5.3.2 结构5.3.3 实现5.3.4 优缺点 5.4 抽象工厂模式5.4.1 概述5.4.2 结构5.4.3 实现5.4.4 优缺点5.4.5 使用场景 5.5 工厂模式扩展 五.工厂模式
5.1 概述
引入工厂概念
需求设计一个咖啡店点餐系统。
设计一个咖啡类Coffee并定义其两个子类美式咖啡AmericanCoffee和拿铁咖啡LatteCoffee再设计一个咖啡店类CoffeeStore咖啡店具有点咖啡的功能。
具体类的设计如下 //咖啡类
public abstract class Coffee {public abstract String getName();public void addMilk(){System.out.println(加奶...);}public void addSugar(){System.out.println(加糖...);}
}//美式咖啡类
public class AmericanCoffee extends Coffee{Overridepublic String getName() {return 美式咖啡;}public void show(){System.out.println(我是美式咖啡....);}
}//拿铁咖啡类
public class LatteCoffee extends Coffee{Overridepublic String getName() {return 拿铁咖啡;}
}//咖啡店类
public class CoffeeStore {public Coffee orderCoffee(String type){Coffee coffee null;if (american.equals(type)){//多态coffee new AmericanCoffee();}else if (latte.equals(type)){//多态coffee new LatteCoffee();}else {throw new RuntimeException(没有这种咖啡);}// 咖啡加糖加奶coffee.addMilk();coffee.addSugar();return coffee;}
}
public class Test {public static void main(String[] args) {// 创建咖啡店类CoffeeStore coffeeStore new CoffeeStore();// 点咖啡多态Coffee coffee coffeeStore.orderCoffee(latte);//Coffee coffee2 coffeeStore.orderCoffee(american);// coffee.show();//多态调用不到子类特有的方法// 获取所点咖啡的名字String name coffee.getName();System.out.println(name);//输出加奶... 加糖... 拿铁咖啡}
}在java中万物皆对象对象都需要创建如果创建的时候直接new该对象就会对该对象耦合严重CoffeeStore类和AmericanCoffee类以及LatteCoffee类的耦合假如我们要更换对象(即添加一个新的咖啡品种)所有new对象的地方都需要修改一遍这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象我们就只和工厂打交道就可以了彻底和对象(这里指的是具体的咖啡对象)解耦如果要更换对象直接在工厂里更换该对象即可达到了与对象解耦的目的所以说工厂模式最大的优点就是解耦。
5.2简单工厂模式
5.2.1 概述
简单工厂不是一种设计模式反而比较像是一种编程习惯。
不属于GOF的23种经典设计模式
5.2.2 结构
简单工厂包含下角色
抽象产品定义了产品的规范描述了产品的主要特性和功能具体产品实现或者继承抽象产品的子类具体工厂提供了创建具体产品的方法调用者通过该方法获取产品对象
5.2.3 实现
对5.1 中案列进行修改 // 咖啡工厂
public class SimpleFactory {//提供方法,创建具体咖啡public Coffee createCoffee(String type){Coffee coffee null;if (american.equals(type)){coffee new AmericanCoffee(); //多态}else if (latte.equals(type)){coffee new LatteCoffee(); //多态}else {throw new RuntimeException(没有这种咖啡);}return coffee;}
}
// 咖啡类(父类)--抽象类
public abstract class Coffee {//每个咖啡都有名字所以抽取到父类定义为抽象方法public abstract String getName();public void addMilk(){System.out.println(加奶...);}public void addSugar(){System.out.println(加糖...);}
}
// 美式咖啡类 继承 咖啡类
public class AmericanCoffee extends Coffee {Overridepublic String getName() {return 美式咖啡;}public void show(){System.out.println(我是美式咖啡....);}
}
// 拿铁咖啡类 继承 咖啡类
public class LatteCoffee extends Coffee {Overridepublic String getName() {return 拿铁咖啡;}
}
// 咖啡店类
public class CoffeeStore {public Coffee orderCoffee(String type){//此处解除了咖啡店类和具体的咖啡类的依赖降低了耦合// 创建工厂对象目的是创建具体的咖啡SimpleFactory sf new SimpleFactory();// 创建咖啡返回具体的咖啡对象Coffee coffee sf.createCoffee(type);coffee.addSugar();coffee.addMilk();// 将具体的咖啡对象返回return coffee;}
}
public class Test {public static void main(String[] args) {// 创建咖啡店对象进行点咖啡CoffeeStore store new CoffeeStore();//隐含了多态在工厂里Coffee coffee store.orderCoffee(american);String name coffee.getName();System.out.println(name);//输出加奶... 加糖... 美式咖啡}
}工厂处理创建对象的细节一旦有了SimpleCoffeeFactory类CoffeeStore类中的orderCoffee就变成了SimpleCoffeeFactory类的客户后期如果需要Coffee对象直接从工厂获取即可。这样解除了具体咖啡类和Coffee类的耦合同时又产生了新的耦合如CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合工厂对象和具体咖啡对象的耦合。
后期如果再加新品种的咖啡我们势必要需求修改SimpleCoffeeFactory的代码违反了开闭原则。但是工厂类的客户端可能有很多比如创建美团外卖等这样只需要修改工厂类的代码省去其他的修改操作。
5.2.4 优缺点
优点
封装了创建对象的过程可以通过参数直接获取对象。把对象的创建和业务逻辑层分开这样以后就避免了修改客户代码如果要实现新产品直接修改工厂类而不需要在原代码中修改这样就降低了客户代码修改的可能性更加容易扩展。
缺点
增加新产品时还是需要修改工厂类的代码违背了“开闭原则”。
5.2.5 扩展—静态工厂
将工厂类中的创建对象的功能定义为静态的这个就是静态工厂模式它也不是23种设计模式中的。代码如下
// 咖啡工厂-----静态工厂
public class SimpleFactory {// 工厂类中的创建对象的功能定义为静态就是静态工厂模式public static Coffee createCoffee(String type){Coffee coffee null;if (american.equals(type)){//多态coffee new AmericanCoffee();}else if (latte.equals(type)){//多态coffee new LatteCoffee();}else {throw new RuntimeException(没有这种咖啡);}return coffee;}
}
// 咖啡类(父类)
public abstract class Coffee {public abstract String getName();public void addMilk(){System.out.println(加奶...);}public void addSugar(){System.out.println(加糖...);}
}
// 美式咖啡类
public class AmericanCoffee extends Coffee {Overridepublic String getName() {return 美式咖啡;}public void show(){System.out.println(我是美式咖啡....);}
}
// 拿铁咖啡类
public class LatteCoffee extends Coffee {Overridepublic String getName() {return 拿铁咖啡;}
}
// 咖啡店类
public class CoffeeStore {public Coffee orderCoffee(String type){//此处解除了咖啡店类和具体的咖啡类的依赖降低了耦合// // 创创建工厂对象目的是创建具体的咖啡// SimpleFactory sf new SimpleFactory();// // 创建咖啡返回具体的咖啡对象// Coffee coffee sf.createCoffee(type);// 用静态工厂模式就不用创建工厂对象//直接用工厂类名调用里面的创建具体咖啡对象的静态方法即可Coffee coffee SimpleFactory.createCoffee(type);coffee.addSugar();coffee.addMilk();// 将具体的咖啡对象返回return coffee;}
}
public class Test {public static void main(String[] args) {// 创建咖啡店对象进行点咖啡CoffeeStore store new CoffeeStore();//隐含了多态在工厂里Coffee coffee store.orderCoffee(american);String name coffee.getName();System.out.println(name);}
}5.3 工厂方法模式
针对5.2.3中的缺点使用工厂方法模式就可以完美的解决完全遵循开闭原则。
5.3.1概述
工厂方法模式定义一个创建对象的接口这里的接口指的是工厂让子类子类 指实现工厂接口的子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。
5.3.2 结构
工厂方法模式的主要角色
抽象工厂Abstract Factory提供了创建产品的接口调用者通过抽象工厂访问具体工厂多态的工厂方法来创建产品对象。具体工厂ConcreteFactory主要是实现抽象工厂中的抽象方法完成具体产品的创建。抽象产品Product定义了产品的规范描述了产品的主要特性和功能。具体产品ConcreteProduct实现了抽象产品角色所定义的接口由具体工厂来创建它同具体工厂之间一一对应。
5.3.3 实现
使用工厂方法模式对5.2.3中的案列进行改进类图如下 // 咖啡抽象类
public abstract class Coffee {public abstract String getName();public void addMilk(){System.out.println(加奶...);}public void addSugar(){System.out.println(加糖...);}
}
//拿铁咖啡类 实现 抽象咖啡类接口public class LatteCoffee extends Coffee{Overridepublic String getName() {return 拿铁咖啡;}
}
// 美式咖啡类 实现 抽象咖啡类接口
public class AmericanCoffee extends Coffee{Overridepublic String getName() {return 美式咖啡;}
}// 定义咖啡工厂接口
public interface CoffeeFactory {public abstract Coffee creatCoffee();
}
// 创建拿铁咖啡工厂类 实现 咖啡工厂类接口
public class LatteCoffeeFactory implements CoffeeFactory{Overridepublic Coffee creatCoffee() {return new LatteCoffee();}
}
// 创建美式咖啡工厂类 实现 咖啡工厂类接口
public class AmericanCoffeeFactory implements CoffeeFactory {Overridepublic Coffee creatCoffee() {return new AmericanCoffee();}
}
//咖啡店类public class CoffeeStore {private CoffeeFactory coffeeFactory;public void setCoffeeFactory(CoffeeFactory coffeeFactory) {this.coffeeFactory coffeeFactory;}public Coffee orderCoffee(){// 咖啡工厂来创建具体的咖啡Coffee coffee coffeeFactory.creatCoffee();// 加配料coffee.addMilk();coffee.addSugar();return coffee;}}
public class ClientTest {public static void main(String[] args) {// 创建咖啡店类对象CoffeeStore coffeeStore new CoffeeStore();//创建拿铁咖啡工厂多态CoffeeFactory coffeeFactory new LatteCoffeeFactory();//CoffeeFactory amerFactory new AmericanCoffeeFactory();coffeeStore.setCoffeeFactory(coffeeFactory);// 点咖啡Coffee coffee coffeeStore.orderCoffee();System.out.println(coffee.getName());//输出加奶... 加糖... 拿铁咖啡}
}5.3.4 优缺点
优点
用户只需要知道具体工厂的名称就可得到所要的产品无须知道产品的具体创建过程在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类无须对原工厂进行任何修改满足开闭原则
缺点
每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类这增加了系统的复杂度。
5.4 抽象工厂模式
5.4.1 概述
是一种为访问类提供一个创建一组相关或相互依赖对象的接口且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。同族的不同等级的产品:通俗讲就是一个综合工厂里的不同商品种类抽象工厂模式是工厂方法模式的升级版本工厂方法模式只生产一个等级即同种的产品的产品而抽象工厂模式可生产多个等级即多种产品的产品。
5.4.2 结构
抽象工厂模式的主要角色如下
抽象工厂Abstract Factory提供了创建产品的接口它包含多个创建产品的方法可以创建多个不同等级的产品。具体工厂Concrete Factory主要是实现抽象工厂中的多个抽象方法完成具体产品的创建。抽象产品Product定义了产品的规范描述了产品的主要特性和功能抽象工厂模式有多个抽象产品。具体产品ConcreteProduct实现了抽象产品角色所定义的接口由具体工厂来创建它 同具体工厂之间是多对一的关系。
5.4.3 实现
现咖啡店业务发生改变不仅要生产咖啡还要生产甜点如提拉米苏、抹茶慕斯等要是按照工厂方法模式需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级都是咖啡提拉米苏、抹茶慕斯也是一个产品等级拿铁咖啡和提拉米苏是同一产品族也就是都属于意大利风味美式咖啡和抹茶慕斯是同一产品族也就是都属于美式风味。所以这个案例可以使用抽象工厂模式实现。类图如下 咖啡系列
// 抽象咖啡类
public abstract class Coffee {// 定义获取具体咖啡名字的规范public abstract String getName();// 咖啡加奶public void addMilk(){System.out.println(加奶...);};// 咖啡加糖public void addSugar(){System.out.println(加糖...);};
}// 具体的 美式咖啡类 继承抽象咖啡类
public class AmericanCoffee extends Coffee{Overridepublic String getName() {return 美式咖啡;}
}
// 具体的 拿铁咖啡类 继承抽象咖啡类
public class LatteCoffee extends Coffee{Overridepublic String getName() {return 拿铁咖啡;}
}
甜品系列
// 抽象甜品类
public abstract class Dessert {// 定义展示具体甜品的规范public abstract void show();
}
// 具体甜品--提拉米苏类 继承 抽象甜品类
public class Tiramisu extends Dessert{Overridepublic void show() {System.out.println(提拉米苏...);}
}
// 具体甜品--抹茶慕斯类 继承 抽象甜品类
public class MatchaMousse extends Dessert {Overridepublic void show() {System.out.println(抹茶慕斯...);}
}工厂系列 //抽象工厂// 综合工厂 生产咖啡类 生产甜品类
public interface DessertFactory {// 生产咖啡public abstract Coffee createCoffee();// 生产甜品public abstract Dessert createDessert();}
//具体工厂// 意大利风味甜品工厂// 生产拿铁咖啡和提拉米苏甜品
public class ItalyDessertFactory implements DessertFactory{// 生产拿铁咖啡Overridepublic Coffee createCoffee() {return new LatteCoffee();}// 生产提拉米苏Overridepublic Dessert createDessert() {return new Tiramisu();}
}
//具体工厂// 美式风味的甜品工厂// 生美式咖啡 和 抹茶慕斯
public class AmericanDessertFactory implements DessertFactory{// 生产美式咖啡Overridepublic Coffee createCoffee() {return new AmericanCoffee();}// 生产抹茶慕斯Overridepublic Dessert createDessert() {return new MatchaMousse();}
}
客户端测试
public class ClientTest {public static void main(String[] args) {
// 客户端测试类// 创建意大利风味甜品工厂对象// 该工厂生产拿铁咖啡 和提拉米苏ItalyDessertFactory factory new ItalyDessertFactory();// 获取拿铁咖啡Coffee coffee factory.createCoffee();System.out.println(coffee.getName());//拿铁咖啡// 获取提拉米苏Dessert dessert factory.createDessert();dessert.show();//提拉米苏...// 创建美式风味的甜品工厂对象//该工厂生产美式咖啡 和抹茶慕斯AmericanDessertFactory factory1 new AmericanDessertFactory();// 获取美式咖啡Coffee coffee1 factory1.createCoffee();System.out.println(coffee1.getName());//美式咖啡// 获取抹茶慕斯Dessert dessert1 factory1.createDessert();dessert1.show();//抹茶慕斯...}
}如果要加同一个产品族的话只需要再加一个对应的工厂类即可不需要修改其他的类。
5.4.4 优缺点
优点
当一个产品族中的多个对象被设计成一起工作时它能保证客户端始终只使用同一个产品族中的对象。
缺点
当产品族中需要增加一个新的产品时所有的工厂类都需要进行修改。
5.4.5 使用场景 当需要创建的对象是一系列相互关联或相互依赖的产品族时如电器工厂中的电视机、洗衣机、空调等。 系统中有多个产品族但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。 系统中提供了产品的类库且所有产品的接口相同客户端不依赖产品实例的创建细节和内部结构。
如输入法换皮肤一整套一起换。生成不同操作系统的程序。
5.5 工厂模式扩展
简单工厂配置文件解除耦合
spring底层类似
可以通过工厂模式配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名并通过反射技术创建对象进行存储客户端如果需要对象直接进行获取即可。
为了演示方便我们使用properties文件作为配置文件名称为bean.properties
americanfactory.config_factory.AmericanCoffee
lattefactory.config_factory.LatteCoffee#如果冰咖啡饮品直接添加全类名即可,咖啡工厂中代码不用修改
icecoffee factory.config_factory.IceCoffee//咖啡工厂
public class CoffeeFactory {//加载配置文件获取配置文件中配置的全类名并创建全类名的类的对象进行存储// 1.定义容器存储咖啡对象private static MapString,Coffee map new HashMap();// 2.静态代码块 加载配置文件只需加载一次static {// 2.1创建Properties对象Properties p new Properties();// 2.2调用p对象中的load方法进行配置文件的加载InputStream is CoffeeFactory.class.getClassLoader().getResourceAsStream(bean.properties);try {p.load(is);//从p集合中获取全名并创建对象//遍历Properties集合对象SetObject keys p.keySet();for (Object key : keys) {//根据键获取值全类名String className p.getProperty((String) key);// 通过反射技术创建对象//获取字节码对象Class clazz Class.forName(className);Coffee obj (Coffee) clazz.newInstance();map.put((String)key,obj);}} catch (Exception e) {e.printStackTrace();}}// 根据名称获取对象public static Coffee createCoffee(String name) {return map.get(name);}}// 咖啡类(父类)
public abstract class Coffee {public abstract String getName();public void addMilk(){System.out.println(加奶...);}public void addSugar(){System.out.println(加糖...);}
}
// 美式咖啡类
public class AmericanCoffee extends Coffee {Overridepublic String getName() {return 美式咖啡;}public void show(){System.out.println(我是美式咖啡....);}
}
// 拿铁咖啡类
public class LatteCoffee extends Coffee {Overridepublic String getName() {return 拿铁咖啡;}
}
//新增冰咖啡饮品咖啡工厂类不用修改
public class MiXue extends Coffee{Overridepublic String getName() {return 冰咖啡;}
}
public class Test {public static void main(String[] args) {//直接通过配置文件中对应的美式咖啡名字 获取美式咖啡对象Coffee american CoffeeFactory.createCoffee(american);american.addMilk();american.addSugar();System.out.println(american.getName());//直接通过配置文件中对应的冰咖啡名字 获取冰咖啡对象//新增冰咖啡Coffee icecoffee CoffeeFactory.createCoffee(icecoffee);icecoffee.addSugar();icecoffee.addMilk();System.out.println(icecoffee.getName());}
}
