设计模式之工厂方法模式和抽象工厂模式

一、工厂方法模式

1.定义：工厂方法模式属于创建类模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类

2.类图

3.结构：

    工厂接口：工厂接口是工厂方法模式的核心，与调用者直接交互用来提供产品。在实际编程中，有时候也会使用一个抽象类来作为与调用者交互的接口，其本质上是一样的。
    工厂实现：在编程中，工厂实现决定如何实例化产品，是实现扩展的途径，需要有多少种产品，就需要有多少个具体的工厂实现。
    产品接口：产品接口的主要目的是定义产品的规范，所有的产品实现都必须遵循产品接口定义的规范。产品接口是调用者最为关心的，产品接口定义的优劣直接决定了调用者代码的稳定性。同样，产品接口也可以用抽象类来代替，但要注意最好不要违反里氏替换原则。
    产品实现：实现产品接口的具体类，决定了产品在客户端中的具体行为。

4.使用场景

/**
 *  @Author: fc
 *  @Date: 21:46 2017/10/30
 */
interface IFactory {
    fun createProduct():Product
}

class Factory : IFactory{
    override fun createProduct() :Product {
        println("创建出Product的对象")
        return Product()
    }
}

interface IProduct {
    fun productMethod()
}

class Product : IProduct{
    override fun productMethod() {
        println("product自己的方法")
    }
}

fun main(args: Array<String>) {
    val factory :IFactory = Factory()
    val product:IProduct =  factory.createProduct()
    product.productMethod()
}

运行结果：
   创建出Product的对象
   product自己的方法


5.优点
    1.容易扩展：需要扩展产品时，只需增加新的产品，不影响其他产品的生产
    2.降低耦合度：客户端最终得到的是产品本身，而不需要知道和操作产品的生产过程，比较适用于需要生成复杂对象的地方，像是只需要通过new就可以完成创建的对象，就不需要使用工厂模式

6.缺点
     系统复杂度高：增加新产品时，需要增加具体的工厂类和具体的产品类，当产品数量多的时候就会造成系统的复杂度增大，也增加了对系统理解的难度。

7. 厂方法模式和策略的模式有什么区别？
      策略模式强调的是提供不同的策略方案，而工厂方法模式强调的是产品本身。

二、抽象工厂模式

1.定义：抽象工厂模式属于创建类模式，为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

 
2. 和工厂方法模式的区别：
      工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则是针对的多个产品等级结构。
      在编程中，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

3.类图：


4.使用场景

/**
 *  @Author: fc
 *  @Date: 21:46 2017/10/30
 */
interface IFactory {
    fun createProduct1(): Product1
    fun createProduct2(): Product2
}

class Factory : IFactory{
    override fun createProduct1() : Product1 {
        println("创建出Product1的对象")
        return Product1()
    }
    override fun createProduct2() : Product2 {
        println("创建出Product2的对象")
        return Product2()
    }
}

interface IProduct1 {
    fun productMethod()
}

class Product1 : IProduct1 {
    override fun productMethod() {
        println("product1 自己的方法")
    }
}

interface IProduct2 {
    fun productMethod()
}

class Product2 : IProduct2{
    override fun productMethod() {
        println("product2 自己的方法")
    }
}

fun main(args: Array<String>) {
    
    val factory: IFactory = Factory()
    val product1: IProduct1 = factory.createProduct1()
    product1.productMethod()
    val product2: IProduct2 = factory.createProduct2()
    product2.productMethod()
}

运行结果：

创建出Product1的对象
product1 自己的方法
创建出Product2的对象
product2 自己的方法


可以看出，当需要创建的对象是一系列相互关联或相互依赖的产品族时，应该使用抽象工厂模式