设计模式之简单工厂,工厂方法,抽象工厂模式-01

学习设计模式的必要性
1) 面试会被问，所以必须学
2) 读源码时看到别人在用，尤其是一些框架大量使用到设计模式，不学看不懂源码为什么这样写，
比如 Runtime 的单例模式.
3) 设计模式能让专业人之间交流方便
4) 提高代码的易维护
5) 设计模式是编程经验的总结，我的理解： 即通用的编程应用场景的模式化，套路化（站在软件
设计层面思考）。

设计模式的介绍
1) 设计模式是程序员在面对同类软件工程设计问题所总结出来的有用的经验，模式【设计，思想】
不是代码，而是某类问题的通用解决方案，设计模式（Design pattern）代表了最佳的实践。这些解决方
案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
2) 设计模式的本质提高 软件的维护性，通用性和扩展性，并降低软件的复杂度【软件巨兽=》软
件工程】。
3) <<设计模式>> 是经典的书，作者是 Erich Gamma、Richard Helm、Ralph Johnson 和 John
Vlissides Design（俗称 “四人组 GOF”）
4) 设计模式并不局限于某种语言，java，php，c++ 都有设计模式.

设计模式类型
设计模式分为三种类型，共 23 种
1) 创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
2) 结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
3) 行为型模式：模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、
解释器模式（Interpreter 模式）、状态模式、策略模式、职责链模式(责任链模式)、访问者模式。

简单工厂
基本介绍
1) 简单工厂模式是属于创建型模式，但不属于 23 种 GOF 设计模式之一。简单工厂模式是由一个
工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
2) 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
3) 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式.

pizz父类

abstract class Pizza {
  var name: String = _
  //假定，每种pizza 的准备原材料不同，因此做成抽象的..
  def prepare() //抽象方法
  def cut(): Unit = {
    println(this.name + " cutting ..")
  }
  def bake(): Unit = {
    println(this.name + " baking ..")
  }
  def box(): Unit = {
    println(this.name + " boxing ..")
  }

}

其中一个pizz种类 

class GreekPizza extends Pizza {
  override def prepare(): Unit = {
    this.name = "希腊pizza"
    println(this.name + " preparing")
  }
}

class PepperPizza extends Pizza{
  override def prepare(): Unit = {
    this.name = "胡椒pizza"
    println(this.name + " preparing")
  }
}

简单工厂 

object SimpleFactory {
  //提供了一个创建Pizza的方法,有需要创建Pizza调用该方法即可
  def createPizza(t: String): Pizza = {
    var pizza: Pizza = null
    if (t.equals("greek")) {
      pizza = new GreekPizza
    } else if (t.equals("pepper")) {
      pizza = new PepperPizza
    } 
    return pizza
  }
}

主程序 

class OrderPizza {
  var orderType: String = _
  var pizza: Pizza = _
  breakable {
    do {
      println("请输入pizza的类型 使用简单工厂模式~~")
      orderType = StdIn.readLine()
      pizza = SimpleFactory.createPizza(orderType)
      if (pizza == null) {
        break()
      }
      this.pizza.prepare()
      this.pizza.bake()
      this.pizza.cut()
      this.pizza.box()
    } while (true)
  }
}
object TestPizz{
  def main(args: Array[String]): Unit = {
    new OrderPizza
  }
}

如果pizz扩展的话,只需要添加类继承pizz,然后工厂里添加一个if,else就可以了,不需要修改主程序.

 

工厂方法模式
看一个新的需求
披萨项目新的需求：客户在点披萨时，可以点不同口味的披萨，比如 北京的奶酪 pizza、北京的胡
椒 pizza 或者是伦敦的奶酪 pizza、伦敦的胡椒 pizza。

 

pizz进行了分区域

class BJCheesePizza extends Pizza{
  override def prepare(): Unit = {
    this.name = "北京奶酪Pizza"
    println(this.name + " preparing..")
  }
}

class BJPepperPizza extends Pizza{
  override def prepare(): Unit = {
    this.name = "北京胡椒Pizza"
    println(this.name + " preparing..")
  }
}

 主程序

//这里我们将OrderPizza 做成抽象类
abstract class OrderPizza {
  breakable {
    var orderType: String = null
    var pizza: Pizza = null
    do {
      println("请输入pizza的类型 使用工方法模式~~")
      orderType = StdIn.readLine()
      pizza = createPizza(orderType)
      if (pizza == null) {
        break()
      }
      pizza.prepare()
      pizza.bake()
      pizza.cut()
      pizza.box()
    } while (true)
  }
  //抽象的方法，createPizza(orderType),让各个子类的实现Order
  def createPizza(t:String):Pizza
}
object PizzaStore {
  def main(args: Array[String]): Unit = {
    new BJOrderPizza
  }
}

北京分店 

class BJOrderPizza extends OrderPizza {
  override def createPizza(t: String): Pizza = {
    var pizza: Pizza = null
    if (t.equals("cheese")) {
      pizza = new BJCheesePizza
    } else if (t.equals("pepper")) {
      pizza = new BJPepperPizza
    }
    pizza
  }
}

 

抽象工厂模式
17.6.1 基本介绍
1) 抽象工厂模式：定义了一个 trait 用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2) 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。
3) 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
4) 将工厂抽象成两层，AbsFactory( 抽象工厂) 和  具体实现的工厂子类。程序员可以根据创建对
象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

 

抽象工厂

trait AbsFactory {
  //一个抽象方法
  def  createPizza(t : String ): Pizza
}

北京工厂 

//这时一个实现了AbsFacotory的一个子工厂类
//如果我们希望订购北京的Pizza就使用该工厂子类
class BJFactory extends AbsFactory {
  override def createPizza(t: String): Pizza = {
    var pizza: Pizza = null
    if (t.equals("cheese")) {
      pizza = new BJCheesePizza
    } else if (t.equals("pepper")) {
      pizza = new BJPepperPizza
    }
    return pizza
  }
}

需要哪个地方的pizz之间创建哪个地方的工厂就可以了, 

//OrderPizza ,当我们使用抽象工厂模式后，我们订购一个Pizza思路
//1.接收一个子工厂实例，根据该工厂的创建要求去实例
class OrderPizza {
  var absFactory: AbsFactory = _
  def this(absFactory: AbsFactory) {
    //多态
    this
    breakable {
      var orderType: String = null
      var pizza: Pizza = null
      do {
        println("请输入pizza的类型 ,使用抽象工厂模式...")
        orderType = StdIn.readLine()
        //使用简单工厂模式来创建对象.
        pizza = absFactory.createPizza(orderType)
        if (pizza == null) {
          break()
        }
        pizza.prepare()
        pizza.bake()
        pizza.cut()
        pizza.box()
      } while (true)
    }
  }
}
object PizzaStore {
  def main(args: Array[String]): Unit = {
    new OrderPizza(new BJFactory)
    //new OrderPizza(new LDFactory)
  }
}