图解java设计模式

本文主要是介绍图解java设计模式，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

前言设计模式的目的

编写程序过程中，软件工程师们面临着众多挑战，其中，低耦合性（功能和功能之间低耦合）、高内聚性（模块内部是十分紧密的）、可扩展性以及可维护性、灵活性（增加新功能十分方便）、重用性（相同的功能，代码无需重复编写），可靠性（增加新的功能后，原来的功能不受影响）都是必须要考虑的因素，所以设计模式是为了让程序更可靠，更灵活，更具有面向对象的精髓

设计模式七大原则

单一职责原则
对类来说，即一个类只负责一个职责，比如我们之前写过的studentMapper他就知识负责学生的增删改查，这就是一个单一职责，如果说studentMapper还要去负责老师的信息管理，这就违背的单一职责原则，这个时候我们需要把studentMapper分成A类和B类，A去管理学生，B去管理老师。

package com.rlw.principle.singleresponsibility;

public class SingleResponsibility {
    public static void main(String[] args) {
        Tiger tiger = new Tiger();
        tiger.eat("母老虎");
        tiger.eat("菜包子");
        tiger.eat("菜团子");
        tiger.eat("菜卷子");
    }
}
class Tiger {
    public void eat(String tiger) {
        System.out.println(tiger + "在吃人！！！");
    }
}

此时已经违反了单一职责原则，母老虎可以吃人没问题，但是菜包子什么的就违反了单一职责原则。

改良2：：单一职责原则模式：但是软件花销比较大，即不仅需要修改很多个类，还要修改主方法（客户端）

package com.rlw.principle.singleresponsibility;
public class SingleResponsibility {
    public static void main(String[] args) {

        Tiger tiger = new Tiger();
        tiger.eat("母老虎");
        CaiBaoZi caiBaoZi = new CaiBaoZi();
        caiBaoZi.eat("菜包子");
        CaiTuanZi caiTuanZi = new CaiTuanZi();
        caiTuanZi.eat("菜团子");
        CaiJuanZi caiJuanZi = new CaiJuanZi();
        caiJuanZi.eat("菜卷子");
    }
}
class Tiger {
    public void eat(String tiger) {
        System.out.println(tiger + "在吃人！！！");
    }
}
class CaiBaoZi{
    public void eat(String cai){
        System.out.println(cai + "在吃火锅！！！");
    }
}
class CaiTuanZi{
    public void eat(String cai){
        System.out.println(cai + "菜团子在喝可乐！！！");
    }
}
class CaiJuanZi{
    public void eat(String cai){
        System.out.println(cai + "菜卷子在想吃鸡架！！");
    }
}

改良3：：这类虽然没有在类的级别上实现单一职责原则，但是在方法级别上仍然遵守单一职责原则

package com.rlw.principle.singleresponsibility;

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

        Tiger tiger = new Tiger();
        tiger.tigerEat("母老虎");
        tiger.caiBaoZiEat("菜包子");
        tiger.caiTuanZiEat("菜团子");
        tiger.caiJuanZiEat("菜卷子");

    }
}
class Tiger {
    public void tigerEat(String tiger) {
        System.out.println(tiger + "在吃人！！！");
    }
    public void caiBaoZiEat(String tiger) {
        System.out.println(tiger + "在吃火锅！！！");
    }
    public void caiTuanZiEat(String tiger) {
        System.out.println(tiger + "在喝可乐！！！");
    }
    public void caiJuanZiEat(String tiger) {
        System.out.println(tiger + "在想吃鸡架！！！");
    }
}
//补充一点，改良3版本如果方法及其多，那我们还是要使用改良2的办法分多个类进行拆分

总结：单一职责原则各行其职！！！！
接口隔离原则
一个类不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小接口上

package com.rlw.principle.segregation;

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

    }
}
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{//A类通过接口Interface1依赖B类，但是只会用到1，2，3方法
    public void depand1(Interface1 i){
        i.operation1();
    }
    public void depand2(Interface1 i){
        i.operation2();
    }
    public void depand3(Interface1 i){
        i.operation3();
    }
}
class C{//C类通过接口Interface1依赖B类，但是只会用到1，2，3方法
    public void depand1(Interface1 i){
        i.operation1();
    }
    public void depand4(Interface1 i){
        i.operation4();
    }
    public void depand5(Interface1 i){
        i.operation5();
    }
}

一个类对另一个类的依赖应该建立在最小接口上
以上代码类A通过接口Interface1依赖B，类C通过接口Interface1依赖D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法。
按照隔离原则应当这样处理：将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则
接口Interface1中出现的方法，根据实际情况拆分为三个接口

package com.rlw.principle.segregation;

public class Segregation1 {
    public static void main(String[] args) {
        A a = new A();
        a.depand1(new B()); //A类通过接口去依赖B
        a.depand2(new B());
        a.depand3(new B());
        C c = new C();
        c.depand1(new D());//C类通过接口去依赖D
        c.depand4(new D());
        c.depand5(new D());

    }
}
interface Interface1{
    void operation1();
}
interface Interface2{
    void operation2();
    void operation3();
}
interface Interface3{
    void operation4();
    void operation5();
}
class B implements Interface1,Interface2{
    @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");
    }

}
class D implements Interface1,Interface3{
    @Override
    public void operation1() {
        System.out.println("D 实现了 operation1");
    }
    @Override
    public void operation4() {
        System.out.println("D 实现了 operation4");
    }
    @Override
    public void operation5() {
        System.out.println("D 实现了 operation5");
    }
}
class A{//A类通过接口Interface1依赖B类，但是只会用到1，2，3方法
    public void depand1(Interface1 i){
        i.operation1();
    }
    public void depand2(Interface2 i){
        i.operation2();
    }
    public void depand3(Interface2 i){
        i.operation3();
    }
}
class C{//C类通过接口Interface1依赖B类，但是只会用到1，2，3方法
    public void depand1(Interface1 i){
        i.operation1();
    }
    public void depand4(Interface3 i){
        i.operation4();
    }
    public void depand5(Interface3 i){
        i.operation5();
    }
}

这篇关于图解java设计模式的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！