设计模式复习资料

已于 2022-01-28 15:37:29 修改
阅读量257 收藏
点赞数
分类专栏： 设计模式 文章标签： java
于 2022-01-26 16:03:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yaoayao123/article/details/122703819
版权

1.单例模式

饿汉模式1

复习点:
1 直接 new 一个 static final 的成员变量

public class Singleton {
   private static final Singleton instance = new Singleton();
   private Singleton() {}
   public static Singleton getInstance() {
       return instance;
   }
}
懒汉模式1

复习点:
1 volatile 禁止指令重排序
2 双重检查,线程安全,效率高

public class Singleton {
  private static volatile Singleton instance;
  private Singleton() {}
  public static Singleton getInstance() {
      if (instance == null) {
          synchronized (Singleton.class) {
              if (instance == null) {
                  instance = new Singleton();
              }
          }
      }
      return instance;
  }
}
懒汉模式2(推荐使用)

复习点:
1 jvm 保证线程安全
2 当第一次调用getInstance()时,才会加载SingletonHolder 类,所以是懒汉模式

public class Singleton {
  private static class SingletonHolder {
      private static final Singleton instance = new Singleton();
  }
  private Singleton() {
  }
  public static Singleton getInstance() {
      return SingletonHolder.instance;
  }
}
枚举(听这种写法是最完美的)

1 这种写法可以防止通过反射获得对象实例

public enum  Singleton {
    INSTANCE;
}

2.策略模式

复习点:
1.jdk 中的接口Comparator就是策略模式的应用
2.根据不同的策略执行不同的逻辑

//创建一个接口
public interface Strategy {
   public int doOperation(int num1, int num2);
}
//创建实现接口的实体类,加
public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}
//创建实现接口的实体类,减
public class OperationSubtract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}
//创建 Context 类。
public class Context {
   private Strategy strategy;
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}
//使用 Context 来查看当它改变策略 Strategy 时的行为变化。
public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());    
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationSubtract());      
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
   }
}

3.建造者模式

复习点:
1.为了编程方便,先构建一个比较简单的对象,再一点一点的设置属性

public class Person {
    int id;
    String name;
    int age;
    double weight;
    int score;
    Location loc;

    private Person() {}

    public static class PersonBuilder {
        Person p = new Person();

        public PersonBuilder basicInfo(int id, String name, int age) {
            p.id = id;
            p.name = name;
            p.age = age;
            return this;
        }

        public PersonBuilder weight(double weight) {
            p.weight = weight;
            return this;
        }

        public PersonBuilder score(int score) {
            p.score = score;
            return this;
        }

        public PersonBuilder loc(String street, String roomNo) {
            p.loc = new Location(street, roomNo);
            return this;
        }

        public Person build() {
            return p;
        }
    }
}

class Location {
    String street;
    String roomNo;

    public Location(String street, String roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }
}

4.适配器模式

复习点:
1.

4.外观模式

1.提供统一的门面,外界程序都和这个门面打交道
2.感觉电脑的例子更形象：
电脑整机是 CPU、内存、硬盘的外观。有了外观以后，启动电脑和关闭电脑都简化了

//形状父类
public interface Shape {
   void draw();
}
//长方形
public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Rectangle::draw()");
   }
}
//正方形
public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Square::draw()");
   }
}
//圆形
public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Circle::draw()");
   }
}
//外观类
public class ShapeMaker {
   private Shape circle;
   private Shape rectangle;
   private Shape square;
 
   public ShapeMaker() {
      circle = new Circle();
      rectangle = new Rectangle();
      square = new Square();
   }
 
   public void drawCircle(){
      circle.draw();
   }
   public void drawRectangle(){
      rectangle.draw();
   }
   public void drawSquare(){
      square.draw();
   }
}
//都通过外观类调用
public class FacadePatternDemo {
   public static void main(String[] args) {
      ShapeMaker shapeMaker = new ShapeMaker();
 
      shapeMaker.drawCircle();
      shapeMaker.drawRectangle();
      shapeMaker.drawSquare();      
   }
}

5.中介者模式

1.在现实生活中，有很多中介者模式的身影，例如QQ游戏平台，聊天室、QQ群、短信平台和房产中介。不论是QQ游戏还是QQ群，它们都是充当一个中间平台，QQ用户可以登录这个中间平台与其他QQ用户进行交流，如果没有这些中间平台，我们如果想与朋友进行聊天的话，可能就需要当面才可以了。
2.mq

6.装饰器模式

1.动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。
2.装饰模式为已有类动态附加额外的功能就像LOL、王者荣耀等类Dota游戏中，英雄升级一样。每次英雄升级都会附加一个额外技能点学习技能。

//Component 英雄接口 
public interface Hero {
    //学习技能
    void learnSkills();
}
//ConcreteComponent 具体英雄盲僧
public class BlindMonk implements Hero {
    
    private String name;
    
    public BlindMonk(String name) {
        this.name = name;
    }

    @Override
    public void learnSkills() {
        System.out.println(name + "学习了以上技能！");
    }
}
//Decorator 技能栏
public class Skills implements Hero{
    
    //持有一个英雄对象接口
    private Hero hero;
    
    public Skills(Hero hero) {
        this.hero = hero;
    }

    @Override
    public void learnSkills() {
        if(hero != null)
            hero.learnSkills();
    }    
}
//ConreteDecorator 技能：Q
public class Skill_Q extends Skills{
    
    private String skillName;

    public Skill_Q(Hero hero,String skillName) {
        super(hero);
        this.skillName = skillName;
    }

    @Override
    public void learnSkills() {
        System.out.println("学习了技能Q:" +skillName);
        super.learnSkills();
    }
}
//ConreteDecorator 技能：W
public class Skill_W extends Skills{

    private String skillName;

    public Skill_W(Hero hero,String skillName) {
        super(hero);
        this.skillName = skillName;
    }

    @Override
    public void learnSkills() {
        System.out.println("学习了技能W:" + skillName);
        super.learnSkills();
    }
}
//ConreteDecorator 技能：E
public class Skill_E extends Skills{
    
    private String skillName;
    
    public Skill_E(Hero hero,String skillName) {
        super(hero);
        this.skillName = skillName;
    }

    @Override
    public void learnSkills() {
        System.out.println("学习了技能E:"+skillName);
        super.learnSkills();
    }
}
//ConreteDecorator 技能：R
public class Skill_R extends Skills{    
    
    private String skillName;
    
    public Skill_R(Hero hero,String skillName) {
        super(hero);
        this.skillName = skillName;
    }
    
    @Override
    public void learnSkills() {
        System.out.println("学习了技能R:" +skillName );
        super.learnSkills();
    }
}
//客户端：召唤师
public class Player {
    public static void main(String[] args) {
        //选择英雄
        Hero hero = new BlindMonk("李青");
        
        Skills skills = new Skills(hero);
        Skills r = new Skill_R(skills,"猛龙摆尾");
        Skills e = new Skill_E(r,"天雷破/摧筋断骨");
        Skills w = new Skill_W(e,"金钟罩/铁布衫");
        Skills q = new Skill_Q(w,"天音波/回音击");
        //学习技能
        q.learnSkills();
    }
}


输出结果:
学习了技能Q:天音波/回音击
学习了技能W:金钟罩/铁布衫
学习了技能E:天雷破/摧筋断骨
学习了技能R:猛龙摆尾
李青学习了以上技能！

6.享元模式

1.共享对象
2.比如常量池,连接池,线程池

public class TestString {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        String s4 = new String("abc");

        System.out.println(s1 == s2); //true
        System.out.println(s1 == s3); //false
        System.out.println(s3 == s4); //false
        System.out.println(s3.intern() == s1);//true
        System.out.println(s3.intern() == s4.intern());//true
    }
}

7.桥接模式

复习点:
1.将抽象和实现放在两个不同的类层次中，使它们可以独立地变化。——《Head First 设计模式》

public interface DrawAPI {
   public void drawCircle(int radius, int x, int y);
}
public class RedCircle implements DrawAPI {
   @Override
   public void drawCircle() {
      System.out.println("Drawing Circle color: red");
   }
}
public class GreenCircle implements DrawAPI {
   @Override
   public void drawCircle() {
      System.out.println("Drawing Circle color: green");
   }
}
public abstract class Shape {
   protected DrawAPI drawAPI;
   protected Shape(DrawAPI drawAPI){
      this.drawAPI = drawAPI;
   }
   public abstract void draw();  
}
public class Circle extends Shape {
 
   public Circle(DrawAPI drawAPI) {
      super(drawAPI);
   }
 
   public void draw() {
      drawAPI.drawCircle();
   }
}
public class BridgePatternDemo {
   public static void main(String[] args) {
      Shape redCircle = new Circle(new RedCircle());
      Shape greenCircle = new Circle(new GreenCircle());
 
      redCircle.draw();
      greenCircle.draw();
   }
}

执行结果
Drawing Circle color: red
Drawing Circle  color: green

8.模板方法

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

public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();
   //模板,定义算法骨架
   public final void play(){
      //初始化游戏
      initialize();
      //开始游戏
      startPlay();
      //结束游戏
      endPlay();
   }
}
public class Cricket extends Game {
  @Override
   void endPlay() {
      System.out.println("Cricket Game Finished!");
   }
   @Override
   void initialize() {
      System.out.println("Cricket Game Initialized! Start playing.");
   }
   @Override
   void startPlay() {
      System.out.println("Cricket Game Started. Enjoy the game!");
   }
}
public class Football extends Game {
 
   @Override
   void endPlay() {
      System.out.println("Football Game Finished!");
   }
   @Override
   void initialize() {
      System.out.println("Football Game Initialized! Start playing.");
   }
   @Override
   void startPlay() {
      System.out.println("Football Game Started. Enjoy the game!");
   }
}
public class TemplatePatternDemo {
   public static void main(String[] args) {
 
      Game game = new Cricket();
      game.play();
      System.out.println();
      game = new Football();
      game.play();      
   }
}
程序猿_产品狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式期末复习资料
11-03
设计模式期末复习资料 本文档提供了设计模式的课程重点总结，包括了常见的设计模式和其类图实现。设计模式是软件工程中的一门重要课程，它们提供了一些通用的解决方案来解决软件设计中的一些常见问题。 面向对象的...
设计模式复习知识点（更新中）
最新发布
sunyoona的博客
05-21 343
设计模式
【复习资料】设计模式
weixin_30546189的博客
06-20 103
面向对象设计原则 对于面向对象的软件系统来说，在支持可维护性的同时，需要提高系统的可复用性。 软件的复用可以提高软件的开发效率，提高软件质量，节约开发成本，改善系统的可维护性。 单一职责原则要求在软件系统中，一个类只负责一个功能领域中的相应职责。 开闭原则要求一个软件实体应当对扩展开放，对修改关闭，即在不修改源代码的基础上扩展一个系统行为。 里氏代换原则：在软件中如果能够使用基类对象，那么一定能...
Java开发中常见的设计模式
Peanut的博客
07-16 441
关于什么是设计模式 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应
设计模式考题复习
KQ的博客
01-06 9696
一.定义 设计模式六大基本原则： 里氏替换原则 迪米特原则 开闭原则 单一职责原则 依赖倒置原则 接口隔离原则 “黑箱复用”——“B复用A的功能，但B无法看到A的内部细节” “白箱复用”——“B复用A的功能，并且B可以了解A的内部细节”。 **总体来说经典设计模式有23种，但不能说设计模式只有23种。**其分为三大类： 创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式（7）：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式
设计模式复习
GeniusLS的博客
12-30 1817
设计模式零零碎碎知识点 1，设计模式的两大主题：系统复用，系统扩展 设计模式UML图 设计模式六大原则 单一职责：一个类只负责一个相应的职责，只会有一个原因会引起类的改动 开闭原则：一个类对扩展开放，对修改关闭，在添加更新功能时不修改源代码 里氏替换原则：所有引用基类的地方，必须可以使用其子类 依赖倒置原则：高层模块不应该依赖于底层模块，而是应该依赖于他们的抽象，编程要面向对象而不是面向过程 接口隔离原则：应该使用多个接口去替代总的接口 迪米特法则：不和陌生人讲话，一个类应该尽可能少.
设计模式复习题，答案已用红色标记
05-17
设计模式复习题答案详解 设计模式作为软件设计中的重要组成部分，掌握设计模式可以帮助软件开发者更好地设计和实现软件系统。在本文中，我们将对设计模式复习题的答案进行详细解释，并从中总结出相关的知识点。 1....
大话设计模式对应的复习资料
01-23
该书通过故事讲述程序如何设计。希望能给渴望了解面向对象程序设计的初学者及困惑、无法复用的...本书主要采用C#介绍设计模式中比较常见的23种设计模式，分29章具体介绍，以现实生活中常见的事情为例来具体分析讲解。
设计模式复习PPT
11-05
非常好的设计模式复习资料，对设计模式的课程中的考试点做了详细的说明，适合期末复习
设计模式总结 考试复习资料
05-03
本系列主要记录设计模式的意图是什么，它要解决一个什么问题，什么时候可以使用它；它是如何解决的，掌握它的结构图，记住它的关键代码；能够想到至少两个它的应用实例，一个生活中的，一个软件中的；这个模式的优...
设计模式资料（一些书籍的pdf版）
11-09
自己收集的一些设计模式的经典书籍资料，很有用~
设计模式资料汇总
我叫王哈哈
11-20 248
设计模式
几个简单的设计模式资料整理
DoubleWeiWei001
09-05 415
装饰器模式： https://www.cnblogs.com/zhangtianq/p/6091047.html 适配器模式： https://blog.csdn.net/u012359453/article/details/79165080 工厂模式和抽象工厂模式： https://blog.csdn.net/qq_32623363/article/details/78246678 ...
<Java>设计模式大汇总，是时候来复习一波了
wocalage的博客
01-06 1077
如果说在开发过程中有什么需要反复学习的，设计模式无疑排在第一位！ 这段时间开始复习设计模式，所以，做了一个汇总，希望能够时不时进行查阅复习一下 仅针对了解设计模式的目标用户，如果还不了解，建议花些时间系统的学习一下 观察者模式 描述：有时被称作发布/订阅模式，观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知所
设计模式资料大全
CookieTo的博客
09-16 524
2012年-2013年，Sunny在CSDN技术博客中陆续发表了100多篇与设计模式学习相关的文章，涵盖了七个面向对象设计原则和24个设计模式（23个GoF设计模式 + 简单工厂模式），为了方便大家学习，现将所有文章的链接进行了整理，希望能给各位带来帮助！ 一、基础知识 1、设计模式概述 从招式与内功谈起——设计模式概述（一）：设计模式从何而来？ 从招式与内功谈起——设计模式概述（
设计模式期末复习重点
qq_44111805的博客
12-29 5489
1、UML（统一建模语言，包括视图，图，模型元素和通用机制四部分，5种视图和13个图） 2、类与类图 （1）类的属性即类的数据职责，类的操作即类的行为职责 （2）类图(Class Diagram)使用出现在系统中的不同类来描述系统的静态结构，它用来描述不同的类以及它们之间的关系 （3）在UML类图中，类一般由三部分组成：类名，属性和类的操作。 （PS:可见性：公有（+）；私有（-）；受保护（#）。为了保证数据的封装性，属性的可见性一般为private，通过公有的Getter和Setter方法供外界使用
设计模式资料
多看多听多总结
07-05 629
 Java源码中有哪些设计模式 http://www.iteye.com/news/18725 常见的设计模式类图 http://blog.sina.com.cn/s/blog_8cc6ff5c0101d4cp.html 常见的设计模式的示例 http://www.jb51.net/article/27973.htm
24种设计模式复习总结
热门推荐
GOON
08-29 1万+
24种设计模式复习总结
太原理工大学设计模式复习资料
05-05
以下是太原理工大学设计模式复习资料的一些建议和资源： 1. 《Head First设计模式》：这本书是学习设计模式的好入门书籍，通俗易懂，讲解深入浅出，适合初学者。 2. 《设计模式之禅》：该书是中国作者编写的设计...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值