模式模式（一）

最新推荐文章于 2024-07-27 18:05:15 发布
最新推荐文章于 2024-07-27 18:05:15 发布
阅读量495 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41709536/article/details/114903290
版权

设计模式

课程链接： bilibili尚硅谷课程

  • 设计模式的七大原则
    • 单一职责原则
    • 接口分离原则
    • 依赖反转原则
    • 里氏替换原则
    • 开闭原则
    • 迪米特法则
    • 合成复用原则

1 单一职责原则

顾名思义：一个类只应该对一项负责

public class Singleresponsibility {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        //违反了单一原则的原则
        vehicle.run("摩托车");
        vehicle.run("汽车");
        vehicle.run("飞机");
    }

}


class Vehicle {
    public void run(String vehicle){
        System.out.println(vehicle + " 在公路上跑");
    }

}

上述代码Vehicle类一个类承担了所有交通工具run的功能，并不是合理的设计，需要对其进行分离。

public class Singleresponsibility2 {
    public static void main(String[] args) {
        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("摩托车");
        roadVehicle.run("汽车");

        WaterVehicle waterVehicle = new WaterVehicle();
        waterVehicle.run("船");

        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");
    }
}

class AirVehicle {
    public void run(String vehicle) {
        System.out.println(vehicle + " 在天空运行");
    }
}

class RoadVehicle {

    public void run(String vehicle) {
        System.out.println(vehicle + "在路上运行");
    }
}

class WaterVehicle {
    public void run(String vehicle){
        System.out.println(vehicle + "在水中运行");
    }
}

上述代码做到了单一原则，一个类负责各自的领域，但是改动太大了

public class Singleresponsibility3 {
    public static void main(String[] args) {
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.run("汽车");
        vehicle2.runWater("轮船");
        vehicle2.runAir("飞机");
    }
}

// 方式3的分析
// 1. 未对原来的类做大的修改，只是增加方法
// 2. 在类的级别上未遵守单一职责，但在方法的级别上遵守了单一职责
class Vehicle2 {
    public void run(String vehicle){
        System.out.println(vehicle + " 在公路上运行");
    }
    public void runAir(String vehicle){
        System.out.println(vehicle + " 在天空中运行");
    }

    public void runWater(String vehicle){
        System.out.println(vehicle + " 在水中运行");
    }

}

老师介绍了上面三种改进的方法，如果让我设计会设计成如下方案：

public class Singleresponsibility4 {
    public static void main(String[] args) {
        VehcileWays vehcileWays = new VehcileWays();
        vehcileWays.show(new Car());
        vehcileWays.show(new Plane());
        vehcileWays.show(new Boat());
    }
}

interface Vehicles{
    void run();
}


class Car implements Vehicles{

    private String name;
    @Override
    public void run() {
        System.out.println("汽车在公路上运行");
    }
}

class Boat implements Vehicles{

    @Override
    public void run() {
        System.out.println("船在水上运行");
    }
}

class Plane implements Vehicles{

    @Override
    public void run() {
        System.out.println("飞机在空中运行");
    }
}

class VehcileWays{
    public void show(Vehicles vehicles){
        vehicles.run();
    }
}

命名方式有待商榷

2 接口隔离原则

让接口负责的内容尽可能小，大接口拆分为小接口，避免接口浪费

  • 原来的大接口模式

    package com.qxd.principle;

public class Segregation {
    public static void main(String[] args) {

    }
}

interface Interface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
    void operation5();
}


class B implements Interface1 {
    public void operation1() {
    System.out.println("B 实现了 operation1");
    }
    public void operation2() {
        System.out.println("B 实现了 operation2");
    }
    public void operation3() {
        System.out.println("B 实现了 operation3");
    }
    public void operation4() {
        System.out.println("B 实现了 operation4");
    }
    public void operation5() {
        System.out.println("B 实现了 operation5");
    }
}

class D implements Interface1 {
    public void operation1() {
        System.out.println("D 实现了 operation1");
    }


    public void operation2() {
        System.out.println("D 实现了 operation2");
    }

    public void operation3() {
        System.out.println("D 实现了 operation3");
    }

    public void operation4() {
        System.out.println("D 实现了  operation4");
    }

    public void  operation5()  {
        System.out.println("D 实现了  operation5");
    }
}


class A { //A 类通过接口 Interface1 依赖(使用) B 类，但是只会用到 1,2,3 方法
    public void depend1(Interface1 i) {
        i.operation1();
    }

    public void depend2(Interface1 i) {
        i.operation2();
    }

    public void depend3(Interface1 i) {
        i.operation3();
    }
}

class C { //C 类通过接口 Interface1  依赖(使用) D 类，但是只会用到 1,4,5 方法
    public void depend1(Interface1 i) { i.operation1();
    }
    public void depend4(Interface1 i) { i.operation4();
    }
    public void depend5(Interface1 i) { i.operation5();
    }
}

    class A 与class B通过接口Interface1发生关系，Interface1就是缓冲层，避免两者发生直接的碰撞，A只要调用B的1，2，3方法，但是B实现了接口的所有方法，说明这个接口太大了，需要瘦身。

    package com.qxd.principle.improve;

public class Segregation1 {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B()); // A 类通过接口去依赖 B 类
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D()); // C 类通过接口去依赖(使用)D 类
        c.depend4(new D());
        c.depend5(new D());
    }
}

// 接 口 1
interface Interface1 {
    void operation1();
}


// 接 口 2
interface Interface2 {
    void operation2();
    void operation3();
}

// 接 口 3
interface Interface3 {
    void operation4();
    void operation5();
}

class B implements Interface1, Interface2 {
    public void operation1() {
        System.out.println("B 实现了 operation1");
    }


    public void operation2() {
        System.out.println("B 实现了 operation2");
    }


    public void operation3() {
        System.out.println("B 实现了 operation3");
    }
}

class D implements Interface1, Interface3 {
    public void operation1() {
        System.out.println("D 实现了  operation1");
    }


    public void operation4() {
        System.out.println("D 实现了  operation4");
    }


    public void operation5() {
        System.out.println("D 实现了 operation5");
    }
}


class A { // A 类通过接口 Interface1,Interface2 依赖(使用) B 类，但是只会用到 1,2,3 方法
    public void depend1(Interface1 i) {
        i.operation1();
    }


    public void depend2(Interface2 i) {
        i.operation2();
    }


    public void depend3(Interface2 i) {
        i.operation3();
    }
}



class C { // C  类通过接口 Interface1,Interface3  依赖(使用) D 类，但是只会用到 1,4,5 方法
    public void depend1(Interface1 i) {
        i.operation1();
    }


    public void depend4(Interface3 i) {
        i.operation4();
    }


    public void depend5(Interface3 i) {
        i.operation5();
    }
}

    接口的设计也需要“求同存异”

3 依赖倒转原则

本质就是面向接口编程

比如 class A中的某个方法形参为class B ，那么以后传入的参数就只能是class B了， 拓展性差。

但是class A中某个方法形参为class B抽象的接口的话，那么传入的参数就是该接口的实现类，易于维护。

package com.qxd.principle.inversion;

public class DependyInversion{
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

class Email {
    public String getInfo() {
        return "电子邮件信息: hello,world";
    }
}


class Person {
    public void receive(Email email ) {
        System.out.println(email.getInfo());
    }
}

*****************************************************************************************************
    public class DependyInversion{
    public static void main(String[] args) {
        //客户端无需改变
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeiXin());
    }
}

//定义接口
interface IReceiver {
    public String getInfo();
}


class Email implements IReceiver{
    public String getInfo() {
        return "电子邮件信息: hello,world";
    }
}

//增加微信
class WeiXin implements IReceiver {
    public String getInfo() {
    return "微信信息: hello,ok";
}

}
class Person {
    public void receive(IReceiver iReceiver ) {
        System.out.println(iReceiver.getInfo());
    }
}

上述两端代码对比即可发现两者的差距

  • 依赖关系传递的三种方式和应用案例

    • 接口传递
    //打开或者关闭哪个电视
interface IOpenAndClose {
    public void open(ITV tv); //抽象方法,接收接口

}

interface ITV { //ITV 接口
    public void play();
}
// 实现接口
 class OpenAndClose implements IOpenAndClose{
    public void open(ITV tv){
        tv.play();
    }
 }
    • 构造方法传递应用案例代码
    class OpenAndClose2 {
    public ITV tv; //成员

    public OpenAndClose2(ITV tv) { //构造器
        this.tv = tv;
    }

    public void open() {
        this.tv.play();
    }
}

    • setter 方式传递

      上述代码构造器传值改为set传值

lovefive55
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络I/O管理---五种I/O模型
weixin_38538135的博客
12-16 354
网络I/O管理---五种I/O模型 网络I/O会涉及到到三个系统对象：一个是用户空间调用 I/O的进程或者线程；一个是内核空间的内核系统；最后一个是IO device. 整个请求过程为： 用户进程/线...
并发模式（一）Future模式
RickyIT的专栏
03-01 1389
并行设计模式是对一些常用的多线程结构的总结和抽象，与串行程序设计相比，并行程序更复杂。 前言常用的并发设计模式有Future模式、Master-Worker模式、Guarded Suspension模式、不变模式、生产者-消费者模式，在多线程环境中，合理使用模式，可以提高程序性能，优化程序设计。
Web开发模式【Mode I 和Mode II的介绍、应用案例】
zhangmiaoping23的专栏
05-14 779
开发模式的介绍 在Web开发模式中，有两个主要的开发结构，称为模式一（Mode I）和模式二（Mode II）. 首先我们来理清一些概念吧： DAO(Data Access Object)：主要对数据的操作，增加、修改、删除等原子性操作。 Web层：界面+控制器，也就是说JSP【界面】+Servlet【控制器】 Service业务层：将多个原子性的DAO操作进行组合，组合成一个完整的业务逻辑 控制层：主要使用Servlet进行控制 数据访问层：使用DAO、Hibernate、JDBC技术实现对
【NIO系列】——之IO模型
weixin_33910460的博客
07-03 543
这是【NIO系列】第二篇，欢迎持续关注:【NIO系列】——之TCP探秘上一篇我们讲到了关于TCP/IP协议的一些内容，这些是网络编程的必备知识。在了解NIO之前我们必须要了解一下对应的系统层IO模型，比如java的NIO对应是那种IO模型，阻塞和同步的差异在哪里，又是否相同。了解了这些更方便我们的后续的NIO探解。一、同步、异步、阻塞、非阻塞同步、异步，阻塞、非阻塞，这四种状态常有人分不清，主要是...
[设计模式]二十三种设计模式
热门推荐
Peak的博客
08-09 1万+
分类： DesignPattern（8）  目录(?)[+] 原文地址：http://blog.csdn.net/zhangerqing 一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模
【模式模式】模式总结
遇见未知的自己
02-15 1803
设计模式学习完了，现在脑子里就是有了一个完整的框架。前边是UML图的简单回顾，最后是面向对象思想的总结，是设计模式的指导思想。中间就是在六大原则指导下的具体模式，三种类型，23种。下面是具体的导图和设计模式的展示。 一、创建型模式 1、单例模式    保证一个类仅有一个实例，并提供一个访问它的全局访问点。通常我们可以让一个全局变量使得一
一种设计模式一种设计模式
09-12
一种设计模式一种设计模式实现，单体
23种设计模式整理pdf
07-14
Singleton 模式是一种创建型模式，用于限制类的实例化次数，确保只有一个实例。Singleton 模式的优点是可以节省内存空间，因为只需要创建一个实例就足够了。 Singleton 模式的缺点是它可能会导致代码的耦合度增加。 ...
设计模式解析
11-28
例如，单例模式在Java中用于确保一个类只有一个实例，常用于日志服务、线程池和缓存管理等场景。工厂模式则提供了一种创建对象的最佳方式，使得代码更易于维护和扩展。此外，适配器模式允许不兼容的接口之间进行通信...
一个简单的工厂模式例子
01-17
java工厂模式一个简单的工厂模式例子工厂模式简单代码案例，仅供参考。java工厂模式一个简单的工厂模式例子工厂模式简单代码案例，仅供参考。java工厂模式一个简单的工厂模式例子工厂模式简单代码案例，仅供参考。...
精讲23种设计模式
07-26
实现：该模式的典型实现方法就是将调用类定义为一个虚类，在调用类定义一个专门用于构造不确定的对象实例的虚函数，再将实际的对象实例化代码留到调用类的子类来实现。 重构成本：低。该模式的重构成本实际上还与...
设计模式实战：日志系统的设计与实现
qq_40254606的博客
07-26 653
通过本项目，我们综合应用了单例模式、适配器模式和桥接模式，解决了日志系统的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
【设计模式】建造者模式
weixin_61144851的博客
07-23 931
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。：这些模式关注对象之间的组合和关系，旨在解决如何构建灵活且可复用的类和对象结构。：这些模式关注对象之间的通信和交互，旨在解决对象之间的责任分配和算法的封装。
设计模式-单例模式
最新发布
weixin_51722520的博客
07-27 98
单例设计模式
C# 设计模式分类
語衣的个人博客
07-23 912
创建型模式主要关注对象的创建过程，包括如何实例化对象，并隐藏实例化的细节。结构型模式主要关注类和对象的组合，以形成更大的结构。行为型模式主要关注对象之间的通信和职责分配。
js 优雅的实现模板方法设计模式
qq_43985303的博客
07-24 310
在JavaScript中，优雅地实现模板方法设计模式通常意味着我们要遵循一些最佳实践，如清晰地定义算法的骨架（模板方法），并确保子类能够灵活地扩展或修改这些算法中的特定步骤。此外，由于JavaScript的类和继承是基于原型的，因此这种实现方式也充分利用了JavaScript的继承机制，使得代码更加符合JavaScript的编程习惯。优雅性：通过提供默认实现，避免了在子类中必须实现所有方法的强制性要求，从而提高了代码的优雅性。灵活性：子类可以自由地选择覆盖哪些钩子方法，以及覆盖后的行为是什么。
6.3 面向对象技术-设计模式
m0_38066007的博客
07-26 429
设计模式
DP学习——外观模式
huibin.yun的博客
07-24 289
学而时习之，温故而知新。
C++(week14): C++提高:(一)面向对象设计：设计原则、设计模式
Edward2022的博客
07-25 734
类与类之间的五种关系、面向对象的七种设计原则、23种设计模式
C语言实现设计模式探索
设计模式包括单件模式、工厂模式、抽象工厂模式、访问者模式、状态模式、命令模式、解释器模式、备忘录模式、观察者模式、桥接模式、建造者模式、中介者模式、策略模式、适配器模式、装饰模式、亨元模式、代理模式、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值