常用设计模式（通俗易懂的例子，小学生都能看懂！）

最新推荐文章于 2024-05-06 09:42:21 发布
最新推荐文章于 2024-05-06 09:42:21 发布
阅读量157 收藏
点赞数
分类专栏： 笔记 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ego12138/article/details/126586681
版权

责任链模式

package com.ego.chain;

public abstract class Boss {
    public int level; //等级
    public Boss nextBoss; //上级Boss

    public void process(int level){
        if(level <= this.level){
            approve();
        }
        if(nextBoss != null){
            nextBoss.process(level);
        }
    }

    //审批方法，由各个子类去实现
    public abstract void approve();
}


package com.ego.chain;

public class BigBoss extends Boss{

    public BigBoss(){
        this.level = 3;
    }

    @Override
    public void approve() {
        System.out.println("大Boss审批通过！");
    }
}


package com.ego.chain;

public class MidBoss extends Boss{

    public MidBoss(){
        this.level = 2;
    }

    @Override
    public void approve() {
        System.out.println("中Boss审批通过！");
    }
}


package com.ego.chain;

public class LittleBoss extends Boss{

    public LittleBoss(){
        this.level = 1;
    }

    @Override
    public void approve() {
        System.out.println("小Boss审批通过！");
    }
}


package com.ego.chain;

public class Test {
    public static void main(String[] args) {

        //三个级别的boss
        LittleBoss littleBoss = new LittleBoss();
        MidBoss midBoss = new MidBoss();
        BigBoss bigBoss = new BigBoss();

        //配置上下级关系
        littleBoss.nextBoss = midBoss;
        midBoss.nextBoss = bigBoss;

        //模拟三种级别的审批操作

        System.out.println("=========1级的审批过程========");
        littleBoss.process(1);
        System.out.println("=========2级的审批过程========");
        littleBoss.process(2);
        System.out.println("=========3级的审批过程========");
        littleBoss.process(3);
    }
}

组合模式

package com.ego.composite;

import com.sun.org.apache.xpath.internal.operations.Mod;

import java.util.ArrayList;
import java.util.List;

public class Module {
    public String name;
    public List<Module> children = new ArrayList<>();

    public Module(String name){
        this.name = name;
    }

    //具体执行逻辑
    public void process() {
        System.out.println(this.name + "执行");
        for(Module child : children){
            child.process();
        }
    }

    public void add(Module module) {
        children.add(module);
    }

    public void remove(Module module) {
        children.remove(module);
    }

    public List<Module> getChildren() {
        return children;
    }
}


package com.ego.composite;

public class Test {
    public static void main(String[] args) {
        //假设提交模块包含购物车和商品，购物车包含地址和支付
        Module submit = new Module("提交模块");
        Module shopping = new Module("购物车模块");
        Module address = new Module("地址模块");
        Module money = new Module("支付模块");
        Module goods = new Module("商品模块");

        submit.add(shopping);
        submit.add(goods);
        shopping.add(address);
        shopping.add(money);

        //执行提交模块，所有模块一起执行
        submit.process();
    }
}

Builder模式

package com.ego.builder;

import java.util.Objects;

public class Student {
    private String name;
    private int age;
    private int number;
    private String sex;

    public Student(StudentBuilder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.number = builder.number;
        this.sex = builder.sex;
    }

    //builder类
    public static class StudentBuilder{
        private String name;
        private int age;
        private int number;
        private String sex;

        public StudentBuilder setName(String name){
            this.name = name;
            return this;
        }
        public StudentBuilder setAge(int age){
            this.age = age;
            return this;
        }
        public StudentBuilder setNumber(int number){
            this.number = number;
            return this;
        }
        public StudentBuilder setSex(String sex){
            this.sex = sex;
            return this;
        }
        public Student build(){
            return new Student(this);
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", number=" + number +
                ", sex='" + sex + '\'' +
                '}';
    }
}


package com.ego.builder;

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student.StudentBuilder().setName("ego").build();
        Student student2 = new Student.StudentBuilder().setName("ego").setNumber(123456).build();
        Student student3 = new Student.StudentBuilder().setName("ego").setNumber(123456).setSex("男").build();
        Student student4 = new Student.StudentBuilder().setName("ego").setNumber(123456).setSex("男").setAge(20).build();

        System.out.println(student1);
        System.out.println(student2);
        System.out.println(student3);
        System.out.println(student4);

    }
}

工厂模式

package com.ego.factory;

public abstract class BaseDao {
    public abstract void insert();
    public abstract void delete();
}


package com.ego.factory;

public class CartDao extends BaseDao {
    @Override
    public void insert() {
        System.out.println("cartDao的增方法");
    }

    @Override
    public void delete() {
        System.out.println("cartDao的删方法");
    }
}


package com.ego.factory;

public class ShoppingDao extends BaseDao {
    @Override
    public void insert() {
        System.out.println("shoppingDao的增方法");
    }

    @Override
    public void delete() {
        System.out.println("shoppingDao的删方法");
    }
}


package com.ego.factory;

public class UserDao extends BaseDao {
    @Override
    public void insert() {
        System.out.println("userDao的增方法");
    }

    @Override
    public void delete() {
        System.out.println("userDao的删方法");
    }
}


package com.ego.factory;

import java.util.HashMap;
import java.util.Map;

public class DaoFactory {
    public static Map<String, BaseDao> map = new HashMap<>();
    static {
        map.put("userDao", new UserDao());
        map.put("shoppingDao", new ShoppingDao());
        map.put("cartDao", new CartDao());
    }
    public static BaseDao getDao(String name){
        return map.get(name);
    }
}


package com.ego.factory;

public class Test {
    public static void main(String[] args) {
        BaseDao userDao = DaoFactory.getDao("userDao");
        BaseDao shoppingDao = DaoFactory.getDao("shoppingDao");
        BaseDao cartDao = DaoFactory.getDao("cartDao");

        userDao.insert();
        userDao.delete();
        shoppingDao.insert();
        shoppingDao.delete();
        cartDao.insert();
        cartDao.delete();
    }
}

组合模式

package com.ego.facade;

public class Juice {

    public void cook(){
        System.out.println("做果汁");
    }

    public void secret(){
        System.out.println("这是果汁秘方，不能泄漏！");
    }
}


package com.ego.facade;

public class Meet {

    public void cook(){
        System.out.println("做肉");
    }

    public void secret(){
        System.out.println("这是肉秘方，不能泄漏！");
    }
}


package com.ego.facade;

public class Vegetable {

    public void cook(){
        System.out.println("做蔬菜");
    }

    public void secret(){
        System.out.println("这是蔬菜秘方，不能泄漏！");
    }
}


package com.ego.facade;

public class Waiter {
    Vegetable vegetable = new Vegetable();
    Meet meet = new Meet();
    Juice juice = new Juice();

    public void cookVegetable(){
        vegetable.cook();
    }
    public void cookMeet(){
        meet.cook();
    }
    public void cookJuice(){
        juice.cook();
    }
}


package com.ego.facade;

public class Test {
    public static void main(String[] args) {
        //假设某人点了蔬菜、肉、果汁三种食品，一直没有上菜，需要催菜

        //传统方式：自己去找对应的厨师催
        System.out.println("======传统方式=======");
        Vegetable vegetable = new Vegetable();
        Meet meet = new Meet();
        Juice juice = new Juice();

        //非常麻烦，得自己去催！
        vegetable.cook();
        meet.cook();
        juice.cook();

        //而且秘方泄漏了！！
        vegetable.secret();
        meet.secret();
        juice.secret();

        //门面模式：由服务员去催     又方便又不会泄漏秘方
        System.out.println("======门面模式======");
        Waiter waiter = new Waiter();
        waiter.cookVegetable();
        waiter.cookMeet();
        waiter.cookJuice();

    }
}

装饰模式

package com.ego.decorator;

public abstract class Food {
    public String food;
    public abstract String cook();
}


package com.ego.decorator;

public class Chicken extends Food{
    public Chicken(){
        this.food = "鸡肉";
    }
    @Override
    public String cook() {
        return this.food;
    }
}


package com.ego.decorator;

public class Meet extends Food{
    public Meet(){
        this.food = "牛肉";
    }
    @Override
    public String cook() {
        return this.food;
    }
}


package com.ego.decorator;

public abstract class DecorationFood extends Food {
    public abstract String cook();
    public abstract String type();
}


package com.ego.decorator;

public class SteamFood extends DecorationFood {
    Food food;
    public SteamFood(Food food){
        this.food = food;
    }
    @Override
    public String cook() {
        return type() + this.food.cook();
    }

    @Override
    public String type() {
        return "蒸";
    }
}


package com.ego.decorator;

public class ToastFood extends DecorationFood {
    Food food;
    public ToastFood(Food food){
        this.food = food;
    }
    @Override
    public String cook() {
        return type() + this.food.cook();
    }

    @Override
    public String type() {
        return "烤";
    }
}


package com.ego.decorator;

public class Test {
    public static void main(String[] args) {
        System.out.println("======普通做法======");
        Food chicken = new Chicken();
        Food meet = new Meet();
        System.out.println(chicken.cook());
        System.out.println(meet.cook());

        //装饰模式
        System.out.println("======高级做法======");
        DecorationFood toast = new ToastFood(chicken);
        DecorationFood steam = new SteamFood(toast);
        System.out.println(toast.cook());
        System.out.println(steam.cook());
    }
}
Ego12138
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式_简单易懂的例子，且很有意思
05-07
1. 策略模式 2. 代理模式 3. 单例模式 4. 多例模式
23种设计模式概要及易懂的例子
weixin_30466953的博客
08-17 181
23种设计模式（分为三大类） 因为内容是从有道云笔记挪过来的，所以排版有点丑，如有不足或错误还望指点。。 注意，一些设计模式之间的(代码)"形式"虽然相同或相似，但是"语义"是截然不同的。个人认为设计模式提倡的是一种编码思想，而不是规范。 为什么要使用设计模式？为了代码复用，增加可维护性 设计模式的六大原则 1、开...
设计模式的理解与举例
qq_43569680的博客
04-07 1164
设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
初探Java设计模式3：行为型模式（策略，观察者等）
Java技术江湖
09-28 644
转自https://javadoop.com/post/design-pattern 行为型模式 策略模式 观察者模式 责任链模式 模板方法模式 状态模式 行为型模式总结 本系列文章将整理到我在GitHub上的《Java面试指南》仓库，更多精彩内容请到我的仓库里查看 https://github.com/h2pl/Java-Tutorial 喜欢的话麻烦点下Star、fork哈 文章也将...
【设计模式】之23种设计模式的基本原理及例子
weixin_42615154的博客
04-29 1515
设计模式1 设计模式六大原则1.1 单一职责原则1.2 开放-关闭原则1.3 依赖倒转原则1.4 里氏替换原则1.5 迪米特法则2 创建型2.1 工厂模式2.1.1简单工厂模式2.1.2 工厂方法模式2.1.3 抽象工厂模式2.2 原型模式2.3 建造者模式3 结构型3.1 代理模式3.2 外观模式3.3 适配器模式4 行为型4.1 策略模式4.2 装饰者模式4.3 模板方法模式4.4 观察者模式4.5 状态模式4.6 备忘录模式 1 设计模式六大原则 1.1 单一职责原则 原理   在软件组件设计中，
小学生也能看懂的！！！编程小白必看：23种设计模式轻松入门！详解(全23种).zip
03-21
本文以通俗易懂的语言，详细介绍了23种设计模式。通过比喻和简单的例子，解释了每种设计模式的工作原理和用途，旨在帮助初学者理解并应用这些模式，以提高代码的质量和可维护性。 **适用人群**： 这篇文章适合编程...
白话设计模式通俗易懂
10-10
非常好的设计模式介绍资料，通俗易懂，适用于编程人员参考。采用了大量图片介绍系统的展示了编程当中常用的各种模式设计
C++设计模式全总结-通俗易懂
10-30
通俗易懂的使用C++总结了全部设计模式，很好的学习资料
深入浅出设计模式(非常详细通俗易懂).docx
09-28
深入浅出设计模式(非常详细通俗易懂)
Head First设计模式。通俗易懂的语言描述模式的神奇
05-07
Head First设计模式。通俗易懂的语言描述模式的神奇
设计模式：桥接模式
最新发布
玉汝于成
05-06 412
接模式是一种对象结构型模式，它将抽象部分与它的实现部分分离，使它们都可以独立地变化。这种分离允许抽象和实现部分独立地扩展，而不会相互影响。桥接模式基于类的最小设计原则，通过封装、聚合及继承等行为让不同的类承担不同的职责。
设计模式（十）：装饰者模式
wenqi1992的博客
04-29 443
装饰者模式的介绍
23种设计模式
weixin_72256328的博客
05-01 982
23种设计模式
【学习vue 3.x】(一)基础内容
m0_74187147的博客
04-30 1607
Vue.js是一套构建用户界面的渐进式框架，采用自底向上增量开发的设计，核心库只关注视图层。另一方面，Vue完全有能力驱动采用单文件组件和Vue生态系统支持的库开发的复杂单页应用。 Vue是一个框架，也是一个生态。可以用不同的方式使用Vue： 无需构建步骤，渐进式增强静态的HTML； 在任何页面中作为Web Components嵌入； 单页应用 (SPA)； 全栈/服务端渲染 (SSR)； Jamstack/静态站点生成 (SSG)； 开发桌面端、移动端、WebGL，甚至是命令行终端中的界面。
设计模式: 工厂模式
m0_59925573的博客
05-02 585
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。主要解决接口选择的问题。我们明确地计划不同条件下创建不同实例时。让其子类实现工厂接口，返回的也是一个抽象的产品。创建过程在其子类执行。1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。2、在 Hibernate 中，如果需要更换数据库，工厂模式同样发挥了作用。只需简单地更改方言（Dialect）和数据库驱动（Driver），就能够实现对不同数据库的切换。
设计模式之MVC模式
Rcain_R的博客
05-02 1134
MVC（Model-View-Controller）模式是一种软件设计模式，广泛应用于构建用户界面的软件架构中，特别是在Web应用程序开发中。
设计模式一
hummhumm的专栏
05-04 528
单例模式简介。
【设计模式】之模板方法模式
小杰不秃头的博客
04-29 1086
今天给大家介绍23种设计模式中的模板方法模式，这个设计模式在Spring框架中还是挺常见的，手写Spring源码的小伙伴必须要掌握的设计模式之一，文章结构还是经典的三连问，是什么？为什么？怎么用？🌈
列举一下Java的设计模式，并写个案例通俗易懂一点
04-08
好的，关于Java的设计模式，常见的有23种，其中比较常用的包括单例模式、工厂模式、观察者模式等等。这里举个例子来说明一下工厂模式的应用。 工厂模式是用来创建对象的一种模式，它提供了一种创建对象的最佳方式。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值