创建型模式之工厂模式（2.2）

最新推荐文章于 2022-09-29 15:08:30 发布

Noneplus

最新推荐文章于 2022-09-29 15:08:30 发布

阅读量124

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/qq_40754146/article/details/99238931

版权

设计模式专栏收录该内容

6 篇文章 0 订阅

订阅专栏

什么是工厂模式？

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

1565531609458

简单工厂的优缺点:

优点：

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

缺点：

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

1565532368140

工厂方法模式的优缺点：

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

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

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

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

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

1565533010264

工厂模式总结

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

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

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

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

Noneplus

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
创建型模式之工厂模式（2.2）

什么是工厂模式？工厂模式是创建型模式的一种，工厂是用来生产的，而在Java里，是用来生产对象实例的。和单例模式相似，工厂模式同样聚焦于在考虑整个软件构建的情况下合理创建对象，从而保证软件的扩展性和稳定性。工厂模式分为三种：简单工厂模式工厂方法模式抽象工厂模式简单工厂模式（实现服务端自扩展）服务端：提供代码的人（作者）客户端：使用代码的人（用户）【对于程序员来说，自己是作者...
复制链接

扫一扫