一、简介
1、设计模式介绍
1. 设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式【设计，思想】不是代码，
而是某类问题的通用解决方案，设计模式（Design pattern）代表了最佳的实践。这些解决方案是众多软件开
发人员经过相当长的一段时间的试验和错误总结出来的。
2. 设计模式的本质提高 软件的维护性，通用性和扩展性，并降低软件的复杂度【软件巨兽=》软件工程】。
3. <<设计模式>> 是经典的书，作者是 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides
Design（俗称 “四人组 GOF”）。
4. 设计模式并不局限于某种语言，java，php，c++ 都有设计模式。
2、设计模式类型
设计模式分为三种类型，共23种
1. 创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
2. 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
3. 行为型模式：模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式
（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)、访问者模式。
注：工作中主要用到的模式：单例模式、工厂模式、装饰模式、代理模式、观察者模式。
二、简单工厂模式
1、基本介绍
1. 简单工厂模式是属于创建型模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定
创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式；
2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)；
3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式。
2、设计一个具体的需求
披萨的项目：要便于披萨种类的扩展，要便于维护，完成披萨订购功能。
披萨簇的设计，如下:
使用传统方式完成示例代码：
1. 代码结构图：
2. 示例代码
==============================abstract class Pizza=====================================
package com.lj.akka.simplefactory.pizza
/**
* @author Administrator
* @create 2020-03-27
*/
abstract class Pizza {
var name: String = _
// 准备
// 假定每种Pizza的原材料都不同，这定义成抽象的方法
def prepare()
// 烘焙
def bake(): Unit = {
println(this.name + " 正在bake......")
}
// 切分
def cut(): Unit = {
println(this.name + " 正在cut......")
}
// 打包
def box(): Unit = {
println(this.name + " 正在box......")
}
}
==============================class ChinesePizza=====================================
package com.lj.akka.simplefactory.pizza
/**
* @author Administrator
* @create 2020-03-27
*/
class ChinesePizza extends Pizza {
override def prepare(): Unit = {
this.name = "中式Pizza"
println(this.name + "正在Prepare......")
}
}
==============================class GreekPizza=====================================
package com.lj.akka.simplefactory.pizza
/**
* @author Administrator
* @create 2020-03-27
*/
class GreekPizza extends Pizza {
override def prepare(): Unit = {
this.name = "希腊Pizza"
}
}
==============================class OrderPizza=====================================
package com.lj.akka.simplefactory.use
import com.lj.akka.simplefactory.pizza.{ChinesePizza, GreekPizza, Pizza}
import scala.io.StdIn
import scala.util.control.Breaks._
/**
* @author Administrator
* @create 2020-03-27
*/
class OrderPizza {
var orderType: String = _
var pizza: Pizza = _
breakable {
do {
print("请输入Pizza的类型：")
orderType = StdIn.readLine()
if (orderType.equals("Greek")) {
this.pizza = new GreekPizza
} else if (orderType.equals("Chinese")) {
this.pizza = new ChinesePizza
} else {
break()
}
this.pizza.prepare()
this.pizza.bake()
this.pizza.cut()
this.pizza.box()
} while (true)
}
}
==============================object PizzaStore=====================================
package com.lj.akka.simplefactory.use
/**
* @author Administrator
* @create 2020-03-27
*/
object PizzaStore {
def main(args: Array[String]): Unit = {
new OrderPizza
println("退出订购....")
}
}
3. 传统的方式的优缺点
1. 优点是比较好理解，简单易操作。
2. 缺点是违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不
修改代码，或者尽可能少修改代码；
3. 比如我们这时要新增加一个Pizza的种类(PepperPizza)，我们需要做如下修改：
3.1: 增加一个PepperPizza类
package com.lj.akka.simplefactory.pizza
class PepperPizza extends Pizza {
override def prepare(): Unit = {
this.name = "Pepper Pizza"
println(this.name + "正在Prepare......")
}
}
3.2: 增加一个判断语句(else if）
breakable {
do {
print("请输入Pizza的类型：")
orderType = StdIn.readLine()
if (orderType.equals("Greek")) {
this.pizza = new GreekPizza
} else if (orderType.equals("Chinese")) {
this.pizza = new ChinesePizza
// ---------------------增加的代码------------------------
} else if (orderType.equals("Pepper")) {
this.pizza = new PepperPizza
}
// ---------------------增加的代码------------------------
else {
break()
}
this.pizza.prepare()
this.pizza.bake()
this.pizza.cut()
this.pizza.box()
} while (true)
4. 改进的思路分析
分析：修改代码可以接受，但是如果我们在其它的地方也有创建Pizza的代码，就意味着，也需要修改，
而创建Pizza的代码，往往有多处。
思路：把创建Pizza对象封装到一个类中，这样我们有新的Pizza种类时，只需要修改该类就可，其它有
创建到Pizza对象的代码就不需要修改了，使用简单工厂模式进行重构代码。
代码结构图：新增了一个SimplePizzaFactory工厂类
说明：通过该工厂SimplePizzaFactory，可以创建指定的Pizza对象。
示例代码：
==============================class OrderPizza修改如下=====================================
package com.lj.akka.simplefactory.use
import com.lj.akka.simplefactory.pizza.Pizza
import scala.io.StdIn
import scala.util.control.Breaks._
class OrderPizza {
var orderType: String = _
var pizza: Pizza = _
val pizzaFactory = new SimplePizzaFactory
breakable {
do {
print("请输入Pizza的类型：")
orderType = StdIn.readLine()
pizza = pizzaFactory.getPizza(orderType)
if (pizza != null) {
this.pizza.prepare()
this.pizza.bake()
this.pizza.cut()
this.pizza.box()
} else {
break()
}
} while (true)
}
}
三、工厂方法模式
1、一个新的需求
披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza、北京的胡椒pizza或者
是伦敦的奶酪pizza、伦敦的胡椒pizza。
思路1
使用简单工厂模式，创建不同的简单工厂类，比如BJPizzaSimpleFactory、LDPizzaSimpleFactory等等。从当前
这个案例来说，也是可以的，但是考虑到项目的规模，以及软件的可维护性、可扩展性并不是特别的好
思路2
使用工厂方法模式
2、工厂方法模式
基本介绍
工厂方法模式设计方案：将披萨项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现。
工厂方法模式：定义一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化
推迟到子类。
工厂方法模式示例代码：
披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如北京的奶酪pizza、北京的胡椒pizza
或者是伦敦的奶酪pizza、伦敦的胡椒pizza。
第一步：添加北京或者伦敦不同口味的Pizza，代码如下图：
说明：BJPepperPizza、LDCheesePizza与BJCheesePizza写法一样，只是增加一个类去继承Pizza类
并实现Pizza里的抽象方法。
第二步：修改OrderPizza类代码
说明：由于要使用工厂抽象方法模式实现需求，此时我们需要定义该类为抽象类，并在其中定义一个抽象方法，
由对应的北京或者伦敦订购Pizza的类去继承并实现里面的抽象方法。
第三步：通过PizzaStore订购Pizza，想订那里的Pizza直接new对应的OrderPizza对象即可。
四、抽象工厂模式
1、基本介绍
1. 抽象工厂模式：定义了一个trait用于创建相关或有依赖关系的对象簇，而无需指明具体的类；
2. 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合；
3. 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)；
4. 将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应
的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。
2、抽象工厂模式完成订购Pizza的需求
2.1：第一步构造一个抽象的工厂类AbsFactory（trait）
说明：提供制作Pizza的抽象方法，该方法的实现由具体的子类去实现。
2.2：第二步重新编写订购Pizza的类OrderPizza02
2.3：第三步订购Pizza的时候我们只要传入自己想要订购不同种类的工厂即可
3、工厂模式小结
1. 工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系
的解耦。从而提高项目的扩展和维护性。
2. 三种工厂模式
3. 设计模式的依赖抽象原则
1）：创建对象实例时，不要直接new类, 而是把这个new类的动作放在一个工厂的方法中，并返回。也有的
书上说，变量不要直接持有具体类的引用；
2）：不要让类继承具体类，而是继承抽象类或者是trait（接口）；
3）：不要覆盖基类中已经实现的方法。
对以前的知识回顾，加深基础知识！
学习来自：北京尚硅谷韩顺平老师—尚硅谷大数据技术之Scala
每天进步一点点，也许某一天你也会变得那么渺小！！！
扫一扫
1881
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
