Java常见设计模式总结（续）

最新推荐文章于 2024-07-07 05:30:00 发布
最新推荐文章于 2024-07-07 05:30:00 发布
阅读量204 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java 设计模式 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KangJinXuan/article/details/126586280
本文详细介绍了适配器模式、策略模式、装饰模式、代理模式、模板设计模式和观察者模式等六大设计模式的概念及应用场景，通过实例代码展示了如何在实际项目中灵活运用这些设计模式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.适配器模式   

适配器主要指的是对接口方法进行适配，看下面的例子：

package com.example;

public interface Phone {
    public void time();
    public void call() ;
}
package com.example;

public class Watch {
    public void time() {
        System.out.println("I am Watch:time");
    }
}

首先，我们有一个电话接口，电话可以看时间，打电话，同时我们有一个手表类，手表只能看时间，如果我们现在要写一个类去实现电话接口，一般需要实现它里面的所有方法，但是我们已经有了Watch类，所以我们可以将Watch类用上，具体实现如下： 　

package com.example;

public class Telephone extends Watch implements Phone {

    public void call() {
        // TODO Auto-generated method stub
        System.out.println("I am Telephone:call");
    }
}

测试一下调用：

package com.example;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Phone phone=new Telephone();
        phone.time();
        phone.call();
    }

}

结果：

可以看到，这里我们只实现了Phone的call接口，但是Telephone继承了Watch类，所以它有time方法，而且正好和Phone的time方法是同名同参数的，所以自动适配到了Phone接口的time方法，但是现实开发中，我们往往会碰到方法名或者参数不一样，但是同样功能的方法，我们就只能去显示的实现Phone的time接口了：

package com.example;

public class Telephone implements Phone {

    public void call() {
        // TODO Auto-generated method stub
        System.out.println("I am Telephone:call");
    }

    public void time() {
        // TODO Auto-generated method stub
        new Watch().time();
    }
}

另外，如果我们不想让Telephone有父类，或者Telephone有其他的父类要继承，因为java的单继承远程，我们也可以这么使用。

适配器模式可以理解为用已有的方法去实现同功能的接口，从而不至于造成同样的功能几个地方都有。还有，真实开发过程中，我们可以实现类和接口之间添加一些父类，这样可以更利于我们封装一些同功能的方法。

2.策略模式

程序里，我们经常会看到像下面：

 int result=0;
        if(flag==1){
            //做一些计算得到result
        }else if(flag==2){
            //做另外一些计算得到result
        }else{
            //做另外一些计算得到result
        }

如果这里面每个flag要做一些动作，那么这样的代码很不容易理解，而且也不方便拓展。于是我们可以创建一个这些操作的接口，然后每个flag对应的操作封装到不同实现这个接口的类型，比如：

package com.example;

public interface Calculator {
    public int exec(int a,int b);
}
package com.example;

public class PlusCalculator implements Calculator {

    public int exec(int a, int b) {
        // TODO Auto-generated method stub
        return a + b;
    }

}
package com.example;

public class MinusCalculator implements Calculator {

    public int exec(int a, int b) {
        // TODO Auto-generated method stub
        return a - b;
    }

}

测试使用：

package com.example;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int flag = 0;
        Calculator calculator = null;
        if (flag == 1) {
            calculator = new PlusCalculator();
        } else {
            calculator = new MinusCalculator();
        }
        int result = calculator.exec(5, 3);
        System.out.println(result);
    }

}

这里演示的只是简单的加减，但是实际的业务算法一般是比较复杂，代码量比较多的，如果不封装，代码会难看；当然，我们也可以为这些实现类写个父类，因为一般的，这些实现类都会有一些公共的逻辑。

3.装饰模式

装饰模式也有人叫修饰模式，其实，装饰模式就是对一些操作增加一些功能，比如在操作之前记录操作日志，操作之后记录结果。

比如，上面我们定义了一个计算接口，并有两个类实现了接口，加法类PlusCalculator 和减法类MinusCalculator ，正常调用，我们只有结果，到底哪两个参数我们不知道：

package com.example;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Calculator plus = new AddCalculator();
        int plusResult = plus.exec(5, 3);
        System.out.println(plusResult);

        Calculator minus = new MinusCalculator();
        int minusResult = minus.exec(5, 3);
        System.out.println(minusResult);
    }

}

结果是：

8
2

现在我们可以创建装饰类，用来记录打印计算的参数：

package com.example;

public class Decorator implements Calculator {
    Calculator calculator = null;

    public Decorator(Calculator calculator) {
        this.calculator = calculator;
    }

    public int exec(int a, int b) {
        // TODO Auto-generated method stub

        System.out.println("before:a=" + a + "    b=" + b);
        int result = calculator.exec(a, b);
        System.out.println("after:save result:" + result);
        return result;
    }

}

把测试改一下，执行后得到结果：

package com.example;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Calculator plus = new Decorator(new PlusCalculator());
        int plusResult = plus.exec(5, 3);
        System.out.println(plusResult);

        Calculator minus = new Decorator(new MinusCalculator());
        int minusResult = minus.exec(5, 3);
        System.out.println(minusResult);
    }

}

这样，我们就记录到了参数信息，这种做法可以用法记录操作日志和结果，简单的说，装饰模式就是拓展一个类型的功能，而不是去方法调用处一个个去加，如果接口的某些方法不想用了，可以抛出提示。

4.代理模式

　　代理模式在形式上和装饰模式有点像，但是和装饰模式的功能不一样，装饰模式更像修饰，修饰一个 接口，然后实现接口的所有类都能被修饰到，所以装饰的对象一般都是接口，而代理模式充当的是中介者的角色，你要访问必须通过类A去访问类B，所以代理的对象一般都是真实的类对象，比如上面的加法类和减法类，我们可以创建他们的代理：

package com.example;

public class PlusProxy implements Calculator {
    PlusCalculator calculator;

    public PlusProxy() {
        calculator = new PlusCalculator();
    }

    public int exec(int a, int b) {
        // TODO Auto-generated method stub
        System.out.println("before:a=" + a + "  b=" + b + "    a+b=?");
        int result = calculator.exec(a, b);
        System.out.println("after:a+b=" + result);
        return result;
    }

}
package com.example;

public class MinusProxy implements Calculator {

    MinusCalculator calculator;

    public MinusProxy() {
        calculator = new MinusCalculator();
    }

    public int exec(int a, int b) {
        // TODO Auto-generated method stub
        System.out.println("before:a=" + a + "  b=" + b + "    a-b=?");
        int result = calculator.exec(a, b);
        System.out.println("after:a-b=" + result);
        return result;
    }

}

然后我们使用代理类去操作，而不是直接对用对应的计算类操作：

package com.example;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Calculator plus = new PlusProxy();
        int plusResult = plus.exec(5, 3);
        System.out.println(plusResult);

        Calculator minus = new MinusProxy();
        int minusResult = minus.exec(5, 3);
        System.out.println(minusResult);
    }

}

结果输出：

 可以这么说，装饰模式和代理模式差不多，只是他们作用对象的区别.

5.模板设计模式

　　这个设计模式可以这么理解，把通用性的东西设置好，关键的部分放空，或者设置一个默认操作，然后使用模板是，只需要重写关键部分就可以了，换成类的方式去说就是，使用一个父类设计好模板，放出一些方法供子类实现或重写，比如：

package com.example;

public abstract class People {
    protected abstract String getName();

    protected abstract String getWord();

    public void say() {
        System.out.println(getName() + ":" + getWord());
    }
}

我们有一个People类，它有三个方法，但是有两个方法没有具体实现，而是留给子类去实现，我们写两个类去实现它：

package com.example;

public class Teacher extends People {

    @Override
    protected String getName() {
        // TODO Auto-generated method stub
        return "老师";
    }

    @Override
    protected String getWord() {
        // TODO Auto-generated method stub
        return "上课";
    }

}
package com.example;

public class Student extends People {

    @Override
    protected String getName() {
        // TODO Auto-generated method stub
        return "学生";
    }

    @Override
    protected String getWord() {
        // TODO Auto-generated method stub
        return "老师好";
    }

}

我们测试调用：

package com.example;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        People teacher=new Teacher();
        teacher.say();
        
        People student=new Student();
        student.say();

    }

}

 

6.观察者模式

观察者模式有点像回调函数，有点像订阅，就是先订阅，当状态发生变化时再通知，比如：

package com.example;

public interface Observer {
    public void send();
}

首先，我们有一个观察者接口，它有一个通知方法，就是通知订阅对象，QQ用户和微信用户都可以实现这个接口：

package com.example;

public class QQObserver implements Observer {

    public void send() {
        // TODO Auto-generated method stub
        System.out.println("QQ received");
    }

}
package com.example;

public class WxObserver implements Observer {

    public void send() {
        // TODO Auto-generated method stub
        System.out.println("Wx received");
    }

}

现在，观察者有两种类型，QQ用户和微信用户，然后我们可以定义一个博客类：

package com.example;

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

public class Blog {
    List<Observer> list=new ArrayList<Observer>();
    
    public void add(Observer obs) {
        list.add(obs);
    }    
    
    public void publish() {
        System.out.println("new blog published");
        
        Iterator<Observer> ite= list.iterator();
        while (ite.hasNext()) {
            Observer obs=ite.next();
            obs.send();
        }
    }
}

博客可以通过add方法添加订阅对象，当博客发布后，就会去通知这些订阅的对象，我们测试一下：

package com.example;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Observer qq=new QQObserver();
        Observer wx=new WxObserver();
        
        Blog blog=new Blog();
        blog.add(qq);//qq用户订阅
        blog.add(wx);//微信用户订阅
        blog.publish();//博客发布        
    }
}

总结：设计模式有很多种，但都是一些理解性的东西，自己动手敲敲代码能更好的理解，每种设计模式都特定的用处，要看具体情况具体看。不要认为设计模式很麻烦就不注重它，无数的经验告诉我们，一个好的程序设计能节省我们大量的时间和精力.

KangJinXuan
关注
「最全 Java 设计模式总结」
guojiaqi_的博客
11-23 1403
最全设计模式总结，二十三种设计模式 + 自定义Spring IOC功能实现
JAVA设计模式总结
GeorgeXu1990的博客
07-14 396
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式（5种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式） 2.结构型模式（7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式） 行为型模式（11种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式） 二、设计模式的六大原则 开闭原则（Open Close Principle） 里氏代换原则（Liskov S...
Java设计模式学习总结
Java技术江湖
07-08 5822
设计模式 创建型模式 创建型模式 创建型模式的作用就是创建对象，说到创建一个对象，最熟悉的就是 new 一个对象，然后 set 相关属性。但是，在很多场景下，我们需要给客户端提供更加友好的创建对象的方式，尤其是那种我们定义了类，但是需要提供给其他开发者用的时候。 单例 单例模式保证全局的单例类只有一个实例，这样的话使用的时候直接获取即可，比如数据库的一个连接，Spring里的be...
Java设计模式--总结
weixin_34130269的博客
09-26 151
设计模式是从许多优秀的软件系统中总结出成功的可复用的设计方案。设计模式一定是将简单的东西复杂化，哈哈哈，是不是矛盾，其实不然，扩展性大大增强。 什么是框架 框架不是模式，框架是针对某个领域，提供用于开发应用系统的类的集合，程序设计者可以使用框架提供的类设计一个应用程序，而且在设计应用程序时可以针对特定的问题使用某个模式。 1....
Java设计模式总结
Truong的专栏
08-29 931
一、策略模式 1、概念：策略模式定义了算法族，并将算法族封装起来，算法可以相互替换，算法的变动不会影响请求该算法的客户。 2、使用场景：               1）在不同类需要不同行为，或者不同类需要相同行为但行为表现（内容）不同时，可以使用strategy模式。需注意，在设计继承时需考虑是否使用策略模式， 尤其继承中有动态行为时。                2）根据不同的情况
【设计模式】Java 设计模式之桥接模式（Bridge）
新手村长的专栏
03-14 1958
本文概述了桥接设计模式的核心原理和应用场景。桥接模式通过分离抽象部分和实现部分，使得两者能够独立变化，从而提升了系统的灵活性和可扩展性。它特别适用于那些需要在多个维度上进行变化，或者要求抽象和实现独立演进的场景。实现桥接模式时，需明确抽象与实现的关系，设计稳定的抽象接口，并保持实现细节的独立性。尽管桥接模式可能增加系统的复杂性并带来一定的性能损失，但其带来的灵活性通常能够弥补这些不足。展望未来，桥接模式将继续在软件开发中发挥重要作用，结合其他技术和设计模式，共同构建高效、灵活且可靠的系统架构。
设计模式在Java项目中的实用之道
最新发布
windowshht的博客
07-07 978
本文将介绍几种我熟悉的设计模式，并结合实际项目中的应用场景，阐述它们在实际开发中的实用性和重要性。应用场景：在GUI编程中，当某个控件的状态（如文本框的内容、按钮的点击事件等）发生改变时，通常需要通知其他相关控件或对象进行相应的处理。在实际的Java项目开发中，设计模式的应用不仅可以提高代码的可读性和可维护性，还能增强系统的可扩展性和灵活性。：设计模式关注系统的可扩展性，使得在需求发生变化时，我们可以在不修改现有代码的情况下，通过扩展或添加新的功能来满足新的需求。这不仅减少了代码量，还提高了代码的质量。
Java多线程上传文件设计模式实现断点续传
根据所提供的文件信息，本文将对Java多线程设计模式进行详细介绍，并探讨如何通过这些设计模式实现文件的上传，特别是在处理分线程下载和断点续传以及超时重连方面的应用。 首先，我们需要明确什么是Java多线程。...
java断点续传原理_很简单的Java断点续传实现原理
weixin_31938727的博客
02-13 1996
原理解析在开发当中，“断点续传”这种功能很实用和常见，听上去也是比较有“逼格”的感觉。所以通常我们都有兴趣去研究研究这种功能是如何实现的？以Java来说，网络上也能找到不少关于实现类似功能的资料。但是呢，大多数都是举个Demo然后贴出源码，真正对其实现原理有详细的说明很少。于是我们在最初接触的时候，很可能就是直接Crtl + C/V代码，然后捣鼓捣鼓，然而最终也能把效果弄出来。但初学时这样做其实很...
Java多线程在文件上传中的应用与设计模式解析
总结而言，利用Java多线程设计模式上传文件，能够有效地提高上传效率，尤其适用于上传大文件或需要同时上传多个文件的场景。在实际开发中，应结合具体的业务需求和环境，选择合适的线程池配置、设计模式以及文件上传...
Java 设计模式总结
斌林诚上的博客
12-08 992
  前言 一、简介 二、设计模式的类型 三、23种设计模式简介 四、设计模式七大原则 五、常用设计模式 六、源码地址 七、参考文档 八、内容推荐 前言 1、设计模式来源？         答：设计模式来自于建筑领域，作为软件工程的一个分支。1995年由GOF收集整理了23种设计模式并出版了《Design Patterns: Elements of Reusable Obj...
java设计模式总结
傻瓜的博客
06-29 301
java23种设计模式（Design Patterns） 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美
设计模式总结
qq_28764557的博客
09-11 160
策略模式： 官方描述（定义一系列算法，把他们封装起来，并且使它们可以相互替换） 白话文描述：有共同的抽象行为，具体不同的行为称作为不同的策略，最终可以使用Context上下文获取对应策略。 应用场景:解决多重if判断问题、聚合支付平台、第三方联合登陆、调用多个不同短信接口等。 责任链模式: 官方描述:（将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。） 白话文描述...
Java常见设计模式总结
热门推荐
张维鹏的博客
09-18 19万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值