设计模式--原型模式和建造者模式

最新推荐文章于 2023-11-24 11:38:13 发布
最新推荐文章于 2023-11-24 11:38:13 发布
阅读量86 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38705074/article/details/109298475
版权

1、原型模式

package com.yqj.pattern.prototype.improve;

public class Sheep implements Cloneable {
    private String name;
    private int age;
    private String color;

    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }

    @Override
    protected Object clone() {
        Object sheep = null;
        try {
            sheep = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return sheep;
    }
}


package com.yqj.pattern.prototype.improve;

public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("tom", 1, "白色");
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
        System.out.println(sheep+" hashcode:"+sheep.hashCode());
        System.out.println(sheep2+" hashcode:"+sheep2.hashCode());
        System.out.println(sheep3+" hashcode:"+sheep3.hashCode());

    }
}

2、建造者模式

2.1

package com.yqj.pattern.builder.improve;

//产品
class House{
    private String basic;
    private String wall;
    private String roofed;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    @Override
    public String toString() {
        return "House{" +
                "basic='" + basic + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

//抽象建造者
abstract class HouseBuilder{
    protected House house = new House();
    //建造流程，定义有关的抽象方法
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();
    //建造好房子，返回产品
    public House buildHouse(){
        return house;
    }
}

//具体建造者1
class CommonHouseBuilder extends HouseBuilder{
    //实现具体的构建方法
    @Override
    public void buildBasic() {
        house.setBasic("普通房子打地基");
    }

    @Override
    public void buildWalls() {
        house.setWall("普通房子刷墙");
    }

    @Override
    public void roofed() {
        house.setRoofed("普通房子封顶");
    }
}

//具体建造者2
class HighBuilding extends HouseBuilder{

    @Override
    public void buildBasic() {
        house.setBasic("别墅打地基");
    }

    @Override
    public void buildWalls() {
        house.setWall("别墅刷墙");
    }

    @Override
    public void roofed() {
        house.setRoofed("别墅封顶");
    }
}



//指挥者
class HouseDirector{
    HouseBuilder houseBuilder;

    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //制定产品的构建流程
    public House build(){
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        //返回产品
        return houseBuilder.buildHouse();
    }
}

//用户
public class Client{
    public static void main(String[] args) {
        HouseDirector director = new HouseDirector(new CommonHouseBuilder());
        System.out.println(director.build());
        //更改指挥者的构建产品
        director.setHouseBuilder(new HighBuilding());
        System.out.println(director.build());
    }
}

package com.yqj.pattern.builder.improve;

//产品
class House{
    private String basic;
    private String wall;
    private String roofed;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    @Override
    public String toString() {
        return "House{" +
                "basic='" + basic + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

//抽象建造者
abstract class HouseBuilder{
    protected House house = new House();
    //建造流程，定义有关的抽象方法
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();
    //建造好房子，返回产品
    public House buildHouse(){
        return house;
    }
}

//具体建造者1
class CommonHouseBuilder extends HouseBuilder{
    //实现具体的构建方法
    @Override
    public void buildBasic() {
        house.setBasic("普通房子打地基");
    }

    @Override
    public void buildWalls() {
        house.setWall("普通房子刷墙");
    }

    @Override
    public void roofed() {
        house.setRoofed("普通房子封顶");
    }
}

//具体建造者2
class HighBuilding extends HouseBuilder{

    @Override
    public void buildBasic() {
        house.setBasic("别墅打地基");
    }

    @Override
    public void buildWalls() {
        house.setWall("别墅刷墙");
    }

    @Override
    public void roofed() {
        house.setRoofed("别墅封顶");
    }
}



//指挥者
class HouseDirector{
    HouseBuilder houseBuilder;

    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //制定产品的构建流程
    public House build(){
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        //返回产品
        return houseBuilder.buildHouse();
    }
}

//用户
public class Client{
    public static void main(String[] args) {
        HouseDirector director = new HouseDirector(new CommonHouseBuilder());
        System.out.println(director.build());
        //更改指挥者的构建产品
        director.setHouseBuilder(new HighBuilding());
        System.out.println(director.build());
    }
}

package com.yqj.pattern.builder.improve;

//产品
class House{
    private String basic;
    private String wall;
    private String roofed;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    @Override
    public String toString() {
        return "House{" +
                "basic='" + basic + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

//抽象建造者
abstract class HouseBuilder{
    protected House house = new House();
    //建造流程，定义有关的抽象方法
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();
    //建造好房子，返回产品
    public House buildHouse(){
        return house;
    }
}

//具体建造者1
class CommonHouseBuilder extends HouseBuilder{
    //实现具体的构建方法
    @Override
    public void buildBasic() {
        house.setBasic("普通房子打地基");
    }

    @Override
    public void buildWalls() {
        house.setWall("普通房子刷墙");
    }

    @Override
    public void roofed() {
        house.setRoofed("普通房子封顶");
    }
}

//具体建造者2
class HighBuilding extends HouseBuilder{

    @Override
    public void buildBasic() {
        house.setBasic("别墅打地基");
    }

    @Override
    public void buildWalls() {
        house.setWall("别墅刷墙");
    }

    @Override
    public void roofed() {
        house.setRoofed("别墅封顶");
    }
}



//指挥者
class HouseDirector{
    HouseBuilder houseBuilder;

    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //制定产品的构建流程
    public House build(){
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        //返回产品
        return houseBuilder.buildHouse();
    }
}

//用户
public class Client{
    public static void main(String[] args) {
        HouseDirector director = new HouseDirector(new CommonHouseBuilder());
        System.out.println(director.build());
        //更改指挥者的构建产品
        director.setHouseBuilder(new HighBuilding());
        System.out.println(director.build());
    }
}

package com.yqj.pattern.builder.improve;

//产品
class House{
    private String basic;
    private String wall;
    private String roofed;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    @Override
    public String toString() {
        return "House{" +
                "basic='" + basic + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

//抽象建造者
abstract class HouseBuilder{
    protected House house = new House();
    //建造流程，定义有关的抽象方法
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();
    //建造好房子，返回产品
    public House buildHouse(){
        return house;
    }
}

//具体建造者1
class CommonHouseBuilder extends HouseBuilder{
    //实现具体的构建方法
    @Override
    public void buildBasic() {
        house.setBasic("普通房子打地基");
    }

    @Override
    public void buildWalls() {
        house.setWall("普通房子刷墙");
    }

    @Override
    public void roofed() {
        house.setRoofed("普通房子封顶");
    }
}

//具体建造者2
class HighBuilding extends HouseBuilder{

    @Override
    public void buildBasic() {
        house.setBasic("别墅打地基");
    }

    @Override
    public void buildWalls() {
        house.setWall("别墅刷墙");
    }

    @Override
    public void roofed() {
        house.setRoofed("别墅封顶");
    }
}



//指挥者
class HouseDirector{
    HouseBuilder houseBuilder;

    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //制定产品的构建流程
    public House build(){
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        //返回产品
        return houseBuilder.buildHouse();
    }
}

//用户
public class Client{
    public static void main(String[] args) {
        HouseDirector director = new HouseDirector(new CommonHouseBuilder());
        System.out.println(director.build());
        //更改指挥者的构建产品
        director.setHouseBuilder(new HighBuilding());
        System.out.println(director.build());
    }
}

    package com.yqj.pattern.builder.improve;
    
    //产品
    class House{
        private String basic;
        private String wall;
        private String roofed;
    
        public String getBasic() {
            return basic;
        }
    
        public void setBasic(String basic) {
            this.basic = basic;
        }
    
        public String getWall() {
            return wall;
        }
    
        public void setWall(String wall) {
            this.wall = wall;
        }
    
        public String getRoofed() {
            return roofed;
        }
    
        public void setRoofed(String roofed) {
            this.roofed = roofed;
        }
    
        @Override
        public String toString() {
            return "House{" +
                    "basic='" + basic + '\'' +
                    ", wall='" + wall + '\'' +
                    ", roofed='" + roofed + '\'' +
                    '}';
        }
    }
    
    //抽象建造者
    abstract class HouseBuilder{
        protected House house = new House();
        //建造流程，定义有关的抽象方法
        public abstract void buildBasic();
        public abstract void buildWalls();
        public abstract void roofed();
        //建造好房子，返回产品
        public House buildHouse(){
            return house;
        }
    }
    
    //具体建造者1
    class CommonHouseBuilder extends HouseBuilder{
        //实现具体的构建方法
        @Override
        public void buildBasic() {
            house.setBasic("普通房子打地基");
        }
    
        @Override
        public void buildWalls() {
            house.setWall("普通房子刷墙");
        }
    
        @Override
        public void roofed() {
            house.setRoofed("普通房子封顶");
        }
    }
    
    //具体建造者2
    class HighBuilding extends HouseBuilder{
    
        @Override
        public void buildBasic() {
            house.setBasic("别墅打地基");
        }
    
        @Override
        public void buildWalls() {
            house.setWall("别墅刷墙");
        }
    
        @Override
        public void roofed() {
            house.setRoofed("别墅封顶");
        }
    }
    
    
    
    //指挥者
    class HouseDirector{
        HouseBuilder houseBuilder;
    
        public HouseDirector(HouseBuilder houseBuilder) {
            this.houseBuilder = houseBuilder;
        }
    
        public void setHouseBuilder(HouseBuilder houseBuilder) {
            this.houseBuilder = houseBuilder;
        }
    
        //制定产品的构建流程
        public House build(){
            houseBuilder.buildBasic();
            houseBuilder.buildWalls();
            houseBuilder.roofed();
            //返回产品
            return houseBuilder.buildHouse();
        }
    }
    
    //用户
    public class Client{
        public static void main(String[] args) {
            HouseDirector director = new HouseDirector(new CommonHouseBuilder());
            System.out.println(director.build());
            //更改指挥者的构建产品
            director.setHouseBuilder(new HighBuilding());
            System.out.println(director.build());
        }
    }

    package com.yqj.pattern.builder.improve;

    //产品
    class House{
        private String basic;
        private String wall;
        private String roofed;

        public String getBasic() {
            return basic;
        }

        public void setBasic(String basic) {
            this.basic = basic;
        }

        public String getWall() {
            return wall;
        }

        public void setWall(String wall) {
            this.wall = wall;
        }

        public String getRoofed() {
            return roofed;
        }

        public void setRoofed(String roofed) {
            this.roofed = roofed;
        }

        @Override
        public String toString() {
            return "House{" +
                    "basic='" + basic + '\'' +
                    ", wall='" + wall + '\'' +
                    ", roofed='" + roofed + '\'' +
                    '}';
        }
    }

    //抽象建造者
    abstract class HouseBuilder{
        protected House house = new House();
        //建造流程，定义有关的抽象方法
        public abstract void buildBasic();
        public abstract void buildWalls();
        public abstract void roofed();
        //建造好房子，返回产品
        public House buildHouse(){
            return house;
        }
    }

    //具体建造者1
    class CommonHouseBuilder extends HouseBuilder{
        //实现具体的构建方法
        @Override
        public void buildBasic() {
            house.setBasic("普通房子打地基");
        }

        @Override
        public void buildWalls() {
            house.setWall("普通房子刷墙");
        }

        @Override
        public void roofed() {
            house.setRoofed("普通房子封顶");
        }
    }
    
    //具体建造者2
    class HighBuilding extends HouseBuilder{

        @Override
        public void buildBasic() {
            house.setBasic("别墅打地基");
        }

        @Override
        public void buildWalls() {
            house.setWall("别墅刷墙");
        }

        @Override
        public void roofed() {
            house.setRoofed("别墅封顶");
        }
    }



    //指挥者
    class HouseDirector{
        HouseBuilder houseBuilder;

        public HouseDirector(HouseBuilder houseBuilder) {
            this.houseBuilder = houseBuilder;
        }

        public void setHouseBuilder(HouseBuilder houseBuilder) {
            this.houseBuilder = houseBuilder;
        }

        //制定产品的构建流程
        public House build(){
            houseBuilder.buildBasic();
            houseBuilder.buildWalls();
            houseBuilder.roofed();
            //返回产品
            return houseBuilder.buildHouse();
        }
    }

    //用户
    public class Client{
        public static void main(String[] args) {
            HouseDirector director = new HouseDirector(new CommonHouseBuilder());
            System.out.println(director.build());
            //更改指挥者的构建产品
            director.setHouseBuilder(new HighBuilding());
            System.out.println(director.build());
        }
    }
帅哥阿飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
讲解Java设计模式编程中的建造者模式与原型模式
09-02
主要介绍了Java设计模式编程中的建造者模式与原型模式,设计模式有利于团队开发过程中的代码维护,需要的朋友可以参考下
原型模式 与 建造者模式
qq_43170213的博客
08-08 346
一、原型模式 原型模式(Prototype Pattern)是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，属于创建型模式。 原型模式的核心在于拷贝原型对象。以系统中已存在的一个对象为原型，直接基于内存二进制流进行拷贝，无需再经历耗时的对象初始化过程(不调用构造函数)，性能提升许多。当兑现的构建过程比较耗时时，可以利用当前系统中已存在的对象作为原型，对其进行克隆(一般是基于二进制流的复制)，躲避初始化过程，使得新对象的创建时间大大减少。下面，我们来看看原型模式类结构图。 在这里插入代码片
设计模式 - 创建型模式_原型模式
小工匠
01-27 2万+
原型模式主要解决的问题就是创建重复对象，⽽这部分 对象 内容本身⽐较复杂，⽣成过程可能从库或者RPC接⼝中获取数据的耗时较⻓，因此采⽤克隆的⽅式节省时间。
Python与设计模式--建造者模式
linjun的博客
11-24 1054
今天的例子，还是上一次谈到的快餐点餐系统。只不过，今天我们从订单的角度来构造这个系统。最先还是有请上次的主角们：最终，我们是要建造一个订单，因而，需要一个订单类。假设，一个订单，包括一份主食，一份小食，一种饮料。（省去一些异常判断）代码中的orderBuilder是什么鬼？这个orderBuilder就是建造者模式中所谓的“建造者”了，先不要问为什么不在order类中把所有内容都填上，而非要用builder去创建。接着往下看。
设计模式 - 创建型模式_建造者模式
热门推荐
小工匠
01-27 2万+
建造者模式所完成的内容就是通过将多个简单对象通过⼀步步的组装构建出⼀个复杂对象的过程。举个例子玩王者荣耀的时的初始化界⾯；有三条路、有树⽊、有野怪、有守卫塔等等，甚⾄依赖于你的⽹络情况会控制清晰度。⽽当你换⼀个场景进⾏其他不同模式的选择时，同样会建设道路、树⽊、野怪等等，但是他们的摆放和⼤⼩都有不同。这⾥就可以⽤到建造者模式来初始化游戏元素。⽽这样的根据相同的物料 ，不同的组装所产⽣出的具体的内容，就是建造者模式的最终意图，也就是将⼀个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
设计模式------原型模式与建造者模式
烟雨gps
05-02 1487
设计模式--------原型模式与建造者模式 目录 设计模式--------原型模式与建造者模式 1、原型模式 1.1什么是原型模式 1.2结构图 1.3浅克隆与深克隆实例 1.4典型应用 1.5小总结 2、构建者模式 2.1什么是构建者模式 2.2结构图 2.3实例演示 2.4典型应用 2.5小总结 1、原型模式 1.1什么是原型模式 ...
Java设计模式-创建型设计模式-建造者模式
Fatter$hday的博客
04-12 1122
Java设计模式-创建型设计模式-建造者模式
设计模式之建造者模式与原型模式
时间静止
08-20 486
单例模式 设计模式总分类创建型模式( 5种 )结构型模式( 7种 )行为型模式( 11种 )建造者模式实质应用场景演示代码原型模式实质应用场景实现方式演示代码 设计模式总分类 创建型模式( 5种 ) 单例模式 工厂模式 抽象工厂模式 建造者模式 原型模式 结构型模式( 7种 ) 适配器模式 桥接模式 装饰模式 组合模式 外观模式 享元模式 代理模式 行为型模式(...
设计模式 - Prototype 原型模式
敖丙
05-18 4075
我看行
Java设计模式-创建型设计模式-原型模式
Fatter$hday的博客
04-20 1153
Java设计模式-创建型设计模式-原型模式
【23种设计模式专题】四 建造者模式
12-20
建造者模式属于创建型模式，建造者模式是23种设计模式的一种，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，它提供了一种创建对象的最佳方式。 建造者关系： Product(产品)：具体...
设计模式-基于python1
08-03
第一章第一章 创建型模式创建型模式1.1 工厂模式(工厂方法、抽象工厂、单例模式及三者的区别)(重点)1.2 建造者模式1.3 原型模式第二章第二章 结构型模式
JAVA设计模式-day2.pdf
06-01
JAVA设计模式-day2，请的行业大能讲得课程，涉及：创建模式（5种： 1、 工厂方法模式（Factory Method）； 2、 抽象工厂模式； 3、 单例模式（Singleton） • 4、 建造者模式（Builder）； 5、 原型模式（Prototype...
设计模式-C++
09-01
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：...
node-v4.8.6-win-x64.zip
05-07
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基础运维技能（下）md格式笔记
最新发布
05-07
基础运维技能（下）md格式笔记
node-v8.1.2-linux-armv7l.tar.xz
05-07
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
黑马程序员 C语言学习笔记
05-07
持续更新
图解Java设计模式-23种设计模式
08-28
Java设计模式是一组经过实践验证的面向对象设计原则和模式，可以帮助开发人员解决常见的软件设计问题。下面是常见的23种设计模式： 1. 创建型模式（Creational Patterns）： - 工厂方法模式（Factory Method ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值