常用设计模式学习（一）

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

常用设计模式学习（一）

设计模式

这里是对几种常见设计模式进行学习。今天是面试回来复盘，面试官问的很基础，但是很遗憾的是，因为太基础没回答上。。。也是很无奈了。其实复习之后发现设计模式核心只为了三点，一是代码复用，二是解耦合，三是方便扩展，下面围绕这三点去学习几种常见的设计模式。

设计模式（Design Patterns），是一套可以被反复使用，多数人知晓的经过分类编目的，代码设计经验的总结。使用设计模式是为了可重用代码，方便他人理解，保证代码可靠性。
设计模式分三大类：

  • 创建型模式，五种：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
  • 结构型模式，七种：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
  • 行为型模式，十一种：策略模式，模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式。
  • 还有其他两种，并发模式和线程池模式。

设计模式的六大原则

  1. 开闭原则（open close Principle）：开闭原则就是对扩展开放，对修改关闭。在程序需要一个新功能的扩展和实现时候，不能去修改原有的代码，为了程序更好的扩展性，我们需要使用接口和抽象类。
  2. 里氏替换原则（Liskov Substitution Principle）：面向对象设计的基本原则之一。里氏替换原则中说，任何基类可以出现的地方，其子类也一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。
  3. 依赖倒转原则（Dependence Inversion Principle）：这个是开闭原则的基础，针对接口编程，依赖于抽象而不依赖于具体。
  4. 接口隔离原则（interface inversion Principle）：使用多个隔离的接口，比使用单个接口要好。还是降低类之间的耦合度的意思。
  5. 迪米特法则（最少知道法则）：一个实体应当尽量少的于其他实体之间发生相互作用，使得系统功能模块相互独立。
  6. 合成复用原则：原则是尽量使用合成的方式，而不是使用继承。

工厂模式

普通工厂模式

就是建立一个工厂类，对实现同一接口的一些类进行实例的创建。

/**
 * 普通工厂设计模式Demo，角色接口Role
 * @author 安澜
 */
public interface role {

    public void method();
}

/**
 * 普通工厂设计模式Demo，role的实现类student
 * @author 安澜
 */
public class student implements role {
    public void method() {
        System.out.println("this is  "+this.getClass().getSimpleName()+"  of role");
    }
}

/**
 * 普通工厂设计模式Demo，role的实现类teacher
 * @author 安澜
 */
public class teacher  implements role {

    public void method() {
        System.out.println("this is  "+this.getClass().getSimpleName()+"  of role");

    }
}

/**
 * 普通工厂设计模式Demo，工厂类FactoryDesign
 * @author 安澜
 */
public class FactoryDesign {

    public role getRole(String type){
    
        if("teacher".equals(type)){
            return new teacher();
            
        }else if("student".equals(type)){
            return new student();
            
        }else {
            System.out.println("类型输入错误==》"+type);
        }
        
        return null;
    }

}

/**
 * 普通工厂设计模式Demo
 * @author 安澜
 */
public class FactoryTest_One {
    public static void main(String[] args) {
    
        FactoryDesign factory = new FactoryDesign();
        
        role teacher = factory.getRole("teacher");
        teacher.method();
        
        role student = factory.getRole("student");
        student.method();
        
        role aNull = factory.getRole("null");
        aNull.method();
    }
}


this is  teacher  of role
this is  student  of role
类型输入错误==》null
Exception in thread "main" java.lang.NullPointerException
	at com.study.Design.demo.FactoryTest_One.main(FactoryTest_One.java:18)

多个工厂方法模式

对普通工厂模式的改进，在普通工厂模式中如果字符串错误则不能创建对象，而多个工厂模式提供多个工厂方法，分别创建对象。

/**
 * 多个工厂方法模式Demo，工厂类MultipleDactoryMethod
 * @author 安澜
 */
public class MultipleDactoryMethod {
    /**
     * get teacher
     * @return role
     */
    public role getTeacher(){
        return new teacher();
    }

    /**
     * get student
     * @return role
     */
    public role getStudent(){
        return new student();
    }
}

/**多个工厂方法模式Demo
 * @author 安澜
 */
public class FactoryTest_Thre {
    public static void main(String[] args) {

        MultipleDactoryMethod multipleDactoryMethod = new MultipleDactoryMethod();

        role student = multipleDactoryMethod.getStudent();
        student.method();

        role teacher = multipleDactoryMethod.getTeacher();
        teacher.method();
    }
}

this is  student  of role
this is  teacher  of role

静态工厂方法模式

就是将上面多个工厂模式中的方法设置为静态，不需要创建工厂的实例，直接调用即可。

/**
 * 静态工厂方法模式Demo，工厂类StaticDactoryMethod
 * @author 安澜
 */
public class StaticDactoryMethod {
    /**
     * get teacher
     * @return role
     */
    public static role getTeacher(){
        return new teacher();
    }

    /**
     * get student
     * @return role
     */
    public static role getStudent(){
        return new student();
    }
}

/**
 * 静态工厂方法模式Demo
 * @author 安澜
 */
public class FactoryTest_four {
    public static void main(String[] args) {

        role student = StaticDactoryMethod.getStudent();
        role teacher = StaticDactoryMethod.getTeacher();

        student.method();
        teacher.method();
    }
}

抽象工厂模式

工厂模式有一个缺陷，就是类的创建依赖于工厂类，也就是说如果我们需要拓展程序，必须对工厂类进行修改，违背了开闭原则，所以从设计模式的角度考虑，创建一个工厂类接口，让多个工厂类去实现这个接口，这样一旦需要增加新的功能，只需要增加新的工厂类就可以了，避免修改之前的代码。

/**
 * 抽象工厂模式，工厂接口FactoryInterface
 * @author 安澜
 */
public interface FactoryInterface {
    /**
     * get Role
     * @return role
     */
    public role getRole();
}

/**
 * 抽象工厂模式，工厂接口的实现类StudentFactory
 * @author 安澜
 */
public class StudentFactory implements FactoryInterface {
    /**
     * get Role
     * @return role
     */
    public role getRole() {
        return new student();
    }

}

/**
 * 抽象工厂模式，工厂接口的实现类TeacherFactory
 * @author 安澜
 */
public class TeacherFactory implements FactoryInterface {
    /**
     * get Role
     * @return role
     */
    public role getRole() {
        return new teacher();
    }
}

/**
 * 抽象工厂模式，工厂接口的新增实现类PrincipalFactory
 * @author 安澜
 */
public class PrincipalFactory implements FactoryInterface {
    /**
     * get Role
     * @return role
     */
    public role getRole() {
        return new principal();
    }
}

/**
 * 抽象工厂模式Demo
 * @author 安澜
 */
public class FactoryTest_Two {
    public static void main(String[] args) {

        FactoryInterface studentFactory = new StudentFactory();
        FactoryInterface teacherFactory = new TeacherFactory();
        PrincipalFactory principalFactory = new PrincipalFactory();

        role principal = principalFactory.getRole();
        principal.method();
        role stu = studentFactory.getRole();
        stu.method();
        role tea = teacherFactory.getRole();
        tea.method();
    }
}

this is  principal  of role
this is  student  of role
this is  teacher  of role

建造者模式

工厂模式提供的是创建单个类的方法，而建造者模式则是将各种产品集中起来管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。

/**建造者模式Demo，建造者类BuilderDesign
 * @author 安澜
 */
public class BuilderDesign {

   List<role> roles=new ArrayList<role>();

    /**
     * teacher Builder
     * @param count
     */
    public void teacherBuilder(int count){

        for(int i=1;i<=count;i++){
            roles.add(new teacher());
        }
    }

    /**
     * student Builder
     * @param count
     */
    public void studentBuilder(int count){

        for(int i=1;i<=count;i++){
            roles.add(new student());
        }
    }

    /**
     * principal Builder
     * @param count
     */
    public void principalBuilder(int count){

        for(int i=1;i<=count;i++){
            roles.add(new principal());
        }
    }
}

/**
 * 建造者模式Demo
 * @author 安澜
 */
public class BuilderDemo {
    public static void main(String[] args) {

        BuilderDesign builderDesign = new BuilderDesign();
        builderDesign.principalBuilder(1);
        builderDesign.teacherBuilder(5);
        builderDesign.studentBuilder(20);
    }
}

单例模式

单例模式是一种常见的设计模式，在java应用中，单例对象能保证在一个jvm中，该对象只有一个实例存在。

  1. 避免某些大型对象频繁创建，节省系统开销。
  2. 省去new操作符的使用，降低系统内存的使用频率，减轻GC压力。
  3. 在一些特定的场景下保证核心服务独立控制整个流程。

单例模式的实现——私有构造方法，静态属性

/**这是一个简单的单例类,不能满足多线程环境下的单例模式
 * @author 安澜
 */
public class SingletonClass {

    /**
     * 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载
     */
    private static SingletonClass Instance= null;

    /**
     * 私有构造方法，防止被实例化
     */
    private SingletonClass(){}

    /**
     * 静态工程方法，创建实例
     */
    public static SingletonClass getInstance(){
        return Instance=new SingletonClass();
    }

    /**
     * 如果该对象被用于序列化，可以保证对象在序列化前后保持一致
     */
    public Object readResolve() {
        return Instance;
    }
    
}

单例模式的实现——Synchronized，双重检验

/**SingletonClass With Synchronized,满足多线程环境下的单例模式
 * @author 安澜
 */
public class SingletonClassWithSynchronized {

    /**
     * 持有私有静态实例，防止被引用，此处赋值为null，目的是实现延迟加载
     */
    private static SingletonClassWithSynchronized Instance= null;

    /**
     * 私有构造方法，防止被实例化
     */
    private SingletonClassWithSynchronized(){}

    /**
     * 静态工程方法，创建实例
     * 这里使用双重检验防止多线程情景下创建了多个实例
     */
    public static SingletonClassWithSynchronized getInstance(){
        if(Instance==null) {
            synchronized (Instance) {
                if (Instance==null) {
                    return Instance=new SingletonClassWithSynchronized();
                }
            }
        }
        return Instance;
    }

    /**
     * 如果该对象被用于序列化，可以保证对象在序列化前后保持一致
     */
    public Object readResolve() {
        return Instance;
    }
    
}

在Java指令中创建对象和赋值操作是分开进行的，也就是说Instance= new
SingletonClassWithSynchronized();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的SingletonClassWithSynchronized实例分配空间，然后直接赋值给instance成员，然后再去初始化这个SingletonClassWithSynchronized实例。这样就可能出错了，我们以A、B两个线程为例：

a>A、B线程同时进入了第一个if判断

b>A首先进入synchronized块，由于instance为null，所以它执行instance = new SingletonClassWithSynchronized();

c>由于JVM内部的优化机制，JVM先画出了一些分配给SingletonClassWithSynchronized实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。

d>B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。

e>此时B线程打算使用SingletonClassWithSynchronized实例，却发现它没有被初始化，于是错误发生了。

单例模式的实现——静态内部类

/**SingletonClass With Factory,优化synchronized实现单例，满足多线程环境下的单例模式
 * @author 安澜
 */
public class SingletonClassWithFactory {
    
    /**
     * 私有构造方法，防止被实例化
     */
    private SingletonClassWithFactory(){}
    
    /**
     * 私有静态内部工厂类
     */
    private static class SingletonFactory{

        private static SingletonClassWithFactory instance=new SingletonClassWithFactory();

        private static SingletonClassWithFactory getInstance(){

            return SingletonFactory.instance;
        }

    }
    
}

JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样我们就不用担心上面的问题。

代理模式

代理模式就是多一个代理类出来，替元对象进行一些操作。

/**代理模式Demo，被代理接口ProxyInterface
 * @author 安澜
 */
public interface ProxyInterface {

    public void method();
}

/**代理模式Demo，元对象ProxyIMPL
 * @author 安澜
 */
public class ProxyIMPL implements ProxyInterface {
	/**
     * 被代理方法method
     */
    public void method() {
        System.out.println("this is proxy method ");
    }
}

/**代理模式Demo，代理类ProxyClass
 * @author 安澜
 */
public class ProxyClass implements ProxyInterface {

    private static ProxyIMPL proxyIMPL=new ProxyIMPL();


    public void method() {
        beforeMethod();
        proxyIMPL.method();
        afterMethod();
    }

    public void beforeMethod(){
        System.out.println("this is before method ");
    }

    public void afterMethod(){
        System.out.println("this is after method ");
    }

public static void main(String[] args) {

        ProxyClass proxyClass = new ProxyClass();
        proxyClass.method();
    }

this is before method 
this is proxy method 
this is after method

代理模式的应用场景：

如果已有的方法在使用的时候需要对原有的方法进行改进，此时有两种办法：

1、修改原有的方法来适应。这样违反了“对扩展开放，对修改关闭”的原则。

2、就是采用一个代理类调用原有的方法，且对产生的结果进行控制。这种方法就是代理模式。

使用代理模式，可以将功能划分的更加清晰，有助于后期维护！

菜菜嗯?
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之单例模式(Singleton)
diy_os的专栏
11-03 447
单例模式是一种常用的设计模式,可以保证对象在JVM中只有一个实例存在，这样做的好处可以不用重复的创建类对象，节省一笔很大的开销，而且可以减轻GC压力。常见的创建模式有懒汉模式和饿汉模式。但是如果考虑到不同场景，设计有很大差别。 懒汉模式:(类加载时，不立即创建实例，所以加载类速度快，但是获取实例较慢) public class SingIeton { /* * 持有私有静态实
常用的设计模式学习
lishuan182的博客
11-14 88
https://www.cnblogs.com/xiaofengwang/p/11255678.html
常用的设计模式的学习与理解心得
pvmsmfchcs的博客
08-08 122
##1，策略模式 优点：利用接口的多态，将接口作为参数传入，可以实现多种对象的传入。 缺点：需要有实现接口的多个策略类 ##2，代理模式 优点：可以生成多种功能的对象，比单纯只采用继承的方法更加的简单灵活 缺点：增加了许多子类，如果过度使用会使得程序变得很复杂 实例代码： public class Food { private String food_name; public Food() { } public Food(String food_name) { this
设计模式之二 --- Singleton 模式
蓝色妖姬
03-04 104
【1】基本概念 Singleton 是一种创建性模式,它用来确保只产生一个实例,并提供一个访问它的全局访问点。对一些类来说,保证只有一个实例是很重要的，比如有的时候，数据库连接或 Socket 连接要受到一定的限制,必须保持同一时间只能有一个连接的存在。 【2】简单分析 我们先来看一下该设计模式的UML结构图： 为了实现 Singleton 模式，我们需要的是一个静态的变...
设计模式:Singleton(单例模式)
TuringQi
07-31 199
Singleton(单例模式) 单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的
设计模式之代理模式分析使用
热门推荐
张彦峰的博客
05-21 164万+
代理模式原理和使用分析总结
常用的JAVA设计模式
weixin_69774975的博客
07-23 2739
无论您是新手，还是老手，本教程都值得一读。对于那些具有丰富的开发经验的开发人员，学习设计模式有助于了解在软件开发过程中所面临的问题的最佳解决方案；对于那些经验不足的开发人员，学习设计模式有助于通过一种简单快捷的方式来学习软件设计。...
JAVA常用的七种设计模式
weixin_44002920的博客
07-23 9456
JAVA设计模式概要
常用八种设计模式，怒肝21000字，常用设计模式看这一篇就够了
weixin_45716968的博客
04-09 3580
常用八种设计模式，怒肝21000字，常用设计模式看这一篇就够了 本文主讲八种设计模式，分别是单例、工厂方法、抽象工厂、代理模式、装饰器模式、策略模式、观察者模式、责任链模式。
Java中常用的设计模式
Superme
03-15 13万+
文章转载借鉴：http://blog.csdn.net/zhangerqing 一、什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块...
枚举工具类
qq_43049583的博客
08-04 225
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
泰勒今天想展开的博客
08-04 289
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
深入理解Java注解
weixin_55745942的博客
08-01 639
Java注解是用来描述程序元素（如类、方法、变量等）的一种机制。它们可以提供关于程序的补充信息，帮助编译器、框架或其他工具更好地理解和处理代码。注解通常以符号开头，后跟注解名称和可能的参数。要创建自定义注解，需要使用@interface关键字定义一个接口，并在接口中声明注解的属性。这个注解名为，可以被用来标记方法。它有一个名为value的属性，具有默认值"default"。
社区养老服务小程序的设计
Karen198的博客
07-31 621
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 568
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
java selenium 设置代理，允许在其他环境中使用不同的IP访问
huanghm88的专栏
08-05 205
此代码以Chrome浏览器为例，如果你使用其他浏览器，你需要相应地调整代码。另外，你需要下载适用于你的操作系统的Chrome浏览器驱动，并将路径替换为。在Java Selenium中设置代理可以使用。替换为其他环境中要访问的IP地址。替换为实际的代理IP和端口，并将。
【SpringBoot】数据验证之分组校验
最新发布
Jacker
08-05 182
下面通过示例演示分组校验。在上面的示例中，在@Validated注解中增加了{GroupA.class,Default.class}参数，表示对于定义了分组校验的字段使用GroupA校验规则，其他字段使用默认规则。@Length(min=20,max=30,message="必须在[20,30]")，groups={GroupA.class};@Length(min=30,max=40,message="必须在[30,40]",groups={GroupB.class})/**用户id**/
在java java.util.Date 已知逝去时间怎么求年月日
huanghm88的专栏
08-05 187
这样，你就可以得到逝去时间的年月日。需要注意的是，这只是一个简单的方法，不考虑闰年等情况。如果你需要更准确的结果，可以使用其他时间处理库，如Joda-Time或java.time包。
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 192
④创建artifact。②点击加号创建，选择。
Java设计模式详解：学习指南与实践案例
"Java设计模式学习.pdf 是一份关于Java设计模式的学习资料，涵盖了7种主要设计模式，并强调了学习方法和重要的设计原则。文件中还提到了常用的对象创建方式，如new关键字、newInstance方法、Constructor类以及Clone...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值