通过Java代码来理解设计模式的七大原则(一)

最新推荐文章于 2024-03-25 19:57:57 发布
最新推荐文章于 2024-03-25 19:57:57 发布
阅读量151 收藏 1
点赞数
文章标签： 设计模式 接口 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44268660/article/details/105675384
版权

单一职责原则

定义很简单：一个类只负责一项职责，这就叫单一职责原则。先来看一个Demo

public class SingleResponsibility1 {
    public static void main(String[] args) {
        new Animal().eat("猫");
        new Animal().eat("兔子");
        //运行结果：
        /**
        *猫吃肉
        *兔子吃肉
        */
    }
}
class Animal{
    public void eat(String animal){
        System.out.println(animal+"吃肉");
    }
}

兔子并不是吃肉的，很明显，这里的Animal类既负责吃肉的动物，又负责吃素的动物，违背了单一职责原则。而最容易想到的改进方法就是将Animal类细分为肉食动物类和素食动物类两个类：

public class SingleResponsibility2 {
    public static void main(String[] args) {
        new MeatAnimal().eat("猫");
        new GrassAnimal().eat("兔子");
        //运行结果：
        /**
        *猫吃肉
        *兔子吃草
        */
    }
}
class MeatAnimal{
    public void eat(String animal){
        System.out.println(animal+"吃肉");
    }
}
class GrassAnimal{
    public  void eat(String animal){
        System.out.println(animal+"吃草");
    }
}

但是这种方式不仅要将原来的类分解，还要改动客户端（main方法）里的代码，因此代码的可维护性较差，不是理想的方案，下面再给出一种改动方案：

public class SingleResponsibility3 {
    public static void main(String[] args) {
        new Animal().eat1("猫");
        new Animal().eat2("兔子");
    }
}
class Animal{
    public void eat1(String animal){
        System.out.println(animal+"吃肉");
    }
    public void eat2(String animal){
        System.out.println(animal+"吃草");
    }
}

这种方案实质上并不是类的单一职责原则，而是方法上的单一职责原则，相比上面两种要好一些。这三种方案，一种比一种好，但第三种也不是最好的，总之，如果仅仅只用单一职责原则，确实能够对代码优化，但要达到最优，有时候用的不仅仅是一种原则。七大原则中的好几条可能要一起用才行，还是这个例子，看第四个Demo

public class SingleResponsibility4 {
    public static void main(String[] args) {
        new Animal().eat(new Cat());
        new Animal().eat(new Rabbit());
    }
}
class Animal{
    //Animal的eat方法是对接口Eat的依赖
    public void eat(Eat eat){
        System.out.println(eat.getEatType());
    }
}
interface Eat{
    public String getEatType();
}
class Cat implements Eat{
    @Override
    public String getEatType() {
        return "猫吃肉";
    }
}
class Rabbit implements Eat{

    @Override
    public String getEatType() {
        return "兔子吃草";
    }
}

别看这个代码这么长，但是第四种相比前三种来说，可维护性可扩展性要高得多，这种方式，既遵守了单一职责原则，又遵守了依赖倒转原则，就是我上面说的，同时遵守多种原则的情况，简单说说这第四种为什么可维护性和可扩展性高？

  • 如果现在新增了一个长颈鹿的动物，长颈鹿是吃树叶的
  • 那么main方法里之前的东西不用改，只需要往后面加就行了（可扩展性体现）
  • Animal类完全不需要任何修改
  • Eat接口完全不需要任何修改
  • 只需要新增一个Giraffe类去实现Eat接口，并重写getEatType方法就ok
  • 从上面我们可以看出，一旦实际需求发送变化，只需要做很小的改动，并且只是“增加”/“删除”这种操作，完全没有“修改”这种操作

再来看看增加一个长颈鹿，代码怎么写：

public class SingleResponsibility4 {
    public static void main(String[] args) {
        new Animal().eat(new Cat());
        new Animal().eat(new Rabbit());
        new Animal().eat(new Giraffe());
    }
}
class Animal{
    //Animal的eat方法是对接口Eat的依赖
    public void eat(Eat eat){
        System.out.println(eat.getEatType());
    }
}
interface Eat{
    public String getEatType();
}
class Cat implements Eat{
    @Override
    public String getEatType() {
        return "猫吃肉";
    }
}
class Rabbit implements Eat{

    @Override
    public String getEatType() {
        return "兔子吃草";
    }
}
class Giraffe implements Eat{

    @Override
    public String getEatType() {
        return "长颈鹿吃树叶";
    }
}

接口隔离原则

定义：一个类对另一个类的依赖应该建立在最小的接口上;先看一个UML图：
在这里插入图片描述
做个说明：

  • A通过Intergace1会依赖B，但A中只会使用到接口的1，2，3这三个方法
  • C通过Intergace1会依赖D，但C中只会使用到接口的1，4，5这三个方法

先按照以上的UML图来写下代码：

public class InterfacePrinciple {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D());
        /**
         * 运行结果：
         * B实现了operation1方法
         * B实现了operation2方法
         * B实现了operation3方法
         * D实现了operation1方法
         * D实现了operation4方法
         * D实现了operation5方法
         */

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

    @Override
    public void operation1() {
        System.out.println("B实现了operation1方法");
    }

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

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

    @Override
    public void operation4() {
        System.out.println("B实现了operation4方法");
    }

    @Override
    public void operation5() {
        System.out.println("B实现了operation5方法");
    }
}
class D implements Interface1{

    @Override
    public void operation1() {
        System.out.println("D实现了operation1方法");
    }

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

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

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

    @Override
    public void operation5() {
        System.out.println("D实现了operation5方法");
    }
}
class A{
    public void depend1(Interface1 m){
        m.operation1();
    }
    public void depend2(Interface1 m){
        m.operation2();
    }
    public void depend3(Interface1 m){
        m.operation3();
    }
}

class C{
    public void depend1(Interface1 m){
        m.operation1();
    }
    public void depend4(Interface1 m){
        m.operation4();
    }
    public void depend5(Interface1 m){
        m.operation5();
    }
}

从这个代码以及运行结果来看，B和D两个类都实现了Interface1里的所有方法，然而A和C通过接口去依赖BD，仅仅只用到了一部分方法，也就是说，对B来说，operation4和operation5白写了，因为A根本用不到这两个。同样的，对D来说，operation2和operation3也白写了，C也用不到这两个。因此，以上的UML类图需要做出改动：
在这里插入图片描述
这一种设计方案，就叫做接口隔离，具体代码我就懒得贴上来了，总之，接口隔离的目的，就是：用不到的方法就隔离，手法是拆分原来的接口，分别去实现和依赖。

依赖倒转原则

四句话可以概括它：

  • 高层模块不应该依赖低层模块，二者都应该依赖其抽象
  • 抽象不应该依赖细节，细节应该依赖抽象
  • 依赖倒转的本质是面向接口编程
  • 抽象比细节要稳定的多，抽象指的是接口或抽象类，细节指的是实现类/继承类

在上面单一职责原则的最后一个Demo的代码就用到了依赖倒转原则，现在再单独写一个别的：

public class DependenceInversion {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.receive(new Email());
        /**
         * 运行结果：
         * 收到电子邮件信息，信息内容为：“hello,jack”
         */
    }
}

class Email {
    public String getInfo() {
        return "收到电子邮件信息，信息内容为：“hello,jack”";
    }
}

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

来分析一下以上代码：

  • 手机收到信息，如果收到的是Email信息，就像上面那样写ok，如果收到的是微信信息，QQ信息等，那么在Phone这个类里面，就还要增加WeiXin以及QQ的receive方法
  • 还能怎么做呢？还可以引入一个接口InfoSource,表示信息来源；而Email,QQ,WeiXin就属于一系列的信息来源，因此，它们可以作为InfoSource的实现类，下面用代码来写一个：
public class DependenceInversion {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.receive(new Email());
        phone.receive(new WeiXin());
        /**
         * 运行结果：
         * 收到电子邮件信息，信息内容为：“hello,jack”
         * 收到微信信息，信息内容为：“GoodBye,jack”
         */
    }
}

class Phone {//这里是对接口的依赖，因此即便有新的信息种类来源，这里也不需要更改
    public void receive(InfoSource infoSource) {
        System.out.println(infoSource.getInfo());
    }
}

interface InfoSource {
    String getInfo();
}

class Email implements InfoSource {
    @Override
    public String getInfo() {
        return "收到电子邮件信息，信息内容为：“hello,jack”";
    }
}

class WeiXin implements InfoSource {
    @Override
    public String getInfo() {
        return "收到微信信息，信息内容为：“GoodBye,jack”";
    }
}

依赖关系的三种传递方式

  • 基于接口的传递
public class DependenceInversion {
    public static void main(String[] args) {
        new Email().receive(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("收到Email信息，内容为：“你好帅呀”");
            }
        });
        new Email().send(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("发送Email信息，内容为:“你更帅”");
            }
        });
        new WeiXin().receive(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("收到微信信息，内容为：“你好丑啊”");
            }
        });
        new WeiXin().send(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("发送微信信息，内容为:“你比我更丑”");
            }
        });
        /**
         * 运行结果：
         * 收到Email信息，内容为：“你好帅呀”
         * 发送Email信息，内容为:“你更帅”
         * 收到微信信息，内容为：“你好丑啊”
         * 发送微信信息，内容为:“你比我更丑”
         */
    }
}


interface ReceiveOrSend {//接收或者发送
	//两个抽象方法都接收了接口
    void receive(InfoSource infoSource);

    void send(InfoSource infoSource);
}

interface InfoSource {//信息

    void getInfo();//信息具体内容
}

class Email implements ReceiveOrSend {

    @Override
    public void receive(InfoSource infoSource) {
        infoSource.getInfo();
    }

    @Override
    public void send(InfoSource infoSource) {
        infoSource.getInfo();
    }
}

class WeiXin implements ReceiveOrSend {

    @Override
    public void receive(InfoSource infoSource) {
        infoSource.getInfo();
    }

    @Override
    public void send(InfoSource infoSource) {
        infoSource.getInfo();
    }
}
  • 基于构造器传递
public class DependenceInversion {
    public static void main(String[] args) {
        new Email(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("收到Email信息，内容为：“你好帅呀”");
            }
        }).receive();
        new Email(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("发送Email信息，内容为:“你更帅”");
            }
        }).send();
        new WeiXin(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("收到微信信息，内容为：“你好丑啊”");
            }
        }).receive();
        new WeiXin(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("发送微信信息，内容为:“你比我更丑”");
            }
        }).send();
        /**
         * 运行结果：
         * 收到Email信息，内容为：“你好帅呀”
         * 发送Email信息，内容为:“你更帅”
         * 收到微信信息，内容为：“你好丑啊”
         * 发送微信信息，内容为:“你比我更丑”
         */
    }
}


interface ReceiveOrSend {//接收或者发送
    //两个抽象方法没有接收接口
    void receive();

    void send();
}

interface InfoSource {//信息

    void getInfo();//信息具体内容
}

class Email implements ReceiveOrSend {
    public InfoSource mInfoSource;
    public Email(InfoSource infoSource){
        mInfoSource = infoSource;
    }
    @Override
    public void receive() {
        mInfoSource.getInfo();
    }

    @Override
    public void send() {
        mInfoSource.getInfo();
    }
}

class WeiXin implements ReceiveOrSend {
    public InfoSource mInfoSource;
    public WeiXin(InfoSource infoSource){
        mInfoSource = infoSource;
    }
    @Override
    public void receive() {
        mInfoSource.getInfo();
    }

    @Override
    public void send() {
        mInfoSource.getInfo();
    }
}
  • 通过setter方法传递
public class DependenceInversion {
    public static void main(String[] args) {
        Email email = new Email();
        email.setInfo(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("收到Email信息，内容为：“你好帅呀”");
            }
        });
        email.receive();
        email.setInfo(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("发送Email信息，内容为:“你更帅”");
            }
        });
        email.send();
        WeiXin weiXin = new WeiXin();
        weiXin.setInfo(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("收到微信信息，内容为：“你好丑啊”");
            }
        });
        weiXin.receive();
        weiXin.setInfo(new InfoSource() {
            @Override
            public void getInfo() {
                System.out.println("发送微信信息，内容为:“你比我更丑”");
            }
        });
        weiXin.send();
        /**
         * 运行结果：
         * 收到Email信息，内容为：“你好帅呀”
         * 发送Email信息，内容为:“你更帅”
         * 收到微信信息，内容为：“你好丑啊”
         * 发送微信信息，内容为:“你比我更丑”
         */
    }
}


interface ReceiveOrSend {//接收或者发送
    //两个抽象方法没有接收接口
    void receive();

    void send();
	//新增了一个setter方法
    void setInfo(InfoSource infoSource);
}

interface InfoSource {//信息

    void getInfo();//信息具体内容
}

class Email implements ReceiveOrSend {
    public InfoSource mInfoSource;

    @Override
    public void receive() {
        mInfoSource.getInfo();
    }

    @Override
    public void send() {
        mInfoSource.getInfo();
    }

    @Override
    public void setInfo(InfoSource infoSource) {
        mInfoSource = infoSource;
    }
}

class WeiXin implements ReceiveOrSend {
    public InfoSource mInfoSource;

    @Override
    public void receive() {
        mInfoSource.getInfo();
    }

    @Override
    public void send() {
        mInfoSource.getInfo();
    }

    @Override
    public void setInfo(InfoSource infoSource) {
        mInfoSource = infoSource;
    }
}

七大原则已经写了3个，后面4个下一篇博客再接着写

King*
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中的设计模式与7大原则归纳整理
08-30
Java中的设计模式是一种被广泛应用于软件工程中的最佳实践，它们是经过时间和经验验证的解决方案，旨在提高代码的可重用性、可维护性和可扩展性。设计模式分为三大类：创建型模式、结构型模式和行为型模式。 1. ...
23种设计模式，及设计模式的七种设计原则的文档和Java代码实现
10-01
这个压缩包包含了23种经典的设计模式，以及一个额外的规格模式(SpecificationPattern)，并且每种模式都有详细的文档说明和Java代码实现。 首先，我们要了解七种设计原则，它们是设计模式的基础： 1. 单一职责原则...
java设计模式七大原则理解
qq_39980463的博客
04-28 205
设计模式目的： 1.重用性 ：相同能能的代码，不用多次编写 2.可读性 ：编程规范性 3.可扩展性 ：当需要增加新的功能时成本低 4.可靠性 ：当增加/减少新功能，对原来功能没有影响 5.是程序高内聚，低耦合的特性：模块之间耦合性低 设计模式原则： 1.单一职责原则 2.接口隔离原则 3.依赖倒转（倒置）原则 4.里氏替换原则 5.开闭原则 6.迪米特原则 7...
面向对象编程原则(06)——依赖倒转原则
谷哥的小弟
09-08 1830
依赖倒转原则(Dependence Inversion Principle，DIP)是RobertCMartin在1996年为C++Reporter所写的专栏EngineeringNotebook的第三篇，后来加入到他在2002年出版的经典著作《Agile Software Development,Principles,Patterns,and Practices》一书中。如果说开闭原则是面向对象设计的目标，那么依赖倒转原则就是面向对象设计的主要实现机制之一，它是系统抽象化的具体实现。
依赖倒转原则
wu_l_v的博客
06-22 1674
1、基本介绍 依赖倒转原则(Dependence Inversion Principle)是指： 高层模块不应该依赖低层模块，二者都应该依赖其抽象(抽象类/接口)，不要去依赖一个具体的子类 抽象不应该依赖细节，细节应该依赖抽象（这样稳定性会比较好） 依赖倒转(倒置)的中心思想是面向接口编程 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在 java 中，抽象指的是接口或抽象类，细节就是具体的实现类 使用接口或抽.
设计模式：依赖倒转原则（详解）
weixin_52533007的博客
05-11 1291
依赖倒转原则(高层模块不应该依赖低层模块，二者都应该依赖其抽象抽象不应该依赖细节，细节应该依赖抽象依赖倒转(倒置)的中心思想是面向接口编程依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类。
依赖倒置原则
skystep的博客
06-26 3183
“所以这里就出现了一连串的对象依赖，从而造成了严重的耦合灾难。解决这个问题的最好的办法就是，买卖双方都依赖于抽象——也就是货币——来进行交换，这样一来耦合度就大为降低了。”依赖倒置原则的原始定义为：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。其核心思想是：要面向接口编程，不要面向实现编程。依赖倒置原则是实现开闭原则的重要途径之一，它降低了客户与实现模块之间的耦合。 1.3. 总结 从代码来看，Player 类是依赖类，属于高层模块，
Java设计模式精讲1
08-08
同时，课程强调了软件设计的七大原则，如开闭原则、依赖倒置原则等，这些原则是设计模式的基础，能指导开发者编写更加符合面向对象思想的代码。 通过深入学习和实践UML、设计模式和设计原则，开发者可以提升抽象...
尚硅谷_韩顺平_图解Java设计模式
10-09
首先，通过一些经典的面试题，帮助学习者理解设计模式在实际工作中的重要性。设计模式不仅能够提高代码的可读性和可维护性，还能帮助开发者更好地解决复杂问题，提升软件设计的质量和效率。课程的亮点在于采用图解的...
依赖倒置原则（Dependecy-Inversion Principle）
Mr. David 专栏
03-08 4017
如果需要修改系统的行为，无须对抽象层进行任何改动，只需要增加新的具体类来实现新的业务功能即可，实现在不修改已有代码的基础上扩展系统的功能，达到开闭原则的要求。依赖正置就是类间的依赖是实实在在的实现类间的依赖，也就是面向实现编程，这也是正常人的思维方式，我要开奔驰车就依赖奔驰车，我要使用笔记本电脑就直接依赖笔记本电脑，而编写程序需要的是对现实世界的事物进行抽象，抽象的结构就是有了抽象类和接口，然后我们根据系统设计的需要产生了抽象间的依赖，代替了人们传统思维中的事物间的依赖，“倒置”就是从这里产生的。
Java设计模式七大原则（3）
qq_43228581的博客
12-23 329
@Adrian 依赖倒转原则 一、基本介绍 依赖倒转原则（Dependence Inversion Principle）是指： 1）高层模块应该依赖低层模块，二者都应该依赖其抽象 2）抽象不应该依赖细节，细节应该依赖抽象 3）依赖倒转（倒置）的中心思想是面向接口编程 4）依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础的架构比以细节为基础的框架要稳定的多。在...
005六大设计原则-依赖倒转原则
技术改变世界
12-13 775
1依赖倒转原则介绍 依赖倒转原则，又称依赖倒置原则（Dependence Inversion Principle），又称DIP原则，官方定义为： “高级模块不应该依赖低级模块，两者都应该依赖抽象。” “抽象不应该依赖于细节，细节应该依赖于抽象。” 低级模块：每一个逻辑的实现都是由原子逻辑组成的，不可分割的原子逻辑就是低层模块 高级模块：原子逻辑的组装就是高层模块 抽象：指接口或抽象类，不能被实例化 细节：实现类，实现接口或继承抽象类而产生的类就是细节，可以直接被实例化， 为了理解这个原理，我们
面向对象设计原则之依赖倒转原则
weixin_40216444的博客
03-19 420
一、定义 依赖倒转原则（Dependence Inversion Principle, DIP）的定义：高层模块不应该依赖于低层模块，它们都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。 另一种表述：要针对接口编程，不要针对实现编程。 对各种概念进行一个描述： 低层模块：不可分割的原子逻辑，可能会根据业务逻辑经常变化。 高层模块：低层模块的再组合，对低层模块的抽象。 抽象：...
Learn-设计模式系列-①七大原则
weixin_44939430的博客
04-01 1273
设计模式 文章目录设计模式@[toc]七大原则之-：单一职责接口隔离原则依赖倒转原则例子：改善后：补充：依赖关系传递的三种方式和应用案例里氏替换原则开闭原则例子迪米特法则合成复用原则思想： 七大原则之-： 单一职责 一个类，接口 方法只有一个职责 接口隔离原则 接口传递的思想实现类的引用 客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上 大白话：一个类只依赖他需要的接口方法 原先: 根据接口隔离原则改变后： 依赖倒转原则 Dependence Inversion Prin
面向对象六大原则——依赖倒置原则
热门推荐
皮皮的雅客
08-13 4万+
什么是依赖倒置原则(Dependence Inversion Principle, DIP)  依赖倒置原则的包含如下的三层含义： - 高层模块不应该依赖低层模块，两者都应该依赖其抽象 - 抽象不应该依赖细节 - 细节应该依赖抽象  每一个逻辑的实现都是由原子逻辑组成的，不可分割的原子逻辑就是低层模块(一般是接口，抽象类)，原子逻辑的组装就是高层模块。在Java语言中，抽象就是指...
设计模式之----依赖倒置（Dependency inversion principle）的理解
04-30 5404
文章目录1.前言2.概念2.1 什么是依赖？2.2 什么是上层模块和下层模块？2.3 什么是抽象和细节？3.作用4.实现方法5.实例 1.前言 依赖倒置是面向对象设计领域的一种软件设计原则。 有人会有疑惑，设计原则有什么用呢？设计原则是前辈们总结出来的经验，你可以把它们看作是内功心法。只要你在平常开发中按照设计原则进行编码，假以时日，你编程的功力将会大增。 2.概念 依赖倒置原则的原始定义为：上层模块不应该依赖下层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象，其核心思想是
依赖倒转（倒置）原则 （Dependence Inversion Principle）
最新发布
m0_51176516的博客
03-25 361
抽象不应该依赖细节，细节应该依赖抽象 依赖倒转（倒置）的中心思想是面向接口编程 使用接口或抽象类的目的是制定好规范
尚硅谷_韩顺平_图解Java设计模式课件1
08-03
接下来，课程详细讲解了设计模式的七大原则，这是理解设计模式的关键： 1. **单一职责原则**：强调一个类或模块应该有且只有一个改变的原因，有助于降低系统的复杂性和提高可读性。 2. **接口隔离原则**：提倡创建...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值