什么是工厂模式？

工厂模式是创建型模式的一种，工厂是用来生产的，而在java里，是用来生产对象实例的。

和单例模式相似，工厂模式同样聚焦于在考虑整个软件构建的情况下合理创建对象，从而保证软件的扩展性和稳定性。

工厂模式分为三种：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

简单工厂模式（实现服务端自扩展）

服务端：提供代码的人（作者）

客户端：使用代码的人（用户）

【对于程序员来说，自己是作者，用户是普通人；那么对于发明语言,框架的人来说，创建者是作者，而普通程序员是用户】

假设没有使用简单工厂模式：

定义一个coder接口，然后定义javacoder和pythoncoder实现coder接口。客户端通过new来创建对象。（耦合）

//服务端
interface coder {

    void express();
}

class javacoder implements coder
{
    @override
    public void express()
    {
        system.out.println("i am a java coder");

    }
}

class pythoncoder implements coder
{

    @override
    public void express()
    {
        system.out.println("i am a python coder");

    }
}

//===============================================================================
public class productmanager     //客户端
{
    public static void main(string[] args) {

        coder javacoder = new javacoder();
        javacoder.express();

        
    }



}

当服务端需要扩展一个类时：需要进行1,2两步

//服务端
interface coder {

    void express();
}

class javacoder implements coder
{
    @override
    public void express()
    {
        system.out.println("i am a java coder");

    }
}

class pythoncoder implements coder
{

    @override
    public void express()
    {
        system.out.println("i am a python coder");

    }
}


class gocoder implements coder    //1.服务端扩展
{

    @override
    public void express()
    {
        system.out.println("i am a go coder");

    }
}
//===============================================================================
public class productmanager     //客户端
{
    public static void main(string[] args) {

        coder javacoder = new javacoder();
        javacoder.express();

        coder gocoder = new gocoder();   //2.客户端跟着修改
        gocoder.express();
    }



}

服务端和客户端处于高度耦合状态。（服务端的变化会引起客户端的变化）

使用简单工厂模式：（如果服务端要扩展一个gocoder，客户端无需做修改）

//服务端
interface coder {

    void express();
}

class javacoder implements coder
{
    @override
    public void express()
    {
        system.out.println("i am a java coder");

    }
}

class pythoncoder implements coder
{

    @override
    public void express()
    {
        system.out.println("i am a python coder");

    }
}


class gocoder implements coder    //1.服务端扩展
{

    @override
    public void express()
    {
        system.out.println("i am a go coder");

    }
}

class simplefactory
{

    //使用静态内部类实现单例模式
    private static class staticclassinnerinstance {
        private static final simplefactory instance = new simplefactory();
    }
    

    public static simplefactory getinstance() {
        return staticclassinnerinstance.instance;
    }

    public coder createcoder(string language)
    {
        coder coder = null;
        if(language.equals("java"))
        {
            coder= new javacoder();

        }
        else if(language.equals("python"))
        {
            coder= new pythoncoder();
        }
        else if(language.equals("go"))  //2.扩展条件
        {
            coder= new gocoder();
        }
        return coder;
    }
}
//===============================================================================
public class productmanager     //客户端
{

    public static void main(string[] args) {

        simplefactory factory = simplefactory.getinstance();
        coder javacoder = factory.createcoder("java");
        javacoder.express();


    }



}

简单工厂uml类图：

简单工厂的优缺点:

优点：

解决了服务端与客户端的耦合问题，实现了服务端的自扩展。

缺点：

当客户端需要进行功能扩展时，无法在simplefactory中添加对应修改代码。

简单工厂可以完成服务端的自扩展，但客户端只能调用，无法扩展。

工厂方法模式（实现客户端自扩展）

//服务端
interface coder {

    void express();
}

class javacoder implements coder
{
    @override
    public void express()
    {
        system.out.println("i am a java coder");

    }
}

class pythoncoder implements coder
{

    @override
    public void express()
    {
        system.out.println("i am a python coder");

    }
}


class gocoder implements coder    //1.服务端扩展
{

    @override
    public void express()
    {
        system.out.println("i am a go coder");

    }
}

interface coderfactory   //抽象出coderfactory
{
    public coder createcoder(string language);
}

class serverfactory implements coderfactory
{

    private static class staticclassinnerinstance {
        private static final serverfactory instance = new serverfactory();
    }

    public static serverfactory getinstance() {
        return staticclassinnerinstance.instance;
    }

    @override
    public coder createcoder(string language)
    {
        coder coder = null;
        if(language.equals("java"))
        {
            coder= new javacoder();

        }
        else if(language.equals("python"))
        {
            coder= new pythoncoder();
        }
        else if(language.equals("go"))  //2.扩展条件
        {
            coder= new gocoder();
        }
        return coder;
    }
}
//===============================================================================

class rustcoder implements coder
{
    @override
    public void express()
    {
        system.out.println("i am a rust coder");

    }
}

class clientfactory implements coderfactory
{
    private static class staticclassinnerinstance1 {
        private static final clientfactory instance = new clientfactory();
    }

    public static clientfactory getinstance() {
        return clientfactory.staticclassinnerinstance1.instance;
    }

    @override
    public coder createcoder(string language)
    {

        return new rustcoder();
    }
}

public class productmanager     //客户端
{

    public static void main(string[] args) {

       clientfactory clientfactory = clientfactory.getinstance();
       coder coder = clientfactory.createcoder("rust");
       coder.express();
    }
}

工厂方法uml类图：

工厂方法模式的优缺点：

优点：实现了客户端的自扩展。

缺点：无法扩展多个产品。

抽象工厂模式（实现产品簇）

适应多个产品，加入设计师。

抽象工厂中可以生产多个产品，产品之间存在内在联系。比如说javacoder对应javadesigner。

而实例化的工厂就是根据这种内在联系来划分的。

同一个工厂的产品属于一个产品簇，不同产品簇之间是不能互相组合的。比如说godesigner和pythoncoder是不能组合到一个工厂里的。

//服务端
interface coder {

    void express();
}
interface designer {

    void express();
}


class javacoder implements coder
{
    @override
    public void express()
    {
        system.out.println("i am a java coder");

    }
}

class pythoncoder implements coder
{

    @override
    public void express()
    {
        system.out.println("i am a python coder");

    }
}


class gocoder implements coder
{

    @override
    public void express()
    {
        system.out.println("i am a go coder");

    }
}

class javadesigner implements designer
{
    @override
    public void express()
    {
        system.out.println("i am a java designer!");

    }
}
class pythondesigner implements designer
{
    @override
    public void express()
    {
        system.out.println("i am a python designer!");

    }
}
class godesigner implements designer
{
    @override
    public void express()
    {
        system.out.println("i am a go designer!");

    }
}

interface productfactory
{
    public coder createcoder();
    public designer createdesigner();

}

class gofactory implements productfactory
{

    private static class staticclassinnerinstance {
        private static final gofactory instance = new gofactory();
    }

    public static gofactory getinstance() {
        return staticclassinnerinstance.instance;
    }

    @override
    public coder createcoder()
    {

            coder coder= new gocoder();

        return coder;
    }
    @override
    public designer createdesigner()
    {
        designer designer= new godesigner();

        return designer;
    }

}

class javafactory implements productfactory
{

    private static class staticclassinnerinstance {
        private static final javafactory instance = new javafactory();
    }

    public static javafactory getinstance() {
        return staticclassinnerinstance.instance;
    }

    @override
    public coder createcoder()
    {

        coder coder= new javacoder();

        return coder;
    }
    @override
    public designer createdesigner()
    {
        designer designer= new javadesigner();

        return designer;
    }

}
//===============================================================================



public class productmanager     //客户端
{

    public static void main(string[] args) {
        javafactory javafactory = javafactory.getinstance();
        coder coder =javafactory.createcoder();
        designer designer = javafactory.createdesigner();
        coder.express();
        designer.express();




    }



}

抽象工厂uml类图：

工厂模式总结

简单工厂模式：适用客户端无需扩展的应用场景

工厂方法模式：适合客户端创建单个产品的应用场景

抽象工厂模式：适合创建多个产品的应用场景（但产品类别需要固定）

-------------------------------------------------------------------------------------------------------------2019.8.11