欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

创建型模式之工厂模式(2.2)

程序员文章站 2024-01-13 18:20:22
和单例模式相似,工厂模式同样聚焦于在考虑整个软件构建的情况下合理创建对象,从而保证软件的扩展性和稳定性。 简单工厂模式:适用客户端无需扩展的应用场景 //工厂方法模式:适合客户端创建单个产品的应用场景 //抽象工厂模式:适合创建多个产品(产品固定)的应用场景 ......

什么是工厂模式?

工厂模式是创建型模式的一种,工厂是用来生产的,而在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类图:

创建型模式之工厂模式(2.2)

简单工厂的优缺点:

优点:

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

缺点:

当客户端需要进行功能扩展时,无法在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类图:

创建型模式之工厂模式(2.2)

工厂方法模式的优缺点:

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

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

抽象工厂模式(实现产品簇)

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

抽象工厂中可以生产多个产品,产品之间存在内在联系。比如说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类图:

创建型模式之工厂模式(2.2)

工厂模式总结

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

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

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

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