5、设计模式

最新推荐文章于 2024-06-06 21:24:04 发布

小鱼做了就会

最新推荐文章于 2024-06-06 21:24:04 发布

阅读量229

点赞数

分类专栏： java基础知识文章标签：设计模式 java 开发语言

本文链接：https://blog.csdn.net/qq_41884396/article/details/127886817

版权

java基础知识专栏收录该内容

4 篇文章 0 订阅

订阅专栏

设计模式简介

设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。

设计原则

对接口编程而不是对实现编程。
优先使用对象组合而不是继承。

设计模式的类型

这些模式可以分为三大类：创建型模式、结构型模式、行为型模式

设计模式的六大原则

1、开闭原则：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。

2、里氏代换原则： 任何基类可以出现的地方，子类一定可以出现。

3、依赖倒转原则： 针对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则： 使用多个隔离的接口，比使用单个接口要好。降低类之间的耦合度。

5、迪米特法则，又称最少知道原则： 一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则： 尽量使用合成/聚合的方式，而不是使用继承。

1、工厂模式

意图： 定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类。

优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了。

2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点： 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

实现

步骤 1

创建一个接口:

public interface Shape {
   void draw();
}

步骤 2

创建实现接口的实体类。

public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}

public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}

public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

步骤 3

创建一个工厂，生成基于给定信息的实体类的对象。

public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

步骤 4

使用该工厂，通过传递类型信息来获取实体类的对象。

public class FactoryPatternDemo {
 
   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();
 
      //获取 Circle 的对象，并调用它的 draw 方法
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取 Rectangle 的对象，并调用它的 draw 方法
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
 
      //获取 Square 的对象，并调用它的 draw 方法
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
   }
}

步骤 5

执行程序，输出结果：

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

2、单例模式

单例模式具有典型的三个特点：

只有一个实例。
自我实例化。
提供全局访问点。

单例设计模式的优缺点：

优点：

1、由于单例模式只生成了一个实例，所以能够节约系统资源，减少性能开销，提高系统效率，

2、避免频繁的创建销毁对象，可以提高性能；

3、避免对共享资源的多重占用，简化访问；

4、为整个系统提供唯一一个全局访问点，能够严格控制客户对它的访问。

缺点：

1、不适用于变化频繁的对象；

2、也正是因为系统中只有一个实例，这样就导致了单例类的职责过重，违背了“单一职责原则”，

滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；

3、同时也没有抽象类，这样扩展起来有一定的困难。

4、如果实例化的对象长时间不被利用，系统会认为该对象是垃圾而被回收，这可能会导致对象状态的丢失；

单例模式的应用场景：

场景一：

windows的任务管理器，无论你点击多少次，始终都只有一个管理器窗口存在，系统并不会为你创建新的窗口，整个系统运行的过程中，系统只维护了一个进程管理器的实例。

场景二：

线程池、数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，用单例模式来维护，就可以大大降低这种损耗。

场景三：

程序的日志模块。一般也是采用单例模式实现。由于共享的日志文件一直处于打开状态，只能有一个实例去操作，否则内容不好追加。采用单例模式就可以。

场景四：

在我们的实际项目开发中，可以使用单例模式来封装一些常用的工具类，保证整个应用常用的数据统一。或者保存一些共享数据在内存中，其他类随时可以读取。

单例设计模式的两种方法：

懒汉式（类加载时并没有生成实例，只有在第一次调用getInstance的时候才生成实例化）

加入volatile 和 synchronized 可以保证线程安全，但是会影响性能；如果不加volatile 和 synchronized会存在线程安全问题，这是懒汉式单例的缺点。

优化后，双重检查（推荐使用）：

// 懒汉式(线程安全，同步方法)
public class Singleton {
    private static volatile Singleton instance;//对象属性前应使用volatile修饰，防止指令重排带来的同步问题
    
    private Singleton() {}
    
    //提供一个静态的公有方法，加入双重检查代码，解决线程安全问题, 同时解决懒加载问题
    //同时保证了效率, 推荐使用
    public static Singleton getInstance() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null) {
                    instance = new Singleton();
                }
            }
            
        }
        return instance;
    }
}

避免了资源的浪费；

提升了效率

防止了反射破坏

饿汉式（类加载的时候就开始生成实例，保证在调用getInstance的时候已经存在实例）

public class HungrySingleton
    {
        private static final HungrySingleton instance=new HungrySingleton();
        private HungrySingleton(){}
        public static HungrySingleton getInstance()
        {
            return instance;
        }
    }

优点：这种写法在类加载的时候就可以完成对象的实例化，避免了线程同步的问题
缺点：类装载就完成实例化，肯定会造成内存浪费问题

3、代理模式

在有些情况下，⼀个客户不能或者不想直接访问另⼀个对象，这时需要找⼀个中介帮忙完成某项任务，这个中介就是代理对象。

实现

4、适配器模式

在现实⽣活中，经常出现两个对象因接口不兼容而不能在⼀起工作的实例，这时需要第三者进行适配。

实现

5、策略模式

在现实生活中，常常遇到实现某种目标存在多种策略可供选择的情况。如：乘坐交通工具，有飞机、汽车、火车可供选择，但是只能选择一种。在软件开发中也常常遇到类似的情况，当实现某⼀个功能存在多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能。这些策略之间是相互排斥、可替换的。并且是有一定的优先级顺序的。