文章目录
创建型模式的主要关注点是:怎样创建对象?,它的主要特点是:将对象的创建与使用分离。
这样可以降低系统的耦合度,使用者不需要关注对象的创建细节。
创建型模式分为:
- 单例模式
- 工厂方法模式
- 抽象工程模式
- 原型模式
- 建造者模式
概述
需求:设计一个咖啡店点餐系统。
设计一个咖啡类(Coffee),并定义其两个子类:美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】
再设计一个咖啡店类(CoffeeStore),咖啡店具有点咖啡的功能。
在 Java 中,万物皆对象,这些对象都需要创建,如果创建的时候直接 new 该对象,就会对该对象耦合严重。假如我们要更换对象,所有 new 对象的地方都需要修改一遍,这显然违背了软件设计的开闭原则。
如果我们使用工厂来生产对象,我们就只和工厂打交道就可以了,彻底和对象解耦,如果要更换对象,直接在工厂里更换该对象即可,达到了与对象解耦的目的。所以说,工厂模式最大的优点就是:解耦。
- 简单工厂模式(不属于 GOF 的 23 种经典设计模式)
- 工厂方法模式
- 抽象工厂模式
简单工厂模式
简单工厂不是一种设计模式,反而比较像是一种编程习惯。
解决的问题
- 设程序中有个Computer类需要组合一个输出设备。我们让Computer类组合了一个Printer对象,如果有一天系统需要重构,要使用BetterPrinter来代替Printer,这就需要打开Computer的源码来进行修改。那如果系统中不只有Computer组合了输出设备,而是有一千、一万个类组合了这个功能呢,一个一个改显然工作量太大。因此在设计的时候就有一种方式能够避免这个问题。
- 实现了对象的创建和使用分离,我们需要什么对象不需要自己创建,直接从工厂中拿取
结构
简单工厂包含如下角色:
-
抽象产品:定义了产品的规范,描述了产品的主要特性和功能。
-
具体产品:实现或者继承抽象产品的子类。
-
具体工厂:提供了创建产品的方法,调用者通过该方法来获取产品。
-
他属于类创建型模式,在简单工厂模式中,可以根据参数的不同返回不同的实例,简单工厂模式专门定义了一个类来负责实现创建了其他类的实例,被创建的实例通常都具有共同的父类
下例中,抽象产品是咖啡抽象类,具体产品是美式咖啡和拿铁咖啡;
抽象产品:咖啡抽象类 Coffee
public abstract class Coffee {
//获取咖啡名称
public abstract String getName();
//加糖
public void addSugar(){
System.out.println("加糖");
}
//加奶
public void addMilk(){
System.out.println("加奶");
}
}
具体产品美式咖啡和拿铁咖啡
public class AmericanCoffee extends Coffee{
@Override
public String getName() {
return "美式咖啡";
}
}
public class LatteCoffee extends Coffee{
@Override
public String getName() {
return "拿铁咖啡";
}
}
生成咖啡的简单工厂类
public class SimpleCoffeeFactory {
public Coffee createCoffee(String type){
// 声明Coffee类型的变量,根据不同类型创建不同的coffee子类对象
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 class CoffeeStore {
public Coffee orderCoffee(String type){
//生产咖啡的简单工厂
SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
//调用生成咖啡的方法
Coffee coffee = factory.createCoffee(type);
//加配料
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}
存在的问题
在以上代码中,工厂处理创建对象的细节,一旦有了 SimpleCoffeeFactory,CoffeeStore 类中的 orderCoffee() 就变成此对象的客户,后期如果需要 Coffee 对象直接从工厂中获取即可,这样也就解除了和 Coffee 实现类的耦合。
-
不使用简单工厂类,比如我们需要做美式咖啡,就需要自己去new 一个 AmericanCoffee对象
-
但是又产生了新的耦合,CoffeeStore 对象和 SimpleCoffeeFactory 工厂对象的耦合,工厂对象和商品对象的耦合。
后期如果再加新品种的咖啡,我们需要修改 SimpleCoffeeFactory 的代码,违反了开闭原则
。如果工厂类的客户端可能有很多,比如创建美团外卖等,这样只需要修改工厂类的代码,省去其他的修改操作。
- **优点:**封装了创建对象的过程,可以通过参数直接获取对象。把对象的创建和业务逻辑层分开,这样以后就避免了修改客户代码,如果要实现新产品直接修改工厂类,而不需要在原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。
- **缺点:**增加新产品时还是需要修改工厂类的代码,违背了 “开闭原则”。
扩展 - 静态工厂
在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的,这就是静态工厂模式,它也不属于 23 种设计模式。
public class SimpleCoffeeFactory {
public static Coffee createCoffee(String type) {
// 声明Coffee类型的变量,根据不同类型创建不同的coffee子类对象
Coffee coffee = null;
if ("american".equals(type)) {
coffee = new AmericanCoffee();
} else if ("latte".equals(type)) {
coffee = new LatteCoffee();
} else {
throw new RuntimeException("对不起,您所点的咖啡没有");
}
return coffee;
}
}
- 这样就消除了CoffeeStore 对象和 SimpleCoffeeFactory 工厂对象的耦合
工厂方法模式
简单工厂模式违背了开闭原则,使用工厂方法模式可以完全遵循开闭原则。
解决的问题
我们的简单工厂方法有一个致命的缺点,就是不符合开放封闭的原则,我们的工厂模式就是为了解决这个问题
- 也就是在我们简单工厂中,如果我们要去新添一个产品的生产,我们就需要来改变我们原来的生产结构,但是如果是在我们的工厂模式中,我们此时的工厂类
不再负责所有产品的创建,而是给出具体的工厂必须实现的接口
,这样工厂方法模式再添加新产品的时候就不修改原来工厂类的逻辑,而是添加新的工厂子类,符合我们开放封闭原则,克服我们的简单工厂的缺点 - 类似我们生活中有一个拖拉机的工厂,有一条拖拉机的生产线,我们现在要生产奔驰,我们是让拖拉机生产线生产奔驰,还是新建一个奔驰的生产线,生产奔驰
概念
-
定义一个用于创建对象的接口(工厂),让其子类决定实例化哪个产品类对象。
-
工厂方法模式使一个产品类的实例化延迟到其工厂的子类。
结构
工厂方法模式的主要角色:
- 抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法来创建产品。
- 具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
- 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。
- 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。
- 步骤1: 创建抽象工厂类,定义具体工厂的公共接口;
- 步骤2: 创建抽象产品类 ,定义具体产品的公共接口;
- 步骤3: 创建具体产品类(继承抽象产品类) & 定义生产的具体产品;
- 步骤4:创建具体工厂类(继承抽象工厂类),定义创建对应具体产品实例的方法;
- 步骤5:外界通过调用具体工厂类的方法,从而创建不同具体产品类的实例
抽象工厂
public interface CoffeeFactory {
Coffee createCoffee();
}
具体工厂
/**
* 美式咖啡工厂,专门用来生产美式咖啡
*/
public class AmericanCoffeeFactory implements CoffeeFactory{
@Override
public Coffee createCoffee() {
return new AmericanCoffee();
}
}
/**
* 拿铁咖啡工厂,专门用来生产拿铁咖啡
*/
public class LatteCoffeeFactory implements CoffeeFactory {
public Coffee createCoffee() {
return new LatteCoffee();
}
}
咖啡店类
public class CoffeeStore {
private CoffeeFactory factory;
public void setFactory(CoffeeFactory factory) {
this.factory = factory;
}
public Coffee orderCoffee(){
Coffee coffee = factory.createCoffee();
// 加配料
coffee.addMilk();
coffee.addSugar();
return coffee;
}
}
测试类
public class Client {
public static void main(String[] args) {
CoffeeStore coffeeStore = new CoffeeStore();
coffeeStore.setFactory(new AmericanCoffeeFactory());
Coffee coffee = coffeeStore.orderCoffee();
System.out.println(coffee.getName());
}
}
存在的问题
根据以上代码可知,要增加产品类时也要增加相应地工厂类,从而不需要修改其他工厂类的代码,这样就满足了开闭原则。
工厂方法模式是简单工厂模式的进一步抽象,不仅保持了简单工厂模式的优点,而且克服了它的缺点。
优缺点
优点:
- 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程。
- 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则。
缺点:
- 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类,增加了系统的复杂度。
抽象工厂模式
工厂方法模式:一个工厂生产一种类对象的模式。
抽象工厂模式:一个工厂可以生产多种类对象的模式。
下图所示横轴是产品等级,也就是同一类产品;纵轴是产品族,也就是同一品牌的产品,同一品牌的产品产自同一个工厂。
- 比如我们的台式电脑、笔记本电脑、苹果电脑都是同一个级别
- 再比如我们的苹果电脑和苹果手机是同一个产品族
- 商务风的一套都是同一产品族,运动风的一套是统一产品族
- 而我们的皮鞋和我们的运动鞋是同一级别
解决的问题
- 在我们的工厂方法模式中,如果一个产品就对应了一个工厂类,那么如果产品很多,必然需要大量的类,导致类爆炸
- 比如我们上面的咖啡店的例子,现在咖啡店只是生产咖啡这一个种类,但是如果咖啡店变成了甜品店,不止有咖啡,还有其他甜品,比如冰淇淋,有美式冰淇淋和拿铁冰淇淋,那么我们需要创建一个冰淇淋的抽象类,然后有子类 美式冰淇淋和拿铁冰淇淋,还有对应的冰淇淋抽象工厂,和其实现类 美式冰淇淋工厂和拿铁冰淇淋工厂
- 让抽象咖啡工厂变成抽象甜品工厂,能生产咖啡又能生产冰淇淋
- 我们为何不让我们的美式咖啡工厂变成美式工厂呢?能生产美式咖啡又能生产美式冰淇淋
- 美式冰淇淋和拿铁冰淇淋属于同一级别
- 美式咖啡和美式冰淇淋属于同一产品族
- 这样就可以实现减少我们相关的类的产生
结构
抽象工厂模式的主要角色如下:
- 抽象工厂:提供了创建产品的接口,它包含多个创建产品的方法,可以创建多个同一产品族不同等级的产品。
- 具体工厂:主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。
- 抽象产品:定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。
- 具体产品:实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间是多对一的关系。
现咖啡店业务发生改变,不仅要生产咖啡还要生产甜点,如提拉米苏、抹茶慕斯等。是按照工厂方法模式,需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类,很容易发生类爆炸情况。拿铁咖啡、美式咖啡是一个产品等级,都是咖啡;提拉米苏、抹茶慕斯也是一个产品等级,都是甜品;拿铁咖啡、提拉米苏是同一产品族,都属于意大利风味;美式咖啡、抹茶慕斯是同一产品族,都属于美式风味;
抽象工厂
/**
* 甜品工厂
*/
public interface DessertFactory {
// 生产咖啡的功能
Coffee createCoffee();
// 生产甜品的功能
Dessert createDessert();
}
具体工厂
/**
* 美式风味的甜品工厂
* 生产美式咖啡和抹茶慕斯
*/
public class AmericanDessertFactory implements DessertFactory {
@Override
public Coffee createCoffee() {
return new AmericanCoffee();
}
@Override
public Dessert createDessert() {
return null;
}
}
/**
* 意大利风味的甜品工厂
* 生产拿铁咖啡和提拉米苏甜品
*/
public class ItalyDessertFactory implements DessertFactory {
@Override
public Coffee createCoffee() {
return new LatteCoffee();
}
@Override
public Dessert createDessert() {
return new MatchaMousseDessert();
}
}
测试
public class Client {
public static void main(String[] args) {
// 创建的是意大利风味甜品工厂对象
ItalyDessertFactory factory = new ItalyDessertFactory();
// 获取拿铁咖啡和提拉米苏甜品
Coffee coffee = factory.createCoffee();
Dessert dessert = factory.createDessert();
System.out.println(coffee.getName());
dessert.show();
}
}
如果要加同一个产品族的话,只需要再加一个对应的工厂类即可,不需要修改其他的类。
存在的问题
优点:
-
当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
-
想要生产一个产品族的产品,只需要一个接口或类。
缺点:
-
当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改。
-
抽象工厂模式也不符合开闭原则,在扩展性和可用性上进行了权衡
使用场景
-
当需要创建的对象是一系列相互关联或相互依赖的产品族时,如电器工厂中的电视机、洗衣机、空调等。
-
系统中有多个产品族,但每次只使用其中的某一族产品,如有人只喜欢穿某一个品牌的衣服和鞋。
-
系统中提供了产品的类库,且所有产品的接口相同,客户端不依赖产品实例的创建细节和内部结构。
如:输入法换皮肤,一整套一起换。生成不同操作系统的程序。
扩展:简单工厂 + 配置文件
可以通过工厂模式 + 配置文件的方式解除工厂对象和产品对象的耦合。
在工厂类中加载配置文件中的全类名,并创建对象进行存储,客户端如果需要对象,直接进行获取即可。
第一步:定义配置文件 bean.properties(使用 .properties 是为了方便演示)
bean.properties
american=com.lsc.itheima.pattern.factory.demo4.AmericanCoffee
latte=com.lsc.itheima.pattern.factory.demo4.LatteCoffee
public class SimpleCoffeeFactory {
//加载配置文件,获取配置文件中的全类名,通过反射创建并进行存储
//1定义存储咖啡对象的容器
private static HashMap<String, Coffee> map=new HashMap<>();
//2加载配置文件,只需要加载一次
static {
//2.1创建properties对象
Properties p=new Properties();
InputStream resourceAsStream = SimpleCoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
try {
p.load(resourceAsStream);
Set<Object> keys = p.keySet();
for (Object key: keys) {
String className = p.getProperty((String) key);
//通过反射技术创建对象
Class clazz = Class.forName(className);
Coffee coffee = (Coffee) clazz.newInstance();
//将名称和对象存储到容器中
map.put((String) key,coffee);
};
} catch (IOException | ClassNotFoundException | InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
//根据名称获取对象
public static Coffee createCoffee(String name) {
return map.get(name);
}
}
静态成员变量用来存储创建的对象,键存储的是名称,值存储的是对应的对象;读取配置文件以及创建对象写在静态代码块中,目的就是只需要执行一次。
public class Client {
public static void main(String[] args) {
System.out.println(SimpleCoffeeFactory.createCoffee("american"));
}
}
JDK源码 - Collection.iterator
public class Demo {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("令狐冲");
list.add("风清扬");
list.add("任我行");
// 获取迭代器对象
Iterator<String> it = list.iterator();
// 使用迭代器遍历
while(it.hasNext()) {
String ele = it.next();
System.out.println(ele);
}
}
}
在单列集合获取迭代器的方法就使用到了工厂方法模式,我们通过类图看看结构:
- Collection 接口是抽象工厂类,ArrayList 是具体的工厂类;
- Iterator 接口是抽象商品类,ArrayList 类中的 Iter 内部类是具体的产品类;
- 在具体的工厂类中 iterator() 方法创建具体的产品类的对象。
DateForamt 类中的 getInstance() 方法使用的是工厂模式
Calendar 类中的 getInstance() 方法使用的是工厂模式