18_Scala_设计模式_工厂模式_单例模式

设计模式 (23种)

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

工厂模式的意义 将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦 

简单工厂模式
1 是由一个工厂对象object决定创建出哪一种产品类的实例。
2 定义了一个创建对象的类，由这个类来封装实例化对象的行为

abstract  class simpleCake {
  var name: String = _
  def prepare()
  def send(): Unit = {
    println(this.name + "外卖")
  }}


class AlexCake extends  simpleCake {
  override def prepare(): Unit = {
    this.name = "alexCake"
    println(this.name + "已经准备")
  }}

class  BobCake extends  simpleCake {
  override def prepare(): Unit = {
    this.name = "bobCake"
    println(this.name + "已经发出")
  }}

// object 静态的
// 定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
object SimpleFactory {
  def createCake(t: String): simpleCake ={
    var simple: simpleCake = null
    if (t.equals("alex")) {
      simple = new AlexCake
    }
    if (t.equals("bob")){
      simple = new BobCake
    }
    simple
  }}



class OrderCake {
  var orderType: String = _
  var sCake: simpleCake = _
  breakable{
    do {
      println("开始准备蛋糕，输入类型： ")
      val str = StdIn.readLine()
      // 由一个工厂对象决定创建出哪一种产品类的实例。
      sCake =  SimpleFactory.createCake(str)
      if (sCake == null){break()}
      sCake.prepare()
      sCake.send()
    } while (true)
  }}


object TEST {
  def main(args: Array[String]): Unit = {
    val cake = new OrderCake
  }}

抽象工厂模式

1 定义了一个trait用于创建相关或有依赖关系的对象簇，而无需指明具体的类
2 将工厂抽象成两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。
3 根据创建对象类型使用对应的工厂子类

Details
创建对象实例时，不要直接 new 类, 而是把这个new 类的动作放在一个工厂的方法中，并返回。
不要让类继承具体类，而是继承抽象类或者是trait（接口）

abstract  class Coffee {
  var coffee_name: String = _
  def prepare

  def send () ={
    println(this.coffee_name + "已经发出")
  }}

class AlexCoffee extends  Coffee {
  override def prepare: Unit = {
    this.coffee_name = "alex"
    println(this.coffee_name + "已经准备")
  }}


class BobCoffee extends  Coffee {
  override def prepare: Unit = {
    this.coffee_name = "bob"
    println(this.coffee_name + "已经准备")
  }}

trait AbsFactory {
  //trait用于创建相关或有依赖关系的对象簇
  def createCoffee (t: String ) : Coffee
}


class AmaricaCoffeeFactory extends  AbsFactory {
  //这时一个实现了AbsFacotory的一个子工厂类
  override def createCoffee(t: String): Coffee = {
    var Acoffee : Coffee = null
    if (t.equals("alex")){
      Acoffee = new AlexCoffee
    }
    else if(t.equals("bob")){
      Acoffee = new BobCoffee
    }
    Acoffee
  }}

//1.接收一个子工厂实例，根据该工厂的创建要求去实例
class OrderCoffee {
  var absFactory: AbsFactory = _

  // 多态
  def this(absFactory: AbsFactory) = {
    this
    breakable {
      var coffeetype: String = null
      var coffee: Coffee = null
      do {
        println("开始准备咖啡，输入类型： ")
        coffeetype = StdIn.readLine()
        //使用建单工厂模式来创建对象.  某类的工厂簇
        coffee = absFactory.createCoffee(coffeetype)
        if (coffee == null) {break()}
        coffee.prepare
        coffee.send()
      } while (true)
    }
  }}

单例模式：保证在整个的软件系统中，某个类只能存在一个对象实例 例 Akka [ActorySystem 单例]
Scala中没有静态的概念，可以直接采用类对象(即伴生对象)方式构建单例对象

方式1-懒汉式  var lanhansample: LanHanTon = null
方式2-饿汉式  val ehanSample = new EhanTon

object lanhanTest {
  def main(args: Array[String]): Unit = {
    val ins1: LanHanTon = LanHanTon.getinstance
    val ins2: LanHanTon = LanHanTon.getinstance
    println(ins1 == ins2)
  }
}

//将SingleTon的构造方法私有化
class LanHanTon private() {

}
//懒汉式
//看底层
/*
  public SingleTon getInstance() {
    if (s() == null) {
      s_$eq(new SingleTon());}
    return s();
  }
 */

object LanHanTon {
  private var lanhansample: LanHanTon = null

  def getinstance = {
    if (lanhansample == null) {
      lanhansample = new LanHanTon
    }
    lanhansample
  }}

object  ehanTest {
  def main(args: Array[String]): Unit = {
    val ins1 = EhanTon.getInstance
    val ins2 = EhanTon.getInstance
    println(ins1 == ins2  )
  }}

//将EhanTon的构造方法私有化
class EhanTon private { }

//饿汉式
//看底层
/*
public SingleTon2 getInstance() {
    return s();
  }
 */
object  EhanTon {
  private val ehanSample = new EhanTon
  def getInstance = ehanSample
}