设计模式之7大设计原则-Java版

最新推荐文章于 2024-05-20 23:45:16 发布

nuist__NJUPT

最新推荐文章于 2024-05-20 23:45:16 发布

阅读量1.1k

点赞数 24

分类专栏：设计模式文章标签：设计模式 java 开发语言设计原则

本文链接：https://blog.csdn.net/nuist_NJUPT/article/details/135660264

版权

设计模式专栏收录该内容

6 篇文章 0 订阅

订阅专栏

软件设计模式是前辈们代码设计经验的总结，可以反复使用。设计模式共分为3大类，创建者模式(5种)、结构型模式(7种)、行为型模式(11种)，一共23种设计模式，软件设计一般需要满足7大基本原则。下面通过5章的学习一起来看看设计模式的魅力吧。

1.1、设计模式概述

软件设计模式是前辈们代码设计经验的总结，本质上是对面向对象设计原则的实际应用，是对类的封装、继承、多态以及类的关联关系与组合关系的充分理解。

使用设计模式的代码可重用性与可维护性高、可读性强、可以减少软件开发周期，提升开发效率。

1.2、设计模式的分类

创建型模式(5种)：本质上就是将对象的创建与使用分离，就是描述怎样去创建对象。

包括：单例、原型、工厂方法、抽象工厂、建造者模式

结构型模式(7种)：本质上是将类或者对象按照某种布局组成更大的结构。

包括：代理、适配器、桥接、装饰、外观、享元、组合模式

行为模式(11种)：本质是描述类与对象协助完成单个对象无法完成的任务，以及怎么分配职责。

包括：模板方法、策略、命令、责任链、状态、观察者、中介者模式、迭代器、访问者、备忘录、解释器。

1.3、UML类图

类图是面向对象建模的主要组成部门，类图显示了模型的内部结构，主要包括：模型中存在的类、类的属性以及类与类之间的关系等。

1.4、设计原则

设计模式的7大原则，具体如下：

1.开闭原则：软件实体 (类、模块、函数等等) 应该是可以被扩展的，但是不可被修改。

2.里式代换原则：继承的时候尽量不要重写父类的方法，如果重写要保证不破坏原方法的功能。

3.依赖倒转原则：抽象不应该依赖于细节，细节应该依赖于抽象，依赖接口，面向接口编程。

4.接口隔离原则：客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上。

5.迪米特法则：最少知道原则，它表示一个对象应该对其它对象保持最少的了解。通俗来说就是，只与直接的朋友通信。

6.合成复用原则：通过组合或者聚合的方式替代继承，增强封装性与提升复用的灵活性。

7.单一职责：表示一个模块的组成元素之间的功能相关性，即一个类只负责一项职责。

1.4.1 开闭原则

1.开闭原则：对扩展开放，对修改关闭。扩展源程序的时候，不要修改原有代码，通过使用接口与抽象类实现。

通过定义一个抽象类，抽象类中定义抽象方法，通过多个子类继承抽象类并重写重写抽象方法，同时设置一个中间类用于注入抽象类并调用抽象方法，这样在客户端测试类中就可以实例化中间类，并注入抽象类的子类，即实现了扩展类方法，也没更改代码本身。

1.定义一个抽象类，如下：

/**
 * @ClassName AbstractSkin
 * @description: 抽象皮肤类
 * @author nuist__NJUPT
 * @date 2024年01月18日
 * @version: 1.0
 */
public abstract class AbstractSkin {
    // 显示方法
    public abstract void display() ;


}

2.定义两个子类，继承抽象类并实现抽象方法display


/**
 * @ClassName DefaultSkin
 * @description: 默认皮肤
 * @author nuist__NJUPT
 * @date 2024年01月18日
 * @version: 1.0
 */
public class DefaultSkin extends AbstractSkin{

    @Override
    public void display() {
        System.out.println("默认皮肤");
    }

}



/**
 * @author nuist__NJUPT
 * @ClassName NewSkin
 * @description: 新皮肤
 * @date 2024年01月18日
 * @version: 1.0
 */
public class NewSkin extends AbstractSkin {

    @Override
    public void display() {
        System.out.println("新皮肤");
    }
}

3.定义一个中间类，在中间类中注入抽象类，并调用抽象方法。

/**
 * @author nuist__NJUPT
 * @ClassName SogouInput
 * @description: 搜狗输入法
 * @date 2024年01月18日
 * @version: 1.0
 */
public class SogouInput {

    private AbstractSkin abstractSkin ;

    public void setAbstractSkin(AbstractSkin abstractSkin) {
        this.abstractSkin = abstractSkin;
    }

    public void display(){
        abstractSkin.display();
    }
}

4.定义一个客户端测试类，在测试类中实例化中间类，并注入实例化子类，即可调用子类方法

/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description: TODO
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Client {
    public static void main(String[] args) {
        //1.创建搜狗输入法对象
        SogouInput sogouInput = new SogouInput() ;
        //2.创建皮肤对象并将皮肤设置到输入法
        sogouInput.setAbstractSkin(new DefaultSkin());
        // sogouInput.setAbstractSkin(new NewSkin());
        //4.显示皮肤
        sogouInput.display();
    }

}

1.4.2、里式代换原则

里式代换原则：子类可以扩展父类的功能，但是不允许更改父类的内容。

子类继承父类得时候，可以新增方法，但是尽量不要重写父类当中得方法

这里通过定义接口，在接口中定义方法，通过实现类的方式实现接口中方法的功能。

1.定义四边形接口，并定义获取长于宽的方法。


/**
 * @author nuist__NJUPT
 * @InterfaceName Quadrilateral
 * @description: 四边形接口
 * @date 2024年01月18日
 * @version: 1.0
 */
public interface Quadrilateral {

    double getLength() ;

    double getWidth() ;

}

2.定义四边形接口的两个实现类，正方法与长方形。



/**
 * @author nuist__NJUPT
 * @ClassName Rectangle
 * @description: 长方形实现类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Rectangle implements Quadrilateral {

    private double length ;
    private  double width ;

    public void setLength(double length) {
        this.length = length;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    @Override
    public double getLength() {
        return length;
    }

    @Override
    public double getWidth() {
        return width;
    }
}



/**
 * @author nuist__NJUPT
 * @ClassName Square
 * @description: 正方形实现类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Square implements Quadrilateral {

    private double side ;

    public double getSide() {
        return side;
    }

    public void setSide(double side) {
        this.side = side;
    }

    @Override
    public double getLength() {
        return side;
    }

    @Override
    public double getWidth() {
        return side;
    }
}

3.定义测试类，测试通过实现类进行扩充长宽并打印。

import com.company.p1.demo2.Rectangle;

/**
 * @author nuist__NJUPT
 * @ClassName RectangleDemo
 * @description: 测试类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class RectangleDemo {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle() ;
        rectangle.setLength(20);
        rectangle.setWidth(10);
        resize(rectangle);
        print(rectangle);
    }
    /**
     * 扩宽方法
     * @param rectangle
     */
    public static void resize(com.company.p1.demo2.Rectangle rectangle){
        // 宽比长小则扩充
        while(rectangle.getLength() >= rectangle.getWidth()){
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }

    /**
     * 打印长与宽
     * @param rectangle
     */
    public static void print(Rectangle rectangle){
        System.out.println("长方形的长为：" + rectangle.getLength());
        System.out.println("长方形的宽为：" + rectangle.getWidth());
    }

}

1.4.3、依赖倒转原则

依赖倒转原则：模块应该依赖于抽象，就是面向抽象编程，而不是对实现进行编程，这样可以降低客户与实现之间的耦合。具体说就是依赖接口，而不是依赖具体的实现类。

首先定义三个接口，硬盘，内存，cpu的如下：


/**
 * @author nuist__NJUPT
 * @InterfaceName HardDisk
 * @description: 硬盘接口
 * @date 2024年01月18日
 * @version: 1.0
 */
public interface HardDisk {

    // 存储数据
    public void save(String data) ;

    // 获取数据
    public String get() ;
}

/**
 * @author nuist__NJUPT
 * @InterfaceName Cpu
 * @description: CPU接口
 * @date 2024年01月18日
 * @version: 1.0
 */
public interface Cpu {

    public void run() ;

}


/**
 * @author nuist__NJUPT
 * @InterfaceName Memory
 * @description: 内存条接口
 * @date 2024年01月18日
 * @version: 1.0
 */
public interface Memory {
    //存储数据的接口
    public void save() ;

}

然后分别定义三个接口的实现类，如下：


/**
 * @author nuist__NJUPT
 * @ClassName XiJieHardDisk
 * @description: 硬盘实现类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class XiJieHardDisk implements HardDisk {

    @Override
    public void save(String data) {
        System.out.println("使用希捷硬盘存储数据");
    }

    @Override
    public String get() {
        return "从硬盘中获取的数据" ;
    }
}

/**
 * @author nuist__NJUPT
 * @ClassName IntelCpu
 * @description: Intel的CPU
 * @date 2024年01月18日
 * @version: 1.0
 */
public class IntelCpu implements Cpu {

    @Override
    public void run() {
        System.out.println("运行Intel的cpu");
    }
}

/**
 * @author nuist__NJUPT
 * @ClassName KingstonMemory
 * @description: TODO
 * @date 2024年01月18日
 * @version: 1.0
 */
public class KingstonMemory implements Memory {

    @Override
    public void save() {
        System.out.println("使用金士顿内存条");
    }
}

然后定义一个中间类，用于依赖这些接口，而不是这些实现类。

/**
 * @author nuist__NJUPT
 * @ClassName Computer
 * @description: 计算机类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Computer {
    /**
     * 依赖的是抽象接口，而不是具体的实现类，这样后面增加新的实现类不需要改动Computer
     * 只需要增加实现类，并且在测试类中进行实例化就可以了
     */
    private HardDisk hardDisk ;
    private Cpu cpu ;
    private Memory memory ;

    public HardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public Cpu getCpu() {
        return cpu;
    }

    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }

    public Memory getMemory() {
        return memory;
    }

    public void setMemory(Memory memory) {
        this.memory = memory;
    }

    /**
     * 运行计算机的方法
     */
    public void run(){
        System.out.println("运行计算机");
        System.out.println("从硬盘上获取的数据：" + hardDisk.get());
        cpu.run();
        memory.save();
    }
}

最后定义测试类，在测试类中实例化中间类与实现类，并调用实现类的方法，在测试类中依赖具体，而不是在中间类，中间类依赖的是抽象的接口。这样在就可以避免中间层的代码修改，只需要增加实现类然后在测试类，也就是客户端修改代码即可。

/**
 * @author nuist__NJUPT
 * @ClassName ComputerDemo
 * @description: 测试类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class ComputerDemo {
    public static void main(String[] args) {


        HardDisk hardDisk = new XiJieHardDisk() ;
        Cpu cpu = new IntelCpu() ;
        Memory memory = new KingstonMemory() ;

        Computer computer = new Computer() ;
        computer.setCpu(cpu);
        computer.setMemory(memory);
        computer.setHardDisk(hardDisk);

        computer.run();


    }

}

1.4.4、接口隔离原则

接口隔离原则：一个类对另外一个类的依赖应该建立在最小的接口上，也就是定义接口的功能最小化，然后通过实现类的方式重写接口中的抽象方法即可，这样可以避免客户端依赖的方法是它并不使用的。

1.定义三个相互隔离的最小化接口，而不是定义一个接口包含三个方法，避免实现类依赖不使用的方法。


/**
 * @author nuist__NJUPT
 * @InterfaceName AntiTheft
 * @description: 防盗接口
 * @date 2024年01月18日
 * @version: 1.0
 */
public interface AntiTheft {

    void antiTheft() ;

}

/**
 * @author nuist__NJUPT
 * @InterfaceName Fireproof
 * @description: 防火接口
 * @date 2024年01月18日
 * @version: 1.0
 */
public interface Fireproof {

    void fireproof() ;
}

/**
 * @author nuist__NJUPT
 * @InterfaceName Waterproof
 * @description: 防水接口
 * @date 2024年01月18日
 * @version: 1.0
 */
public interface Waterproof {
    void waterproof() ;
}

2.定义多个实现类，分别实现接口并重写接口中的抽象方法，需要用到接口方法的，才去实现接口。

/**
 * @author nuist__NJUPT
 * @ClassName SafeDoor
 * @description: TODO
 * @date 2024年01月18日
 * @version: 1.0
 */
public class SafeDoor implements AntiTheft, Fireproof, Waterproof {

    @Override
    public void antiTheft() {
        System.out.println("防盗");
    }

    @Override
    public void fireproof() {
        System.out.println("防火");
    }

    @Override
    public void waterproof() {
        System.out.println("防水");
    }
}

/**
 * @author nuist__NJUPT
 * @ClassName SafeDoor2
 * @description: TODO
 * @date 2024年01月18日
 * @version: 1.0
 */
public class SafeDoor2 implements AntiTheft, Fireproof{

    @Override
    public void antiTheft() {
        System.out.println("防盗");
    }

    @Override
    public void fireproof() {
        System.out.println("防火");
    }
}

3.在测试类中实例化实现类，并调用相应的实现方法。


/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description:测试类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Client {
    public static void main(String[] args) {
        // 实例化对象
        SafeDoor safeDoor = new SafeDoor() ;
        safeDoor.antiTheft();
        safeDoor.fireproof();
        safeDoor.waterproof();

        System.out.println("-----------------------------");

        SafeDoor2 safeDoor2 = new SafeDoor2() ;
        safeDoor2.antiTheft();
        safeDoor2.fireproof();
    }
}

1.4.5、迪米特法则

迪米特法则：最少只知识原则，也就是说如果两个实体无需直接通信，就尽量不要产生直接交互，这样可以降低模块的耦合度，提高模块的独立性。

1、首先定义三个类，分别为公司类、明星类、粉丝类

/**
 * @author nuist__NJUPT
 * @ClassName Company
 * @description: 公司类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Company {
    private String name ;
    public Company(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

/**
 * @author nuist__NJUPT
 * @ClassName Star
 * @description: 明星类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Star {

    private String name ;

    public Star(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

/**
 * @author nuist__NJUPT
 * @ClassName Fans
 * @description: 粉丝类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Fans {
    private String name ;
    public Fans(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

}

2、定义一个经纪人的类，通过该类实现明星与粉丝，以及明星与公司的交互，避免它们直接交互，降低模块的耦合性，提高模块的独立性。

/**
 * @author nuist__NJUPT
 * @ClassName Agent
 * @description: 经纪人类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Agent {
    private Star star ;
    private Company company ;
    private Fans fans ;

    public Star getStar() {
        return star;
    }

    public void setStar(Star star) {
        this.star = star;
    }

    public Company getCompany() {
        return company;
    }

    public void setCompany(Company company) {
        this.company = company;
    }

    public Fans getFans() {
        return fans;
    }

    public void setFans(Fans fans) {
        this.fans = fans;
    }

    /**
     * 粉丝见面方法
     */
     public void meeting(){
         System.out.println("明星：" + star.getName() + "与粉丝：" + fans.getName()+"见面");
     }
    /**
     * 与公司洽谈
     */
    public void business(){
        System.out.println("明星：" + star.getName() + "与公司：" + company.getName()+"洽谈");
    }

}

3.最后在测试类实例化经纪人类，并调用相应的方法。

/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description: 测试类
 * @date 2024年01月18日
 * @version: 1.0
 */
public class Client {
    public static void main(String[] args) {
        Agent agent = new Agent() ;
        agent.setStar(new Star("刘德华"));
        agent.setCompany(new Company("大碗娱乐公司"));
        agent.setFans(new Fans("张三"));

        agent.meeting();
        agent.business();
    }
}

1.4.6、合成复用原则

合成复用原则：尽量使用组合或者聚合等关联关系来实习复用，而不是通过继承的方式实现复用

因为继承首先破环了类的封装性，父类暴露给子类了，同时子类与父类的耦合度高，另外继承限制了复用的灵活性。

1.4.7、单一职责原则

单一职责原则，通俗的来说就是尽量让一个类中只负责一件事，当然这个还是要结合实际情况来看。有些场景可以一个类中做多件事，然后子类继承并重写方法。

我们假设有两种动物，分别呼吸空气与水，那么可以定义两个类，每个类中定义一个方法。这样满足单一职责原则。

/**
 * @author nuist__NJUPT
 * @ClassName Client
 * @description: 单一职责测试类
 * @date 2024年01月19日
 * @version: 1.0
 */
class Terrestrial{
    public void breathe(String animal){
        System.out.println(animal + "呼吸空气");
    }
}
class Aquatic{
    public void breathe(String animal){
        System.out.println(animal + "呼吸水");
    }
}

public class Client{
    public static void main(String[] args){
        Terrestrial terrestrial = new Terrestrial();
        terrestrial.breathe("牛");
        terrestrial.breathe("羊");
        terrestrial.breathe("猪");

        Aquatic aquatic = new Aquatic();
        aquatic.breathe("鱼");
    }
}

nuist__NJUPT

关注

24
点赞
踩
22

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式之7大设计原则-Java版

软件设计模式是前辈们代码设计经验的总结，本质上是对面向对象设计原则的实际应用，是对类的封装、继承、多态以及类的关联关系与组合关系的充分理解。使用设计模式的代码可重用性与可维护性高、可读性强、可以减少软件开发周期，提升开发效率。
复制链接

扫一扫