工厂设计模式

最新推荐文章于 2023-12-14 23:32:35 发布
最新推荐文章于 2023-12-14 23:32:35 发布
阅读量719 收藏
点赞数
分类专栏： 软件设计模式 文章标签： 简单工厂模式 工厂方法模式 抽象工厂模式 静态工厂模式 工厂设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43521890/article/details/123858983
版权

工厂模式

一、普通写法

1、UML

在这里插入图片描述

1、代码案例

/**
 * @Author: dashu
 * @Description: 饺子
 * @Date: 23:18
 * @Version: 1.0
 */
public abstract class Dumplings {

    private String stuffing;

    /**
     * 准备食材
     */
    public abstract void ingredient();

    /**
     * 包饺子
     */
    public void makeDumplings() {
        System.out.println("包" + stuffing + "饺子");
    }

    /**
     * 煮饺子
     */
    public void boilDumplings() {
        System.out.println("煮" + stuffing + "饺子");
    }

    /**
     * 捞饺子
     */
    public void fishingDumplings() {
        System.out.println("捞" + stuffing + "饺子");
    }

    /**
     * 饺子名
     *
     * @param stuffing
     */
    public void setStuffing(String stuffing) {
        this.stuffing = stuffing;
    }


}

/**
 * @Author: dashu
 * @Description: 猪肉饺子
 * @Date:  23:28
 * @Version: 1.0
 */
public class PorkDumplings extends Dumplings{
    /**
     * 准备食材
     */
    @Override
    public void ingredient() {
        System.out.println("准备猪肉和饺子皮...");
    }
}

/**
 * @Author: dashu
 * @Description: 牛肉饺子
 * @Date:  23:26
 * @Version: 1.0
 */
public class BeefDumplings extends Dumplings{
    /**
     * 准备食材
     */
    @Override
   public void ingredient() {
        System.out.println("准备牛肉和饺子皮...");
    }


}

/**
 * @Author: dashu
 * @Description: 买饺子
 * @Date:  23:30
 * @Version: 1.0
 */
public class BuyDumplings {

    public BuyDumplings(){
        Dumplings dumplings = null;
        String stuffing;
        do {
            stuffing = getStuffing();
            if (stuffing.equals("猪肉")){
                dumplings = new PorkDumplings();
                dumplings.setStuffing(stuffing);
            }else if (stuffing.equals("牛肉")){
                dumplings = new BeefDumplings();
                dumplings.setStuffing(stuffing);
            }else{
                System.out.println("没有你要买的饺子...");
                break;
            }
            dumplings.ingredient();
            dumplings.makeDumplings();
            dumplings.boilDumplings();
            dumplings.fishingDumplings();
        }while (true);

    }


    /**
     * 获取饺子馅
     * @return
     */
    private String getStuffing(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入饺子馅:");
            String s = bufferedReader.readLine();
            return s;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }

}

/**
 * @Author: dashu
 * @Description: 测试
 * @Date:  23:37
 * @Version: 1.0
 */
public class Main {
    public static void main(String[] args) {
        new BuyDumplings();
    }
}

2、结论

该写法优点就是比较好理解，容易操纵。

但是严重违反了设计模式的开闭原则（ocp），即对扩展开放，对修改关闭。

当我们给类中添加一个白菜饺子时，需要修改到BuyDumplings类中的方法BuyDumplings

 public BuyDumplings(){
        Dumplings dumplings = null;
        String stuffing;
        do {
            stuffing = getStuffing();
            if (stuffing.equals("猪肉")){
                dumplings = new PorkDumplings();
                dumplings.setStuffing(stuffing);
            }else if (stuffing.equals("牛肉")){
                dumplings = new BeefDumplings();
                dumplings.setStuffing(stuffing);
            }else{
                System.out.println("没有你要买的饺子...");
                break;
            }
            dumplings.ingredient();
            dumplings.makeDumplings();
            dumplings.boilDumplings();
            dumplings.fishingDumplings();
        }while (true);

    }

二、简单工厂模式

1、UML

在这里插入图片描述

1、代码案例

/**
 * @Author: dashu
 * @Description: 饺子
 * @Date: 23:18
 * @Version: 1.0
 */
public abstract class Dumplings {

    private String stuffing;

    /**
     * 准备食材
     */
    public abstract void ingredient();

    /**
     * 包饺子
     */
    public void makeDumplings() {
        System.out.println("包" + stuffing + "饺子");
    }

    /**
     * 煮饺子
     */
    public void boilDumplings() {
        System.out.println("煮" + stuffing + "饺子");
    }

    /**
     * 捞饺子
     */
    public void fishingDumplings() {
        System.out.println("捞" + stuffing + "饺子");
    }

    /**
     * 饺子名
     *
     * @param stuffing
     */
    public void setStuffing(String stuffing) {
        this.stuffing = stuffing;
    }


}

/**
 * @Author: dashu
 * @Description: 牛肉饺子
 * @Date:  23:26
 * @Version: 1.0
 */
public class BeefDumplings extends Dumplings{
    /**
     * 准备食材
     */
    @Override
   public void ingredient() {
        System.out.println("准备牛肉和饺子皮...");
    }


}

/**
 * @Author: dashu
 * @Description: 猪肉饺子
 * @Date:  23:28
 * @Version: 1.0
 */
public class PorkDumplings extends Dumplings{
    /**
     * 准备食材
     */
    @Override
    public void ingredient() {
        System.out.println("准备猪肉和饺子皮...");
    }
}

/**
 * @Author: dashu
 * @Description: 简单工厂：创建饺子
 * @Date:  23:41
 * @Version: 1.0
 */
public class DumplingsSimplenessFactory {

    public Dumplings createDumplings(String stuffing) {
        Dumplings dumplings = null;
        if (stuffing.equals("猪肉")) {
            dumplings = new PorkDumplings();
            dumplings.setStuffing(stuffing);
        } else if (stuffing.equals("牛肉")) {
            dumplings = new BeefDumplings();
            dumplings.setStuffing(stuffing);
        }
        return dumplings;
    }

}

/**
 * @Author: dashu
 * @Description: 买饺子
 * @Date:  23:30
 * @Version: 1.0
 */
public class BuyDumplingsBySimplenessFactory {

    private DumplingsSimplenessFactory dumplingsSimplenessFactory;

    private Dumplings dumplings;


    public BuyDumplingsBySimplenessFactory(DumplingsSimplenessFactory dumplingsSimplenessFactory){
        this.dumplingsSimplenessFactory = dumplingsSimplenessFactory;
        buyDumplings();
    }


    public void buyDumplings(){

        String stuffing;
        do {
            stuffing = getStuffing();

            dumplings = dumplingsSimplenessFactory.createDumplings(stuffing);

            if (dumplings == null){
                System.out.println("没有你要买的饺子...");
                break;
            }

            dumplings.ingredient();
            dumplings.makeDumplings();
            dumplings.boilDumplings();
            dumplings.fishingDumplings();

        }while (true);

    }


    /**
     * 获取饺子馅
     * @return
     */
    private String getStuffing(){
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入饺子馅:");
            String s = bufferedReader.readLine();
            return s;
        }catch (IOException e){
            e.printStackTrace();
            return "";
        }
    }

}

/**
 * @Author: dashu
 * @Description: 测试
 * @Date:  23:57
 * @Version: 1.0
 */
public class Main {
    public static void main(String[] args) {
        new BuyDumplingsBySimplenessFactory(new DumplingsSimplenessFactory());
    }

}

2、结论

简单工厂模式是由一个工厂对象决定创建出哪一种产品的实例。

简单工厂模式：定义一个创建对象的类，由这个类来封装实例化对象的行为

当我们给类中添加一个白菜饺子时，只需要修改工厂类DumplingsSimplenessFactory即可，不会影响到使用对象的类

三、静态工厂模式

1、UML

在这里插入图片描述

1、代码案例

/**
 * @Author: dashu
 * @Description: 饺子
 * @Date: 23:18
 * @Version: 1.0
 */
public abstract class Dumplings {

    private String stuffing;

    /**
     * 准备食材
     */
    public abstract void ingredient();

    /**
     * 包饺子
     */
    public void makeDumplings() {
        System.out.println("包" + stuffing + "饺子");
    }

    /**
     * 煮饺子
     */
    public void boilDumplings() {
        System.out.println("煮" + stuffing + "饺子");
    }

    /**
     * 捞饺子
     */
    public void fishingDumplings() {
        System.out.println("捞" + stuffing + "饺子");
    }

    /**
     * 饺子名
     *
     * @param stuffing
     */
    public void setStuffing(String stuffing) {
        this.stuffing = stuffing;
    }


}

/**
 * @Author: dashu
 * @Description: 牛肉饺子
 * @Date:  23:26
 * @Version: 1.0
 */
public class BeefDumplings extends Dumplings{
    /**
     * 准备食材
     */
    @Override
   public void ingredient() {
        System.out.println("准备牛肉和饺子皮...");
    }


}

/**
 * @Author: dashu
 * @Description: 猪肉饺子
 * @Date:  23:28
 * @Version: 1.0
 */
public class PorkDumplings extends Dumplings{
    /**
     * 准备食材
     */
    @Override
    public void ingredient() {
        System.out.println("准备猪肉和饺子皮...");
    }
}

/**
 * @Author: dashu
 * @Description: 静态工厂：创建饺子
 * @Date: 23:41
 * @Version: 1.0
 */
public class DumplingsStaticFactory {

    public static Dumplings createDumplings(String stuffing) {
        Dumplings dumplings = null;
        if (stuffing.equals("猪肉")) {
            dumplings = new PorkDumplings();
            dumplings.setStuffing(stuffing);
        } else if (stuffing.equals("牛肉")) {
            dumplings = new BeefDumplings();
            dumplings.setStuffing(stuffing);
        }
        return dumplings;
    }

}

/**
 * @Author: dashu
 * @Description: 买饺子
 * @Date: 23:30
 * @Version: 1.0
 */
public class BuyDumplingsByStaticFactory {


    private Dumplings dumplings;

    public BuyDumplingsByStaticFactory() {
        buyDumplings();
    }


    public void buyDumplings() {

        String stuffing;

        do {
            stuffing = getStuffing();

            dumplings = DumplingsStaticFactory.createDumplings(stuffing);

            if (dumplings == null) {
                System.out.println("没有你要买的饺子...");
                break;
            }

            dumplings.ingredient();
            dumplings.makeDumplings();
            dumplings.boilDumplings();
            dumplings.fishingDumplings();

        } while (true);

    }


    /**
     * 获取饺子馅
     *
     * @return
     */
    private String getStuffing() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入饺子馅:");
            String s = bufferedReader.readLine();
            return s;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

/**
 * @Author: dashu
 * @Description: 测试
 * @Date:  23:57
 * @Version: 1.0
 */
public class Main {
    public static void main(String[] args) {
        new BuyDumplingsByStaticFactory();
    }

}

2、结论

简单工厂模式也叫静态工厂模式。只是工厂创建实例的方式直接由类名调用创建实例的静态方法

四、工厂方法模式

1、UML

在这里插入图片描述

1、代码案例

/**
 * @Author: dashu
 * @Description: 饺子
 * @Date: 23:18
 * @Version: 1.0
 */
public abstract class Dumplings {

    private String stuffing;

    /**
     * 准备食材
     */
    public abstract void ingredient();

    /**
     * 包饺子
     */
    public void makeDumplings() {
        System.out.println("包" + stuffing + "饺子");
    }

    /**
     * 煮饺子
     */
    public void boilDumplings() {
        System.out.println("煮" + stuffing + "饺子");
    }

    /**
     * 捞饺子
     */
    public void fishingDumplings() {
        System.out.println("捞" + stuffing + "饺子");
    }

    /**
     * 饺子名
     *
     * @param stuffing
     */
    public void setStuffing(String stuffing) {
        this.stuffing = stuffing;
    }


}

/**
 * @Author: dashu
 * @Description: 北方猪肉饺子
 * @Date:  23:28
 * @Version: 1.0
 */
public class BFPorkDumplings extends Dumplings {
    /**
     * 准备食材
     */
    @Override
    public void ingredient() {
        System.out.println("北方饺子");
        System.out.println("准备猪肉和饺子皮...");
    }
}

/**
 * @Author: dashu
 * @Description: 北方牛肉饺子
 * @Date:  23:26
 * @Version: 1.0
 */
public class BFBeefDumplings extends Dumplings {
    /**
     * 准备食材
     */
    @Override
   public void ingredient() {
        System.out.println("北方饺子");
        System.out.println("准备牛肉和饺子皮...");
    }


}

/**
 * @Author: dashu
 * @Description: 南方猪肉饺子
 * @Date:  23:28
 * @Version: 1.0
 */
public class NFPorkDumplings extends Dumplings {
    /**
     * 准备食材
     */
    @Override
    public void ingredient() {
        System.out.println("南方饺子");
        System.out.println("准备猪肉和饺子皮...");
    }
}

/**
 * @Author: dashu
 * @Description: 南方牛肉饺子
 * @Date:  23:26
 * @Version: 1.0
 */
public class NFBeefDumplings extends Dumplings {
    /**
     * 准备食材
     */
    @Override
   public void ingredient() {
        System.out.println("南方饺子");
        System.out.println("准备牛肉和饺子皮...");
    }


}

/**
 * @Author: dashu
 * @Description: 买北方饺子
 * @Date: 2022/3/25 0:05
 * @Version: 1.0
 */
public class BFBuyDumplingsByFactoryMethod extends BuyDumplingsByFactoryMethod {


    /**
     * 创建饺子
     * @param stuffing 馅
     * @return
     */
    @Override
    public Dumplings createDumplings(String stuffing) {
        Dumplings dumplings = null;
        if (stuffing.equals("猪肉")) {
            dumplings = new BFPorkDumplings();
            dumplings.setStuffing(stuffing);
        } else if (stuffing.equals("牛肉")) {
            dumplings = new BFBeefDumplings();
            dumplings.setStuffing(stuffing);
        }
        return dumplings;
    }
}

/**
 * @Author: dashu
 * @Description: 买南方饺子
 * @Date: 2022/3/25 0:05
 * @Version: 1.0
 */
public class NFBuyDumplingsByFactoryMethod extends BuyDumplingsByFactoryMethod {


    /**
     * 创建饺子
     * @param stuffing 馅
     * @return
     */
    @Override
    public Dumplings createDumplings(String stuffing) {
        Dumplings dumplings = null;
        if (stuffing.equals("猪肉")) {
            dumplings = new NFPorkDumplings();
            dumplings.setStuffing(stuffing);
        } else if (stuffing.equals("牛肉")) {
            dumplings = new NFBeefDumplings();
            dumplings.setStuffing(stuffing);
        }
        return dumplings;
    }



}

/**
 * @Author: dashu
 * @Description: 买饺子
 * @Date: 23:30
 * @Version: 1.0
 */
public abstract class BuyDumplingsByFactoryMethod {

    /**
     * 创建饺子
     *
     * @param stuffing 馅
     * @return
     */
    public abstract Dumplings createDumplings(String stuffing);

    private Dumplings dumplings;

    public BuyDumplingsByFactoryMethod() {

        String stuffing;

        do {
            stuffing = getStuffing();

            dumplings = createDumplings(stuffing);

            if (dumplings == null) {
                System.out.println("没有你要买的饺子...");
                break;
            }

            dumplings.ingredient();
            dumplings.makeDumplings();
            dumplings.boilDumplings();
            dumplings.fishingDumplings();

        } while (true);

    }


    /**
     * 获取饺子馅
     *
     * @return
     */
    private String getStuffing() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入饺子馅:");
            String s = bufferedReader.readLine();
            return s;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

/**
 * @Author: dashu
 * @Description: 测试
 * @Date:  23:57
 * @Version: 1.0
 */
public class Main {
    public static void main(String[] args) {
        new BFBuyDumplingsByFactoryMethod();
    }

}

2、结论

工厂方法模式：定义一个创建对象的抽象方法，由子类决定要实例化的类。

工厂方法模式将对象的实例化推迟到了子类

五、抽象工厂模式

1、UML

在这里插入图片描述

2、代码案例

/**
 * @Author: dashu
 * @Description: 饺子
 * @Date: 23:18
 * @Version: 1.0
 */
public abstract class Dumplings {

    private String stuffing;

    /**
     * 准备食材
     */
    public abstract void ingredient();

    /**
     * 包饺子
     */
    public void makeDumplings() {
        System.out.println("包" + stuffing + "饺子");
    }

    /**
     * 煮饺子
     */
    public void boilDumplings() {
        System.out.println("煮" + stuffing + "饺子");
    }

    /**
     * 捞饺子
     */
    public void fishingDumplings() {
        System.out.println("捞" + stuffing + "饺子");
    }

    /**
     * 饺子名
     *
     * @param stuffing
     */
    public void setStuffing(String stuffing) {
        this.stuffing = stuffing;
    }


}

/**
 * @Author: dashu
 * @Description: 北方猪肉饺子
 * @Date:  23:28
 * @Version: 1.0
 */
public class BFPorkDumplings extends Dumplings {
    /**
     * 准备食材
     */
    @Override
    public void ingredient() {
        System.out.println("北方饺子");
        System.out.println("准备猪肉和饺子皮...");
    }
}

/**
 * @Author: dashu
 * @Description: 北方牛肉饺子
 * @Date:  23:26
 * @Version: 1.0
 */
public class BFBeefDumplings extends Dumplings {
    /**
     * 准备食材
     */
    @Override
   public void ingredient() {
        System.out.println("北方饺子");
        System.out.println("准备牛肉和饺子皮...");
    }


}

/**
 * @Author: dashu
 * @Description: 南方猪肉饺子
 * @Date:  23:28
 * @Version: 1.0
 */
public class NFPorkDumplings extends Dumplings {
    /**
     * 准备食材
     */
    @Override
    public void ingredient() {
        System.out.println("南方饺子");
        System.out.println("准备猪肉和饺子皮...");
    }
}

/**
 * @Author: dashu
 * @Description: 南方牛肉饺子
 * @Date:  23:26
 * @Version: 1.0
 */
public class NFBeefDumplings extends Dumplings {
    /**
     * 准备食材
     */
    @Override
   public void ingredient() {
        System.out.println("南方饺子");
        System.out.println("准备牛肉和饺子皮...");
    }


}

/**
 * @Author: dashu
 * @Description: 抽象工厂：饺子
 * @Date: 2022/3/25 0:23
 * @Version: 1.0
 */
public interface DumplingsAbstractFactory {

    /**
     * 创建饺子
     * @param stuffing 馅
     * @return
     */
    Dumplings createDumplings(String stuffing);

}

/**
 * @Author: dashu
 * @Description: 简单工厂：北方饺子
 * @Date: 2022/3/25 0:25
 * @Version: 1.0
 */
public class BFDumplingsAbstractFactory implements DumplingsAbstractFactory{
    /**
     * 创建饺子
     * @param stuffing 馅
     * @return
     */
    @Override
    public Dumplings createDumplings(String stuffing) {
        Dumplings dumplings = null;
        if (stuffing.equals("猪肉")) {
            dumplings = new BFPorkDumplings();
            dumplings.setStuffing(stuffing);
        } else if (stuffing.equals("牛肉")) {
            dumplings = new BFBeefDumplings();
            dumplings.setStuffing(stuffing);
        }
        return dumplings;
    }
}

/**
 * @Author: dashu
 * @Description: 简单工厂：北方饺子
 * @Date: 2022/3/25 0:25
 * @Version: 1.0
 */
public class NFDumplingsAbstractFactory implements DumplingsAbstractFactory {

    /**
     * 创建饺子
     *
     * @param stuffing 馅
     * @return
     */
    @Override
    public Dumplings createDumplings(String stuffing) {
        Dumplings dumplings = null;
        if (stuffing.equals("猪肉")) {
            dumplings = new NFPorkDumplings();
            dumplings.setStuffing(stuffing);
        } else if (stuffing.equals("牛肉")) {
            dumplings = new NFBeefDumplings();
            dumplings.setStuffing(stuffing);
        }
        return dumplings;
    }
}

/**
 * @Author: dashu
 * @Description: 买饺子
 * @Date: 23:30
 * @Version: 1.0
 */
public class BuyDumplingsByAbstractFactory {

    private DumplingsAbstractFactory dumplingsAbstractFactory;

    private Dumplings dumplings;


    public BuyDumplingsByAbstractFactory(DumplingsAbstractFactory dumplingsAbstractFactory) {
        this.dumplingsAbstractFactory = dumplingsAbstractFactory;
        buyDumplings();
    }


    public void buyDumplings() {

        String stuffing;
        do {
            stuffing = getStuffing();

            dumplings = dumplingsAbstractFactory.createDumplings(stuffing);

            if (dumplings == null) {
                System.out.println("没有你要买的饺子...");
                break;
            }

            dumplings.ingredient();
            dumplings.makeDumplings();
            dumplings.boilDumplings();
            dumplings.fishingDumplings();

        } while (true);

    }


    /**
     * 获取饺子馅
     *
     * @return
     */
    private String getStuffing() {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入饺子馅:");
            String s = bufferedReader.readLine();
            return s;
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }

}

/**
 * @Author: dashu
 * @Description: 测试
 * @Date:  23:57
 * @Version: 1.0
 */
public class Main {
    public static void main(String[] args) {
        new BuyDumplingsByAbstractFactory(new BFDumplingsAbstractFactory());
    }

}

3、结论

抽象工厂模式：定义一个interface用于创建相关或有依赖关系的对象，而无需指明具体的类

抽象工厂模式就是对简单工厂模式的改进（进一步的抽象）

抽象工厂模式将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类。我们可以根据创建对象类型使用对应的工厂子类

大树下躲雨
关注
专栏目录
设计模式之工厂模式，史上最强，不服来辩！
xmt1139057136的专栏
07-10 4810
设计模式是对大家实际工作中写的各种代码进行高层次抽象的总结，如果设计模式没学会，抽象能力肯定就不会太强。常见的设计模式有 23 种，今天我们只聊最简单的工厂模式。工厂模式是属于创建型模式的...
【设计模式】工厂模式详解
最新发布
k123456kah的博客
07-29 525
工厂模式是一种创建型设计模式，通过提供一个接口或抽象类来创建对象，而不是直接实例化对象。工厂模式的主要思想是将对象的创建与使用分离，使得创建对象的过程更加灵活和可扩展。抽象工厂（Abstract Factory）：定义了一个创建产品对象的接口，可以包含多个方法来创建不同类型的产品。具体工厂（Concrete Factory）：实现抽象工厂接口，负责实例化具体的产品对象。抽象产品（Abstract Product）：定义了产品的接口或抽象类，是工厂方法和抽象工厂模式中的基础。
【设计模式】工厂模式（Factory Pattern）
qq_27198345的博客
11-15 9561
工厂模式
设计模式 - 工厂模式、建造者模式，就该这样学！
CYK_byte的博客
10-08 2572
简单工厂不是一种设计模式，反而比较像是一种编程习惯.抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。具体产品 ：实现或者继承抽象产品的子类具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。
设计模式详解之工厂模式
阿里技术
05-25 6666
本文将着眼于工厂模式，从简单工厂模式、工厂方法模式和抽象工厂模式出发，展开学习和深入探讨。
工厂设计模式代码
06-22
工厂设计模式是软件工程中广泛使用的一种创建型设计模式，它的主要目的是为了隔离对象的创建过程，使得客户端代码不直接创建对象，而是通过一个专门的工厂类来负责对象的实例化。这种模式使得系统在面对产品扩展时...
工厂设计模式简单实例
12-27
工厂设计模式是面向对象编程中的一种经典设计模式，它的主要目的是为了解耦对象的创建与使用，使得系统在不关心具体实现的情况下能够灵活地创建所需的对象。在这个名为"工厂设计模式简单实例"的资料中，我们可以期待...
工厂设计模式1
08-03
工厂设计模式是面向对象设计中的一种经典模式，其主要目的是为了解耦代码，将对象的创建过程封装起来，使得客户端代码不再直接实例化对象，而是通过一个“工厂”来获取所需的对象。这样做的好处在于，当需要添加新的...
抽象工厂设计模式code
04-11
抽象工厂设计模式是一种创建型设计模式，它提供了一种创建对象族的方法，而无需指定具体的类。这种模式在处理相关对象族的创建时特别有用，因为它允许创建一组具有相同接口的对象，而无需指定它们的具体类型。C#作为...
简单工厂设计模式
03-30
简单工厂设计模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在简单工厂模式中，一个工厂类负责创建对象，客户端不再直接创建对象，而是通过调用工厂类的静态方法来获取所需对象，降低了代码之间的耦合...
java设计模式中最简单的工厂设计模式的实例
07-12
工厂设计模式是其中最基础且常用的一种，它属于创建型设计模式，主要用于对象的创建。本实例将深入讲解工厂设计模式的概念、结构以及如何在实际项目中应用。 ### 工厂设计模式概述 工厂设计模式的核心思想是定义一...
java中代理设计+工厂设计模式
05-27
其中，Java中的代理设计模式和工厂设计模式是两种非常重要的设计模式。 1. **单例设计模式**： 单例设计模式是23种设计模式中最简单的一种。它保证一个类只有一个实例，并提供一个全局访问点。这种方式适用于那些...
工厂设计模式介绍，欢迎下载分享
03-01
### 工厂设计模式概述 #### 一、工厂模式概览 工厂模式是软件工程中最常用的创建型设计模式之一，其主要目标是提供一个创建对象的接口，但允许子类决定实例化哪一个类。工厂模式使得一个类的实例化延迟到其子类。 ...
ios 简单工厂设计模式
08-20
简单工厂设计模式是其中一种创建型设计模式，它提供了一个创建对象的接口，但允许子类决定实例化哪一个类。这个接口就像一个工厂，根据输入条件生产不同类型的实例。 简单工厂模式的核心在于一个“工厂”类，这个类...
设计模式第3讲——工厂模式（Factory）
让~学习~成为一种习惯（橡 皮 人の技术博客）
05-29 9635
工厂模式是一种创建型设计模式。一、什么是工厂模式 二、工厂分类 三、应用场景3.1 生活场景3.2 java场景 四、 工厂模式实现4.0 代码结构4.1 传统模式4.2 简单工厂模式4.3 方法工厂模式4.4 抽象工厂模式五、总结5.1 简单工厂模式5.2 方法工厂模式5.3 抽象工厂
设计模式详解---工厂模式
stu_kk的博客
12-14 492
工厂模式
设计模式之工厂模式详解和应用
赵广陆
02-13 1010
目录 1 工厂模式的历史由来 2.简单工厂模式 2.1 简单工厂模式定义 2.2 简单工厂模式案例 2.3 简单工厂模式相关源码 2.4 简单工厂模式优缺点 3 工厂方法模式 3.1 工厂方法模式定义 3.2 工厂方法模式案例 3.3 工厂方法模式源码 3.4 工厂方法模式优缺点 4 抽象工厂模式 4.1 抽象工厂模式定义 4.2 抽象工厂模式案例 4.3 抽象工厂模式优缺点 5 简单工厂 vs 工厂方法 vs 抽象工厂
工厂设计模式：接口与抽象类的应用与理解
"工厂设计模式是一种软件设计模式，主要应用于对象创建的过程中，以解决创建对象的复杂性和灵活性问题。它将对象的实例化过程抽象出来，使客户端无需关心对象的具体实现细节，只需与工厂类交互即可得到所需的对象。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大树下躲雨

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值