设计模式 - 工厂模式 Java&Kotlin

同算法与数据结构一样，设计模式同样是作为一个优秀程序员必须熟练掌握与应用的基本功，在阅读源码或者优秀的开源项目的同时，不难发现各种设计模式的灵活运用，叹为观止。

接下来一系列博客，将和大家一起分享这些常用的设计模式。

观察者模式

装饰者模式

工厂模式

单例模式

建造者模式​​​​​​​

本篇博客旨在和大家一起分享工厂模式的应用，这里的工厂模式指的是普通工厂模式，不是简单工厂与抽象工厂，简单工厂严格意义上来说，并不是一种设计模式，只是一种写法，而抽象工厂将会在后面的博客中进行分享。

首先来看看神马是工厂模式，工厂模式定义了一个创建对象时的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到了子类。

在设计工厂的时候，可以这样理解，把工厂类和产品类作为平行的两个模块来进行设计，这样结构会更加清晰，也方便大家的理解，当然这里说文字还是有点抽象，接下来通过代码来具体体会一下。

我们这里实现一个手机工厂，可以生产HuaWei Mate20、Galaxy S10、iPhoneX、iPhoneXR四种手机。

首先我们来设计产品类

第一步先定义抽象的手机类，Phone有两个成员变量，os代表操作系统，name代表手机名称，成员方法product进行生产

public abstract class Phone {
    private String os;
    private String name;

    public void product() {
        System.out.println("Begin to product phone");
        System.out.println("System is " + os);
        System.out.println("Name is " + name);
        System.out.println("Product success");
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setOs(String os) {
        this.os = os;
    }
}

接着根据Android和IOS声明两个抽象类作为操作系统的基类

public abstract class AndroidPhone extends Phone {
    public AndroidPhone() {
        setOs("Android");
    }
}

public abstract class IPhone extends Phone {
    public IPhone() {
        setOs("ios");
    }
}

接着便是这四部手机的具体实现类了

public class GalaxyS10 extends AndroidPhone {
    public GalaxyS10() {
        setName("Galaxy S10");
    }
}

public class HuaWeiMate20 extends AndroidPhone {
    public HuaWeiMate20() {
        setName("HuaWei Mate20");
    }
}


public class IPhoneX extends IPhone {
    public IPhoneX() {
        setName("Iphone X");
    }
}

public class IPhoneXR extends IPhone {
    public IPhoneXR() {
        setName("IPhone XR");
    }
}

至此，我们的产品类就设计完了

现在开始设计工厂类，工厂类持有一个createPhone的方法用来创建手机

public abstract class PhoneFactory {
    public abstract Phone createPhone(String name);
}

Android和IOS有着不同的实现

public class AndroidPhoneFactory extends PhoneFactory {
    @Override
    public Phone createPhone(String name) {
        if (name.equals("HuaWei Mate20")) {
            return new HuaWeiMate20();
        } else if (name.equals("Galaxy S10")) {
            return new GalaxyS10();
        }
        return null;
    }
}

public class IPhoneFactory extends PhoneFactory {
    @Override
    public Phone createPhone(String name) {
        if (name.equals("Iphone X")) {
            return new IPhoneX();
        } else if (name.equals("IPhone XR")) {
            return new IPhoneXR();
        }
        return null;
    }
}

这样工厂类也设计完了，Android工厂和IOS工厂依赖于封装了如何具体实现的手机类，以此实现了工厂类对产品类的创建。

让我们一起来看看手机的生产过程吧

public class PhoneStore {
    public static void main(String[] args) {
        PhoneFactory iPhoneFactory = new IPhoneFactory();

        Phone iphoneX = iPhoneFactory.createPhone("Iphone X");
        iphoneX.product();

        Phone iphoneXR = iPhoneFactory.createPhone("IPhone XR");
        iphoneXR.product();

        PhoneFactory androidFactory = new AndroidPhoneFactory();

        Phone huaWeiMate20 = androidFactory.createPhone("HuaWei Mate20");
        huaWeiMate20.product();

        Phone galaxyS10 = androidFactory.createPhone("Galaxy S10");
        galaxyS10.product();
    }
}

此时一个简单的完整的工厂模式demo就完成啦，下面是Kotlin代码实现

open class AndroidPhone : Phone() {
    init {
        setOs("Android")
    }
}

class AndroidPhoneFactory : PhoneFactory() {
    override fun createPhone(name: String): Phone? {
        if (name == "HuaWei Mate20") {
            return HuaWeiMate20()
        } else if (name == "Galaxy S10") {
            return GalaxyS10()
        }
        return null
    }
}

class GalaxyS10 : AndroidPhone() {
    init {
        setName("Galaxy S10")
    }
}

class HuaWeiMate20 : AndroidPhone() {
    init {
        setName("HuaWei Mate20")
    }
}

open abstract class IPhone : Phone() {
    init {
        setOs("ios")
    }
}

class IPhoneFactory : PhoneFactory() {
    override fun createPhone(name: String): Phone? {
        if (name == "Iphone X") {
            return IPhoneX()
        } else if (name == "IPhone XR") {
            return IPhoneXR()
        }
        return null
    }
}

class IPhoneX : IPhone() {
    init {
        setName("Iphone X")
    }
}

class IPhoneXR : IPhone() {
    init {
        setName("IPhone XR")
    }
}

abstract class Phone {
    private var os: String? = null
    private var name: String? = null

    fun product() {
        println("Begin to product phone")
        println("System is " + os!!)
        println("Name is " + name!!)
        println("Product success")
    }

    fun setName(name: String) {
        this.name = name
    }

    fun setOs(os: String) {
        this.os = os
    }
}

abstract class PhoneFactory {
    abstract fun createPhone(name: String): Phone?
}

fun main() {
    val iPhoneFactory = IPhoneFactory()

    val iphoneX = iPhoneFactory.createPhone("Iphone X")
    iphoneX!!.product()

    val iphoneXR = iPhoneFactory.createPhone("IPhone XR")
    iphoneXR!!.product()

    val androidFactory = AndroidPhoneFactory()

    val huaWeiMate20 = androidFactory.createPhone("HuaWei Mate20")
    huaWeiMate20!!.product()

    val galaxyS10 = androidFactory.createPhone("Galaxy S10")
    galaxyS10!!.product()
}