设计模式笔记系列 第二篇

已于 2024-02-02 11:23:13 修改
阅读量784 收藏 22
点赞数 24
文章标签： 设计模式 笔记 java
于 2024-02-01 10:25:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dlcoing/article/details/135950137
版权

        上篇我们笔记了可能都比较熟悉的简单工厂模式、工厂方法模式、抽象工厂模式以及单例模式。这篇咱们继续做笔记，介绍下原型模式、策略模式、适配器模式和模板模式。

        1、原型模式

                （一）、定义

                        用原型实例指定创建对象的类型，并通过拷贝这些原型来创建新的对象。

                （二）、结构

                        

    作为原型的对象，需要声明 Cloneable接口，实现clone接口。通过实现的clone方法，我们可以将原来对象的数据，直接复制一份。但要注意复制后的数据和原来的的数据不是同一个对象。

                （三）、代码演示

/**
 * @Description: 原型模式
 */
public class OriginalMode implements Cloneable{

    private Integer id;
    private String name;
    private kidsMode kidsMode;

    public OriginalMode() {
    }

    public OriginalMode(Integer id, String name, kidsMode kidsMode) {
        this.id = id;
        this.name = name;
        this.kidsMode = kidsMode;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public kidsMode getKidsMode() {
        return kidsMode;
    }

    public void setKidsMode(kidsMode kidsMode) {
        this.kidsMode = kidsMode;
    }

    @Override
    public OriginalMode clone() {
        OriginalMode originalMode = null;
        try {
            originalMode = (OriginalMode) super.clone();
            // 防止属性对象在克隆，跟源对象共享属性对象
            kidsMode keyStroke = this.kidsMode.clone();
            originalMode.setKidsMode(keyStroke);
            return originalMode;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public String toString() {
        return "hashcode:"+ this.hashCode() +", OriginalMode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", kidsMode=" + kidsMode +
                '}';
    }
}


/**
 * @Description: 原型对象引用的属性对象
 */
public class kidsMode implements Cloneable{

    private Integer kidsId;

    private String kidsName;

    public kidsMode(Integer kidsId, String kidsName) {
        this.kidsId = kidsId;
        this.kidsName = kidsName;
    }

    public Integer getKidsId() {
        return kidsId;
    }

    public void setKidsId(Integer kidsId) {
        this.kidsId = kidsId;
    }

    public String getKidsName() {
        return kidsName;
    }

    public void setKidsName(String kidsName) {
        this.kidsName = kidsName;
    }



    @Override
    public String toString() {
        return "hashcode"+ this.hashCode()+ ", kidsMode{" +
                "kidsId=" + kidsId +
                ", kidsName='" + kidsName + '\'' +
                '}';
    }

    @Override
    public kidsMode clone() {
        try {
            return (kidsMode) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}



/**
 * @Description: 原型模式单元测试
 */
public class OriginalModeTest {

    @Test
    public void test(){
        // 原对象数据
        OriginalMode originalMode = new OriginalMode(10, "原型对象名称",
                                        new kidsMode(105, "原型对象属性节点名称"));
        // 克隆后的对象数据
        OriginalMode cloneOriginalMode = originalMode.clone();

        System.out.println(originalMode);
        System.out.println(cloneOriginalMode);

        // 修改原对象属性对象数据
        kidsMode kidsMode = originalMode.getKidsMode();
        kidsMode.setKidsName("修改===》》》原型对象属性节点名称");
        originalMode.setKidsMode(kidsMode);

        System.out.println(originalMode);
        System.out.println(cloneOriginalMode);
    }
}

测试结果

        如上代码，如果要拷贝的对象OriginalMode存在对象属性kidsMode，那么对OriginalMode进行克隆的时候，需要对其属性也进行拷贝。简言之，当原型类中都是不可变对象属性时，对其实现clone接口进行浅拷贝即可；但如果原型类中存在可变对象时，需要进行深拷贝，即还需要对可变对象就行拷贝。

        2、策略模式

                （一）、定义

                        定义一系列的算法，把他们一个个的封装起来，并且使它们可以相互替换，并且算法的变化不会影响到使用算法的用户。

                

                （二）结构

比如，现在有这样个场景，某个产品需要根据不同地域的市场行情，算出产品定价，在向市场发布定价。我们用代码实现下~

                （三）、代码演示
/**
 * @Description: 策略模式
 */
public interface Strategy {

    /**
     * @description: 计算市场定价
     **/
    void calculate();

}


/**
 * @Description: 欧洲市场算法
 */
public class EuropeStrategyImpl implements Strategy {

    @Override
    public void calculate() {
        System.out.println("计算欧洲市场价格.......");
    }
}


/**
 * @Description: 本土市场算法
 */
public class LocalStrategyImpl implements Strategy {

    @Override
    public void calculate() {
        System.out.println("计算本土市场价格..........");
    }
}


/**
 * @Description: 区域市场
 */
public class RegionalMarket {

    private Strategy strategy;

    public RegionalMarket(Strategy strategy) {
        this.strategy = strategy;
    }

    /**
     * @description: 发布市场价格
     *
     * @return: void
     **/
    public void quote(){
        this.strategy.calculate();
        System.out.println("向"+ this.strategy.getClass().getName() +"发布市场价格......");
    }
}


/**
 * @Description: 策略模式单元测试
 */
public class StrategyTest {

    @Test
    public void test(){

        // 根据市场获取对应的算法
        Strategy strategy = new LocalStrategyImpl();

        // 传入算法得到具体的市场
        RegionalMarket regionalMarket = new RegionalMarket(strategy);

        // 市场报价
        regionalMarket.quote();
    }
}

测试结果：

        注意：策略模式的实现和工厂方法模式的实现很相似，但二者其实存在很大的区别。  首先，使用场景不一样：策略模式主要用于在运行中，根据不同的情况选择不同的计算或行为的场景；而工厂方法模式着重在于创建多个相似对象的场景。 其次，对象关系不同：策略模式具体实现的类可以相互替换，而工厂方法模式创建的对象是紧密相关的。他们的关注点也不同：策略模式关注的是对行为的封装，而工厂方法模式关注对象的创建。

      

        3、适配器模式  

                （一）、定义

                        将一个类的接口转换成客户端期望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作，主要解决接口不兼容的问题。

                （二）、结构

  简单来说就是Api A 通过适配器类的处理，转换为了Api B。比如现在有个手机充电头的需求，手机充电头只能接受15V的电压，而家庭电压是220V，我们采用适配器模式将220V的电压转变为15V的电压。

                （三）、代码实现
/**
 * @Description: 家庭电压 api
 */
public interface HouseVoltage {

    /**
     * @description: 输出家庭电压
     *
     * @return: int
     **/
    public int outputVoltage();
}

public class HouseVoltageImpl implements HouseVoltage {

    @Override
    public int outputVoltage() {
        return 220;
    }
}

/**
 * @Description: 手机电压 api
 */
public interface PhoneVoltage {

    /**
     * @description: 输出手机电压
     *
     * @return: int
     **/
    public int outputVoltage();
}


/**
 * @Description: 适配器
 */
public class Adapter implements PhoneVoltage {

    private HouseVoltage houseVoltage;

    public Adapter(HouseVoltage houseVoltage) {
        this.houseVoltage = houseVoltage;
    }

    /**
     * @description: 转变家庭电压成手机电压
     *
     * @return: int
     **/
    @Override
    public int outputVoltage() {
        int outputVoltage = this.houseVoltage.outputVoltage();
        // .............

        return 5;
    }
}

        4、模板方法模式

                （一）、定义

                                定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构，即可重定义该算法的某些特定步骤。

                (二）、结构

简单来说，我们可以定义一个骨架主类，将整个过程抽象划分成多个步骤。子类里可以按照抽象的步骤，完成各自不同的实现。既没有干扰的骨架的步骤，又分离开了多个类似流程不同的实现。

                （三）、代码实现
/**
 * @Description: 模板模式
 *      将每天的生活划分成几个步骤，定义出一个骨架
 */
public abstract class TemplateLife {

    /**
     * @description: 我常规的一天生活
     */
    protected void myOneDayLife() {
        this.getUp();
        this.dine();
        this.work();
        this.sleep();
    }

    /**
     * @description: 起床
     */
    public abstract void getUp();


    /**
     * @description: 吃饭
     */
    public abstract void dine();


    /**
     * @description: 工作
     */
    public abstract void work();

    /**
     * @description: 睡觉
     */
    public abstract void sleep();
}


/**
 * @Description: 工作日的一天生活
 */
public class WorkingDayLife extends TemplateLife {

    @Override
    public void getUp() {
        System.out.println("早起....");
    }

    @Override
    public void dine() {
        System.out.println("吃工作餐.....");
    }

    @Override
    public void work() {
        System.out.println("工作挣钱......");
    }

    @Override
    public void sleep() {
        System.out.println("加班很晚回家睡觉......");
    }
}


/**
 * @Description: 周末的一天生活
 */
public class WeekendLife extends TemplateLife {
    @Override
    public void getUp() {
        System.out.println("周末补觉........");
    }

    @Override
    public void dine() {
        System.out.println("在家里一起吃饭.......");
    }

    @Override
    public void work() {
        System.out.println("适当运动学习.....");
    }

    @Override
    public void sleep() {
        System.out.println("按时睡觉.........");
    }
}

/**
 * @Description: 模板模式的单元测试
 */
public class TemplateLifeTest {

    @Test
    public void test(){
        // 工作日的一天
        TemplateLife workingDayLife = new WorkingDayLife();
        workingDayLife.myOneDayLife();

        System.out.println("======================================");

        // 周末的一天
        TemplateLife weekendLife = new WeekendLife();
        weekendLife.myOneDayLife();
        
    }
}

好了，今天就分享到这里，下一篇咱们接着再做笔记~

渡 君
关注
  • 24
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
李建忠讲23种设计模式笔记-上
mg2flyingff的博客
04-06 2486
第一讲：设计模式简介 什么是设计模式 “每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的解决方案的核心。这样，你就能一次又一次地使用该方案而不必做重复劳动”。 ——Christopher Alexander 如何解决复杂性 1.分解 即分而治之，将大问题分解为多个小问题，将复杂问题分解为多个简单问题。分解是人们面对复杂性时的常见做法 2.抽象 由于不能掌握全部的复杂对象，从而选择...
侯捷C++八部曲笔记（三、设计模式）
weixin_42065178的博客
06-07 2638
侯捷C++八部曲笔记（三、设计模式）
【软考笔记 ——软件设计师】（七） 设计模式 总结
CPT1024
09-26 4346
总结看红色设计模式4个基本要素1、模式名称2、问题3、解决方案4 、 效果背 中英都要适配器模式 类和对象都一样背创建型 和 结构型创建型 （类 / 对象 ） 模式。
【设计模式笔记】单例模式
yrx00go的博客
03-16 2724
特点 A private constructor [私有构造函数] A static reference of its class[当前类的静态引用] One static method [一个静态方法获取实例] Globally accessible object reference [允许全局获取] Consistency across multiple threads [跨线程安全] 存在类型： 1、饿汉模式 直接赋值，用static标志，类加载较慢； // 饿汉模式：直接进行加载，在类加载时直接
《JavaScript设计模式》初次笔记——wsdchong
wsdchong的博客
06-17 1万+
《JavaScript设计模式》初次笔记 前言 设计模式一直久仰大名，但是没有去花时间去了解，于是今天特意花时间去看《JavaScript设计模式》（2013年6月出版）和w3cschool上的设计模式。然后做了一些笔记。 以《JavaScript设计模式》为目录，以w3cschool上的设计模式为补充。 讲的内容有三：设计模式、JavaScript设计模式、其他（模块化的JavaScript设计模式、jQuery设计模式、jQuery插件设计模式）。 学习目的：尝试性地了解JavaScript设计模式，方
设计模式原则笔记
一夜星尘
10-28 4944
Java 设计模式原则 合成复用原则 合成复用原则是指：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。 通常类的复用分为继承复用和合成复用。 继承复用虽然简单和易实现的有点，但是它也存在以下的缺点： 1.继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为'白箱'复用。 2.子类与父类的耦合度高。父类实现的任何改变导致子类的实现发生改变就，这不利于类的扩展和维护。 3.它限制了复用的灵活性。从父类继承而来的实现是静态的，在.
《设计模式》学习笔记整理手册
Nicky's blog
04-16 4187
文章目录一、GoF设计模式的分类1.1 创建型1.2 结构型1.3 行为型二、设计原则概述2.1 面向对象设计原则概述：2.2 单一职责原则2.3 开闭原则2.4 里氏代换原则2.5 依赖倒转原则2.6 接口隔离原则2.7 合成复用原则2.8 迪米特法则三、创建型设计模式3.1 抽象工厂模式3.1.1 模式定义3.1.2 模式角色3.1.3 简单例子3.1.4 抽象工厂模式和工厂模式的区别3.2 ...
马士兵设计模式笔记1之单例的几种实现方式
sk_Overlord_knife的博客
04-07 1193
//第一种  classic public class Singleton{ private static Singleton uniqueInstance; //other useful instance variables here private Singleton(){} public  static Singleton getInstance(){ if(
设计模式读书笔记与总结系列文章
夜深人静后的码农
04-11 1022
设计模式读书笔记设计模式目录 目录(?)[+] 这学期开始学习设计模式了，借了一本马士兵推荐的《JAVA与模式》，很厚，现在还在看。开始的时候，只是写一些读书笔记，只给自己看，文章的质量很低，后来我们老师和我们共享了CSDN访谈刘伟的一个文档，看了一下刘伟是怎么谈如何学习设计模式的，说是学设计模式，要知道设计模式的意图是什么，它要解决一个什么问题，什么时候可
Java高级程序设计笔记 • 【第6章 设计模式】
热门推荐
杨明金的博客
10-14 1万+
全部章节 >>>> 本章目录 6.1 设计模式 6.1.1 设计模式概述和分类 6.1.2 单列模式介绍 6.1.3 单例模式的实现 6.1.4 实践练习 6.2 单例模式的应用 6.2.1 单例模式应用场景 6.2.2 单例模式的优缺点分析 6.2.3 实践练习 6.3 简单工厂模式 6.3.1 简单工厂模式的介绍 6.3.2 实践练习 6.4 简单工厂模式的应用 6.4.1 简单工厂模式的使用场景 6.4.2 简单工厂的优缺点分析 6.4.3..
《C++20设计模式》学习笔记-第2章构造器模式学习代码
02-04
《C++20设计模式》学习笔记-第2章构造器模式学习代码
笔记_HeadFirst设计模式.pdf
06-16
笔记_HeadFirst设计模式
《设计模式解析》第2版学习笔记
01-13
阅读《设计模式解析》第2版 后的学习笔记
C#设计模式–单例模式
12-22
主要的参考书籍是《Head First 设计模式》，同时在学习过程中也查看了很多博客园中关于设计模式的一些文章的，在这里记录下我的一些学习笔记，一是为了帮助我更深入地理解设计模式，二同时可以给一些初学设计模式的...
设计模式之蝉
11-29
高清版的设计模式之蝉（第二版），附个人看书笔记，Java语言。
设计模式21——命令模式
weixin_43687024的博客
05-29 1060
1、将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。2、可以在 根据请求执行命令的类 里、设计一个命令队列，把 声明接收者执行哪些命令的类 保存起来；3、允许接受请求的一方拒绝请求。
设计模式-享元模式
楠姐的博客
05-29 686
享元模式（Flyweight Pattern）是一种用于效率和内存优化的结构型设计模式。这种模式通过共享尽可能多的相似对象来减少内存使用，特别适合于处理大量对象时，每个对象都消耗大量内存的场景。总的来说，享元模式在处理大量相似对象时提供了一种有效的内存优化策略。然而，它的使用应当谨慎，需要正确评估和设计内部状态和外部状态，以确保不会对应用程序的逻辑造成负面影响。在 JavaScript 等动态语言中，享元模式可以帮助管理内存消耗，尤其是在客户端浏览器环境中，这对提升用户体验和应用性能都是非常有益的。
设计模式深度解析：分布式与中心化
最新发布
zgw555555的专栏
05-31 538
分布式系统和中心化系统各有其特点和优势，适用于不同的业务场景。在设计系统时，应根据业务需求和技术特点选择适当的架构和设计模式。
设计模式深度解析：分布式与中心化，IT界两大巨头“华山论剑”
制定明确可量化的目标，坚持默默的做事。
05-26 2502
分布式模式与中心化模式各有其独特的优势和局限性。分布式模式因其高容错性和适应大规模复杂系统的能力，在处理大数据和高并发场景中具有显著优势，然而，其节点间数据传输的安全性要求高，且开发调试难度较大，这是其面临的挑战。相比之下，中心化模式在安全控制和开发维护方面更具优势，适用于对安全性和稳定性要求较高的场景。在选择时，需综合考虑业务需求和技术要求，权衡利弊。未来，随着云计算、边缘计算等技术的发展，两种模式将迎来新的机遇与挑战，需灵活调整策略，确保系统高效稳定运行。
数据库系统概论第五版笔记
03-17
很抱歉，我无法提供或介绍具体的书籍或笔记内容。但是，我可以为您提供数据库系统概论的一般概念和基本知识。数据库系统概论是关于数据库的基本概念、原理和应用的一门课程。它主要包括以下内容： 1. 数据库基本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值