【不就是java设计模式吗】设计模式七大原则,用代码对比方式,化抽象为具体,实打实的教会你

简介: 【不就是java设计模式吗】设计模式七大原则,用代码对比方式,化抽象为具体,实打实的教会你

一、为什么要学习设计模式?

在编写软件的过程中,设计模式是为了让软件具有更好的以下优点:


代码重用性(相同功能的代码不用多次编写)

可读性(编程规范性,便于其他程序员的阅读和理解)

可扩展性(当需要增加新的功能时,非常的方便)

可靠性(当增加新的功能后,对原来的功能没有影响)

使程序呈现高内聚、低耦合的特性

二、常用的七大原则

单一职责原则

接口隔离原则

依赖倒转原则

里氏替换原则

开闭原则

迪米特法则

合成复用原则

三、单一职责原则

1、基本介绍

对类来说,一个类应该只负责一项职责。如果类A负责两个不同的职责:职责1、职责2。当职责1需求变更而改变A时,可能造成职责2执行错误,所以需要将类A分解为A1、A2。


这么说有点抽象,下面用代码来演示一下,化抽象为具体。


2、代码对比

代码一:


public class class01 {
    public static void main(String[] args) {
        Vehicle1 vehicle = new Vehicle1();
        vehicle.run("汽车");
        vehicle.run("飞机");
        vehicle.run("轮船");
    }
}
class Vehicle1 {
    public void run(String vehicle){
        System.out.println(vehicle + "在高速上行驶");
    }
}


通过代码一可以看出,这样设计的结果是:飞机和轮船也是在高速上行驶,违反了单一职责原则,这显然是错误的。接下来看看代码二,与其对比一下。


代码二:


public class class02 {
    public static void main(String[] args) {
        VehicleRoad road = new VehicleRoad();
        road.run("汽车");
        VehicleWater water = new VehicleWater();
        water.run("轮船");
    }
}
class VehicleRoad {
    public void run(String vehicle) {
        System.out.println(vehicle + "在高速上行驶");
    }
}
class VehicleWater {
    public void run(String vehicle) {
        System.out.println(vehicle + "在水中行驶");
    }
}



通过代码二,我们根据交通工具运行方法不同,分解成不同的类,解决了代码一的问题。但是有一个问题就是,这样很浪费资源,改动很大。貌似不太完美,接下来看看代码三


代码三:


public class class03 {
    public static void main(String[] args) {
        Vehicle2 vehicle = new Vehicle2();
        vehicle.runRoad("汽车");
        vehicle.runWater("轮船");
    }
}
class Vehicle2{
    public void runRoad(String vehicle){
        System.out.println(vehicle + "在高速上行驶");
    }
    public void runWater(String vehicle){
        System.out.println(vehicle + "在水中行驶");
    }
}


代码三通过修改方法,与代码二比较,对原来的类没有做很大的修改,只是增加方法。这里虽然没有在类这个级别上遵守单一职责原则,但是在方法级别上,仍然是遵守单一职责原则。


3、注意事项和使用细节

要降低类的复杂度,一个类只负责一项职责

确保提高类的可读性,可维护性

降低变更引起的风险

通常情况下,我们应当遵守单一职责原则,只有逻辑 足够简单,才可以在代码级别违反单一职责原则;只有类中方法数量足够少,可以在方法级别保持单一职责原则

四、接口隔离原则

1、基本介绍

客户端不应该依赖它不需要的接口,一个类对另一个类的依赖应该建立在最小的接口上。


先看看一张图:

image.png

代码一:


public class class01 {
    public static void main(String[] args) {
        A a = new A();
        a.method1(new B());
        C c = new C();
        c.method2(new D());
    }
}
interface Interface1{
    void opertion1();
    void opertion2();
    void opertion3();
    void opertion4();
    void opertion5();
}
class B implements Interface1{
    public void opertion1() {
        System.out.println("B 实现了 operation1");
    }
    public void opertion2() {
        System.out.println("B 实现了 operation2");
    }
    public void opertion3() {
        System.out.println("B 实现了 operation3");
    }
    public void opertion4() {
        System.out.println("B 实现了 operation4");
    }
    public void opertion5() {
        System.out.println("B 实现了 operation5");
    }
}
class D implements Interface1{
    public void opertion1() {
        System.out.println("D 实现了 operation1");
    }
    public void opertion2() {
        System.out.println("D 实现了 operation2");
    }
    public void opertion3() {
        System.out.println("D 实现了 operation3");
    }
    public void opertion4() {
        System.out.println("D 实现了 operation4");
    }
    public void opertion5() {
        System.out.println("D 实现了 operation5");
    }
}
class A { // A 类 通过接口Interface1 依赖 B类,但只使用1、2、3方法
    public void method1(Interface1 interface1){
        interface1.opertion1();
    }
    public void method2(Interface1 interface1){
        interface1.opertion2();
    }
    public void method3(Interface1 interface1){
        interface1.opertion3();
    }
}
class C { // C 类 通过接口Interface1 依赖 D类,但只使用1、4、5方法
    public void method1(Interface1 interface1){
        interface1.opertion1();
    }
    public void method2(Interface1 interface1){
        interface1.opertion4();
    }
    public void method3(Interface1 interface1){
        interface1.opertion5();
    }
}



代码一中,类A通过接口Interface1 依赖类B,类C通过接口Interface1 依赖类D,因为接口Interface1 对于类A 和类C来说不是最小接口,所以要想实现图片的功能,需要实现接口的所有方法,违反了接口隔离原则! 接下来看看代码二,与其对比一下。


代码二:


public class class02 {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.method1(new BB());
        CC cc = new CC();
        cc.method1(new DD());
    }
}
interface Interface2{
    void opertion1();
}
interface Interface3{
    void opertion2();
    void opertion3();
}
interface Interface4{
    void opertion4();
    void opertion5();
}
class BB implements Interface2,Interface3{
    public void opertion1() {
        System.out.println("BB 实现了operation1");
    }
    public void opertion2() {
        System.out.println("BB 实现了operation2");
    }
    public void opertion3() {
        System.out.println("BB 实现了operation3");
    }
}
class DD implements Interface2,Interface4{
    public void opertion1() {
        System.out.println("DD 实现了operation1");
    }
    public void opertion4() {
        System.out.println("DD 实现了operation4");
    }
    public void opertion5() {
        System.out.println("DD 实现了operation5");
    }
}
class AA {
    public void method1(Interface2 interface2){
        interface2.opertion1();
    }
    public void method2(Interface3 interface3){
        interface3.opertion2();
    }
    public void method3(Interface3 interface3){
        interface3.opertion3();
    }
}
class CC {
    public void method1(Interface2 interface2){
        interface2.opertion1();
    }
    public void method2(Interface4 interface4){
        interface4.opertion4();
    }
    public void method3(Interface4 interface4){
        interface4.opertion5();
    }
}


代码二的UML类图:

image.png


代码二采用了接口隔离原则。根据实际情况,把代码一中的接口Interface1拆分成三个接口,即最小接口。这样就完美的去除了类BB和类DD不用实现他们不需要的方法


目录
打赏
0
0
0
0
7
分享
相关文章
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
本文聚焦 MySQL 集群架构中的负载均衡算法,阐述其重要性。详细介绍轮询、加权轮询、最少连接、加权最少连接、随机、源地址哈希等常用算法,分析各自优缺点及适用场景。并提供 Java 语言代码实现示例,助力直观理解。文章结构清晰,语言通俗易懂,对理解和应用负载均衡算法具有实用价值和参考价值。
大数据大厂之MySQL数据库课程设计:揭秘MySQL集群架构负载均衡核心算法:从理论到Java代码实战,让你的数据库性能飙升!
【高薪程序员必看】万字长文拆解Java并发编程!(8):设计模式-享元模式设计指南
🌟 ​大家好,我是摘星!​ 🌟今天为大家带来的是并发编程中的经典对象复用设计模式-享元模式,废话不多说让我们直接开始。
62 0
java实现队列数据结构代码详解
本文详细解析了Java中队列数据结构的实现,包括队列的基本概念、应用场景及代码实现。队列是一种遵循“先进先出”原则的线性结构,支持在队尾插入和队头删除操作。文章介绍了顺序队列与链式队列,并重点分析了循环队列的实现方式以解决溢出问题。通过具体代码示例(如`enqueue`入队和`dequeue`出队),展示了队列的操作逻辑,帮助读者深入理解其工作机制。
104 1
Java 面试资料中相关代码使用方法与组件封装方法解析
这是一份详尽的Java面试资料代码指南,涵盖使用方法与组件封装技巧。内容包括环境准备(JDK 8+、Maven/Gradle)、核心类示例(问题管理、学习进度跟踪)、Web应用部署(Spring Boot、前端框架)、单元测试及API封装。通过问题库管理、数据访问组件、学习进度服务和REST接口等模块化设计,帮助开发者高效组织与复用功能,同时支持扩展如用户认证、AI推荐等功能。适用于Java核心技术学习与面试备考,提升编程与设计能力。资源链接:[点此下载](https://pan.quark.cn/s/14fcf913bae6)。
58 6
Java 面试资料中相关代码使用方法与组件封装方法解析
接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
287 96
接替此文【下篇-服务端+后台管理】优雅草蜻蜓z系统JAVA版暗影版为例-【蜻蜓z系列通用】-2025年全新项目整合搭建方式-这是独立吃透代码以后首次改变-独立PC版本vue版搭建教程-优雅草卓伊凡
基于Java 17 + Spring Boot 3.2 + Flink 1.18的智慧实验室管理系统核心代码
这是一套基于Java 17、Spring Boot 3.2和Flink 1.18开发的智慧实验室管理系统核心代码。系统涵盖多协议设备接入(支持OPC UA、MQTT等12种工业协议)、实时异常检测(Flink流处理引擎实现设备状态监控)、强化学习调度(Q-Learning算法优化资源分配)、三维可视化(JavaFX与WebGL渲染实验室空间)、微服务架构(Spring Cloud构建分布式体系)及数据湖建设(Spark构建实验室数据仓库)。实际应用中,该系统显著提升了设备调度效率(响应时间从46分钟降至9秒)、设备利用率(从41%提升至89%),并大幅减少实验准备时间和维护成本。
56 0
JVM实战—1.Java代码的运行原理
本文介绍了Java代码的运行机制、JVM类加载机制、JVM内存区域及其作用、垃圾回收机制,并汇总了一些常见问题。
JVM实战—1.Java代码的运行原理
Java 设计模式:装饰者模式(Decorator Pattern)
装饰者模式属于结构型设计模式,允许通过动态包装对象的方式为对象添加新功能,提供比继承更灵活的扩展方式。该模式通过组合替代继承,遵循开闭原则(对扩展开放,对修改关闭)。
|
4月前
|
Java代码结构解析:类、方法、主函数(1分钟解剖室)
### Java代码结构简介 掌握Java代码结构如同拥有程序世界的建筑蓝图,类、方法和主函数构成“黄金三角”。类是独立的容器,承载成员变量和方法;方法实现特定功能,参数控制输入环境;主函数是程序入口。常见错误包括类名与文件名不匹配、忘记static修饰符和花括号未闭合。通过实战案例学习电商系统、游戏角色控制和物联网设备监控,理解类的作用、方法类型和主函数任务,避免典型错误,逐步提升编程能力。 **脑图速记法**:类如太空站,方法即舱段;main是发射台,static不能换;文件名对仗,括号要成双;参数是坐标,void不返航。
156 5
设计模式觉醒系列(01)设计模式的基石 | 六大原则的核心是什么?
本文介绍了设计模式的六大原则,包括单一职责原则(SRP)、开闭原则(OCP)、里氏替换原则(LSP)、接口隔离原则(ISP)、依赖倒置原则(DIP)和迪米特法则。通过具体案例分析了每个原则的应用场景及优势,强调了这些原则在提升代码可维护性、可复用性、可扩展性和降低耦合度方面的重要作用。文章指出,设计模式的核心在于确保系统模块间的低耦合高内聚,并为后续深入探讨23个经典设计模式打下基础。

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等