Java中几种常用设计模式

怼烎@ 2024-04-19 14:42 134阅读 0赞

一、介绍

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

二、设计模式分类  
创建型模式，五种，即工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。  
结构型模式，：七种，即适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。  
行为型模式，十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

三、设计模式六大原则  
（1）开闭原则（Open Close Principle）  
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。概括来说，为了使程序的扩展性好，易于维护和升级，需要使用接口和抽象类。  
（2）里氏代换原则（Liskov Substitution Principle）  
在里氏代换原则中，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。  
（3）依赖倒转原则（Dependence Inversion Principle）  
这个是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。  
（4）接口隔离原则（Interface Segregation Principle）  
使用多个隔离的接口，比使用单个接口要好。可降低类之间的耦合度。  
（5）迪米特法则（最少知道原则）（Demeter Principle）  
一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。  
（6）合成复用原则（Composite Reuse Principle）  
原则是尽量使用合成/聚合的方式，而不是使用继承。

四、几种常见模式设计  
1、单例模式  
一个类只有一个实例（实例对象），且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。  
单例模式分为懒汉式和饿汉式，讲解如下：  
（1）饿汉式：构造方法私有化，外部无法产生新的实例化对象，只能通过static方法取得实例化对象

class Singleton {
    
         //在类的内部可以访问私有结构，所以可以在类的内部产生实例化对象
        private static Singleton instance = new Singleton();
        
         //private 声明构造
        private Singleton() {
        
        }
     //返回对象实例
        public static Singleton getInstance() {
            return instance;
        }
        public void print() {
            System.out.println("Hello Singleton...");
        }
    }

（2）懒汉式：当第一次去使用Singleton对象的时候才会为其产生实例化对象的操作

class Singleton {
    
    //声明变量
        private static volatile Singleton singleton = null;
        
    //私有构造方法
        private Singleton() {
        
        }
         //提供对外方法
        public static Singleton getInstance() {
        
         // 还未实例化
            if (singleton == null) {
                synchronized (Singleton.class) {
                    if (singleton == null) {
                        singleton = new Singleton();
                    }
                }
            }
            return singleton;
        }
        public void print() {
            System.out.println("Hello World");
        }
    }

当多个线程并发执行 getInstance 方法时，懒汉式会存在线程安全问题，所以用到了 synchronized 来实现线程的同步，当一个线程获得锁的时候其他线程就只能在外等待其执行完毕。而饿汉式则不存在线程安全的问题。

2、工厂模式  
工厂模式分为工厂方法模式和抽象工厂模式

工厂方法模式  
①工厂方法模式分为三种：普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。  
② 多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。  
③静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

（1）普通工厂模式  
建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

interface Sender {
        void Send();
    }
    
    class MailSender implements Sender {
    
        @Override
        public void Send() {
            System.out.println("This is mail sender...");
        }
    }
    
    class SmsSender implements Sender {
    
        @Override
        public void Send() {
            System.out.println("This is sms sender...");
        }
    }
    
    public class FactoryPattern {
        public static void main(String[] args) {
            Sender sender = produce("mail");
            sender.Send();
        }
        public static Sender produce(String str) {
            if ("mail".equals(str)) {
                return new MailSender();
            } else if ("sms".equals(str)) {
                return new SmsSender();
            } else {
                System.out.println("输入错误...");
                return null;
            }
        }
    }

（2）多个工厂方法模式  
该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

interface Sender {
        void Send();
    }
    
    class MailSender implements Sender {
    
        @Override
        public void Send() {
            System.out.println("This is mail sender...");
        }
    }
    
    class SmsSender implements Sender {
    
        @Override
        public void Send() {
            System.out.println("This is sms sender...");
        }
    }
    
    class SendFactory {
        public Sender produceMail() {
            return new MailSender();
        }
    
        public Sender produceSms() {
            return new SmsSender();
        }
    }
    
    public class FactoryPattern {
        public static void main(String[] args) {
            SendFactory factory = new SendFactory();
            Sender sender = factory.produceMail();
            sender.Send();
        }
    }

（3）静态工厂方法模式  
将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

interface Sender {
        void Send();
    }
    
    class MailSender implements Sender {
    
        @Override
        public void Send() {
            System.out.println("This is mail sender...");
        }
    }
    
    class SmsSender implements Sender {
    
        @Override
        public void Send() {
            System.out.println("This is sms sender...");
        }
    }
    
    class SendFactory {
        public static Sender produceMail() {
            return new MailSender();
        }
    
        public static Sender produceSms() {
            return new SmsSender();
        }
    }
    
    public class FactoryPattern {
        public static void main(String[] args) {
            Sender sender = SendFactory.produceMail();
            sender.Send();
        }
    }

（4）抽象工厂模式  
工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要扩展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？  
那么这就用到了抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

interface Provider {
        Sender produce();
    }
    
    interface Sender {
        void Send();
    }
    
    class MailSender implements Sender {
    
        public void Send() {
            System.out.println("This is mail sender...");
        }
    }
    
    class SmsSender implements Sender {
    
        public void Send() {
            System.out.println("This is sms sender...");
        }
    }
    
    class SendMailFactory implements Provider {
    
        public Sender produce() {
            return new MailSender();
        }
    }
    
    class SendSmsFactory implements Provider {
    
        public Sender produce() {
            return new SmsSender();
        }
    }
    
    
    public class FactoryPattern {
        public static void main(String[] args) {
            Provider provider = new SendMailFactory();
            Sender sender = provider.produce();
            sender.Send();
        }
    }

3、适配器模式  
适配器模式是将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的的类的兼容性问题。主要分三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

（1）类的适配器模式

class Source {
        public void method1() {
            System.out.println("This is original method...");
        }
    }
    
    interface Targetable {
    
    //与原类中的方法相同
        public void method1();
        
    // 新类的方法
        public void method2();
    }
    
    class Adapter extends Source implements Targetable {
        @Override
        public void method2() {
            System.out.println("This is the targetable method...");
        }
    }
    
    public class AdapterPattern {
        public static void main(String[] args) {
            Targetable targetable = new Adapter();
            targetable.method1();
            targetable.method2();
        }
    }

4、代理模式  
代理模式指给一个对象提供一个代理对象，并由代理对象控制对原对象的引用。代理可以分为静态代理和动态代理。  
通过代理模式，可以利用代理对象为被代理对象添加额外的功能，以此来拓展被代理对象的功能。可以用于计算某个方法执行时间，在某个方法执行前后记录日志等操作。

（1）静态代理  
静态代理需要我们写出代理类和被代理类，而且一个代理类和一个被代理类一一对应。代理类和被代理类需要实现同一个接口，通过聚合使得代理对象中有被代理对象的引用，以此实现代理对象控制被代理对象的目的。

//代理类和被代理类共同实现的接口
    interface IService {
        void service();
    }
    
    // 被代理类
    class Service implements IService{
        @Override
        public void service() {
            System.out.println("被代理对象执行相关操作");
        }
    }
    
    //代理类
    class ProxyService implements IService{
    
      //持有被代理对象的引用
        private IService service;
        
    //默认代理Service类
        public ProxyService() {
            this.service = new Service();
        }
        
    //也可以代理实现相同接口的其他类
        public ProxyService(IService service) {
            this.service = service;
        }
    
        @Override
        public void service() {
            System.out.println("开始执行service()方法");
            service.service();
            System.out.println("service()方法执行完毕");
        }
    }
    
    //测试类
    public class ProxyPattern {
    
        public static void main(String[] args) {
            IService service = new Service();
            
            //传入被代理类的对象
            ProxyService proxyService = new ProxyService(service);
            proxyService.service();
        }
    }

（2）动态代理  
动态代理常用于有若干个被代理的对象，且为每个被代理对象添加的功能是相同的（例如在每个方法运行前后记录日志）。  
动态代理的代理类不需要我们编写，由Java自动产生代理类源代码并进行编译最后生成代理对象。  
创建动态代理对象的步骤：  
①指明一系列的接口来创建一个代理对象  
②创建一个调用处理器（InvocationHandler）对象  
③将这个代理指定为某个其他对象的代理对象  
④在调用处理器的invoke（）方法中采取代理，一方面将调用传递给真实对象，另一方面执行各种需要的操作

//代理类和被代理类共同实现的接口
    interface IService {
        void service();
    }
    
    class Service implements IService{
    
        @Override
        public void service() {
            System.out.println("被代理对象执行相关操作");
        }
    }
    
    class ServiceInvocationHandler implements InvocationHandler {
    
    //被代理的对象
        private Object srcObject;
    
        public ServiceInvocationHandler(Object srcObject) {
            this.srcObject = srcObject;
        }
    
        @Override
        public Object invoke(Object proxyObj, Method method, Object[] args) throws Throwable {
            System.out.println("开始执行"+method.getName()+"方法");
            
            //执行原对象的相关操作，容易忘记
            Object returnObj = method.invoke(srcObject,args);
            System.out.println(method.getName()+"方法执行完毕");
            return returnObj;
        }
    }
    
    public class ProxyPattern {
        public static void main(String[] args) {
            IService service = new Service();
            Class<? extends IService> clazz = service.getClass();
    
            IService proxyService = (IService) Proxy.newProxyInstance(clazz.getClassLoader(),
                                            clazz.getInterfaces(), new ServiceInvocationHandler(service));
            proxyService.service();
        }
    }

5、装饰模式  
装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

interface Shape {
        void draw();
    }
    
    // 实现接口的实体类
    class Rectangle implements Shape {
    
        @Override
        public void draw() {
            System.out.println("Shape: Rectangle...");
        }
    }
    
    class Circle implements Shape {
    
        @Override
        public void draw() {
            System.out.println("Shape: Circle...");
        }
    }
    
    //创建实现了 Shape 接口的抽象装饰类。
    abstract class ShapeDecorator implements Shape {
        protected Shape decoratedShape;
    
        public ShapeDecorator(Shape decoratedShape) {
            this.decoratedShape = decoratedShape;
        }
    
        @Override
        public void draw() {
            decoratedShape.draw();
        }
    }
    
    // 创建扩展自 ShapeDecorator 类的实体装饰类。
    class RedShapeDecorator extends ShapeDecorator {
    
        public RedShapeDecorator(Shape decoratedShape) {
            super(decoratedShape);
        }
    
        @Override
        public void draw() {
            decoratedShape.draw();
            setRedBorder(decoratedShape);
        }
    
        private void setRedBorder(Shape decoratedShape) {
            System.out.println("Border Color: Red");
        }
    }
    
    //使用 RedShapeDecorator 来装饰 Shape 对象。
    public class DecoratorPattern {
        public static void main(String[] args) {
            Shape circle = new Circle();
            Shape redCircle = new RedShapeDecorator(new Circle());
            Shape redRectangle = new RedShapeDecorator(new Rectangle());
            System.out.println("Circle with normal border");
            circle.draw();
    
            System.out.println("\nCircle of red border");
            redCircle.draw();
    
            System.out.println("\nRectangle of red border");
            redRectangle.draw();
        }
    }

6、迭代器模式  
迭代器模式提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。