常用设计原则和设计模式

最新推荐文章于 2025-05-08 22:14:39 发布

原创最新推荐文章于 2025-05-08 22:14:39 发布 · 254 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

JavaSE

本文介绍了软件开发常用设计原则和设计模式。设计原则包括开闭、里氏代换等原则，可提升程序扩展性与可维护性。设计模式有创建型、结构型、行为型，详细讲解了单例、工厂、装饰器等模式，分析其概念、结构、代码实现及优缺点。

文章目录

常用设计原则和设计模式

常用设计原则和设计模式

常用的设计原则（记住）

软件开发的流程

需求分析文档、概要设计文档、详细设计文档、编码和测试、安装和调试、维护和升级

常用的设计原则

开闭原则（Open Close Principle）
对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级，一般使用继承方式实现该原则
里氏代换原则（Liskov Substitution Principle）
任何基类可以出现的地方，子类一定可以出现，即建议多使用多态的方式
依赖倒转原则（Dependence Inversion Principle）
尽量多依赖于抽象类和接口而不是具体实现类，因为抽象类对子类具有强制性和规范性
接口隔离原则（Interface Segregation Principle）
在依赖倒转原则建议多使用抽象类和接口下，尽量多使用小接口而不是大接口，避免接口的污染（比如有个大接口Animal，里面有抽象的run()和fly()方法，这时候若Dog类实现Animal接口也必须实现fly()方法，但是明显狗不能飞，因此此时就出笑话了），降低类之间的耦合度（即类之间的关联性）
迪米特法则（最少知道原则）（Demeter Principle）
一个实体（模块）应当尽量少与其他实体（模块）之间发生相互作用，使系统功能模块相对独立
高内聚，低耦合：该实体应该实现的功能应该高度聚集于该实体内部，尽量让实体之间相互关联
合成复用原则（Composite Reuse Principle）
尽量多使用合成/聚合的方式，而不是继承的方式——所谓合成/聚合的方式即：想在B类中调用A类中的成员，这时候可以让B类继承A类，但是由于Java是单继承的，所以一旦继承后B类就无法再继承其他类了，因此不推荐；所以应该在B类中声明A类的引用作为成员，并在构造函数中作为参数，这样就能使用A类的引用去调用A类中的成员了

常用的设计模式

基本概念

设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结
设计模式就是一种用于固定场合的固定套路

基本分类

创建型模式（针对对象的创建） - 单例设计模式、工厂设计模式、抽象设计模式、…
结构型模式（针对代码结构的扩展、改变）- 装饰器模式、代理模式、…
行为型模式（针对动作的设计） - 模板设计模式、…

设计模式详解（重点）

单例设计模式

单例设计模式主要分为：饿汉式和懒汉式，懒汉式需要对多线程进行同步处理
- 饿汉式：声明本类类型的引用时就创建对象，让引用指向对象
- 懒汉式：声明本类类的的引用时先让它指向null，在之后的get()方法中判断引用为null时才创建对象让引用指向该对象
实现步骤
1. 私有化构造方法，使用private关键字修饰
2. 声明本类类型的引用指向本类类型的对象，并使用private static关键字共同修饰（如果是饿汉式这里直接指向new 本类类型的对象；如果是懒汉式，这里先将本类类型的引用赋值为null；推荐使用饿汉式）
3. 提供公有的get()方法负责将对象返回出去，并使用public static关键字共同修饰

懒汉式对多线程进行同步处理代码如下

package com.lagou.task21;

public class Singleton {
    //2、声明本类类型的引用指向本类类型的对象并使用private static关键字修饰（饿汉式直接将new对象赋值给引用，懒汉式将null赋值给引用）
    private static Singleton singleton = null;  //懒汉式
    //1、私有化构造方法，使用private关键字修饰
    private Singleton() { }
    //3、提供公有的get方法负责将上述对象返回出去，使用public static修饰
    public static Singleton getInstance() {
        if (null == singleton) {
            synchronized (Singleton.class) {    //使用锁，防止多线程的时候抢夺创建多个对象
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

普通工厂模式

基本概念

普通工厂方法模式就是创建一个工厂类，对实现了同一个接口的不同实现类进行实例的创建

类图结构

普通工厂模式

代码实现举例

Sender接口：

package com.lagou.task21;

public interface Sender {
    //自定义抽象方法来描述发送的行为
   void send();
}

MailSender实现类：

package com.lagou.task21;

public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送邮件...");
    }
}

SmsSender实现类：

package com.lagou.task21;

public class SmsSender implements Sender {
    @Override
    public void send() {
        System.out.println("正在发送短信...");
    }
}

SendFactory工厂类：（用来创建实现类对象）

package com.lagou.task21;

/**
 * 工厂类：用来创建对象
 */
public class SendFactory {
    //自定义成员方法实现对象的创建
    public Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        }
        if ("sms".equals(type)) {
            return new SmsSender();
        }
        return null;
    }
}

之后使用SendFactory对象调用produce()方法就可以不断创建Sender接口不同的实现类对象（就像工厂生产产品一样）

普通工厂模式的优势

使用普通工厂模式来创建对象其实和多态创建对象是一样的效果，但是可以发现普通工厂模式创建新对象相比较多态创建对象而言，代码复杂，可读性略差。那么普通工厂模式创建对象的优势是什么呢？
普通工厂模式创建对象的优势主要在于：**扩展性和可维护性更强！**尤其是在创建大量对象的前提下，如果需要做出扩展性内容，直接在produce()方法中进行扩展即可。

主要缺点

在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常
解决方法：使用多个工厂方法模式

多个工厂方法模式

基本概念

即在普通工厂模式的基础上使用多个produceXXX()方法创建不同类对象

类图结构

多个工厂模式

代码实现举例

在普通工厂模式代码基础上，SendFactory中实现多个produceXxx()方法用于创建不同类对象

package com.lagou.task21;

/**
 * 工厂类：用来创建对象
 */
public class SendFactory {
    //自定义成员方法实现对象的创建  
    public Sender produceMail() {	//需要创建MailSender对象就调用该方法
        return new MailSender();
    }
    public Sender produceSms() {	//需要创建SmsSender对象就调用该方法
        return new SmsSender();
    }
}

主要缺点

在多个工厂方法模式中，为了能够正确创建对象，需要先创建工厂类的对象才能调用工厂类中的生产方法
解决方法：使用静态工厂方法模式

静态工厂方法模式

基本概念

其实就是在普通或者多个工厂方法模式的基础上，将produce()生产方法使用static修饰，使之能用 类名.去调用

类图结构

静态工厂模式

注：SendFactory类中的两个produceXxx()方法加下划线代表这两个方法是静态的

实际意义（工厂方法模式的作用）

工厂方法模式适用于：凡是出现了大量的对象需要创建且这些对象对应的类具有共同接口时，可以通过工厂方法模式实现创建

主要缺点

工厂方法模式有一个问题就是：类的创建依赖工厂类。也就是说，如果想要扩展程序生产新的产品，就必须对工厂类的代码进行修改，这就违背了开闭原则（对扩展开放，对修改关闭）
解决方法：使用抽象工厂模式

抽象工厂模式

基本概念

其实就是对于不同类的对象创建实现不同的工厂类，并且让这些工厂类都是实现同一个接口

类图结构

抽象工厂模式

代码实现举例

工厂类的接口——Provider接口

package com.lagou.task21;

public interface Provider {
    //自定义抽象方法描述产品的生产行为
    Sender produce();
}

具体创建某个对象的某个工厂类（这里以两个工厂类举例）

package com.lagou.task21;

public class MailSendFactory implements Provider {	//制造MailSender对象的工厂
    @Override
    public Sender produce() {
        return new MailSender();
    }
}

package com.lagou.task21;

public class SmsSendFactory implements Provider {	//制造SmsSender对象的工厂
    @Override
    public Sender produce() {
        return new SmsSender();
    }
}

主要优势

使用抽象工厂模式扩展性更强！需要的时候直接写一个新的工厂类进行扩展即可！

装饰器模式

基本概念

装饰器模式就是给一个对象动态地增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例（其实就是合成复用原则）

类图结构

装饰器模式

代码实现举例

Sourceable接口：

package com.lagou.task21;

public interface Sourceable {
    //自定义抽象方法
    void method();
}

Source类：

package com.lagou.task21;

public class Source implements Sourceable {
    @Override
    public void method() {
        System.out.println("没想到素颜美可以如此之美...");
    }
}

Decorator类：（使用合成复用原则对Source功能进行扩展，实现对Source类的“装饰”效果）

package com.lagou.task21;

public class Decorator implements Sourceable {
    //合成复用原则
    private Sourceable sourceable;
    public Decorator(Sourceable sourceable) {
        this.sourceable = sourceable;
    }
    @Override
    public void method() {
        sourceable.method();    //保证原有功能不变
        //接下来的部分是装饰部分（即扩展部分）
        System.out.println("化妆之后你会更美！");
    }
}

实际意义

可以实现一个类功能的扩展
可以动态地增加功能，而且还能动态撤销（继承不行）
缺点：产生过多相似的对象，不易排错

代理模式

基本概念

代理模式就是找一个代理类替原对象进行一些操作（直接进行全权代理操作，而不是仅仅只是想装饰器模式那样只是扩展功能）
比如我们在租房租的时候找中介，再如我们打官司需要请律师，中介和律师在这里就是我们的代理

类图结构

代理模式

与装饰器模式区别：由于是全权代理的模式，因此直接在Proxy()的构造方法中new一个Source对象，而不是作为参数传入，这样就相当于一个全新的对象在Proxy中被代理了

代码实现举例

Sourceable接口和Source实现类同装饰器模式

代理类Proxy实现代码如下：

package com.lagou.task21;

public class Proxy implements Sourceable {
    private Sourceable sourceable;
    public Proxy() {
        sourceable = new Source();  //与装饰器模式不同，这里直接new一个Source对象给sourceable引用
    }
    @Override
    public void method() {
        sourceable.method();
        System.out.println("代理模式与装饰器模式是不一样的");
    }
}

实际意义

如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的结果进行控制，这种方式就是代理模式
使用代理模式，可以将功能划分的更加清晰，有助于后期维护

代理模式和装饰器模式的比较

装饰器模式通常的做法是将原始对象作为一个参数传递给装饰着的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象
装饰器模式关注于在一个对象上动态地添加方法，然而代理模式关注于控制对对象的访问

模板方法模式

基本概念

模板方法模式主要指一个抽象类中封装了一个固定流程，流程中的具体步骤可以由不同子类进行不同的实现，通过抽象类让固定的流程产生不同的结果（其实就是类似多态的实现）

类图结构

如下举例使用模板方法模式实现加减计算器

模板方法模式

注：AbstractCalculator斜体表示这个是一个抽象类

代码实现举例

抽象类AbstractCalculator（模板）：

package com.lagou.task21;

public abstract class AbstractCalculator {
    //自定义成员方法实现将参数指定得表达式按照参数指定的符号规则进行切割并返回计算结果
    public int splitExpression(String exp, String op) {
        String[] nums = exp.split(op); //先根据符号切割
        return calculate(Integer.parseInt(nums[0]), Integer.parseInt(nums[1]));
    }
    //自定义抽象方法实现运算
    public abstract int calculate(int a, int b);    //抽象的计算方法
}

具体实现类Plus和Minus：

package com.lagou.task21;

public class Plus extends AbstractCalculator {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

package com.lagou.task21;

public class Minus extends AbstractCalculator {
    @Override
    public int calculate(int a, int b) {
        return a - b;
    }
}