Java设计模式

微亮之海

已于 2023-04-03 09:45:28 修改

阅读量1.1k

点赞数

文章标签： java 设计模式开发语言

于 2023-03-30 15:22:48 首次发布

本文链接：https://blog.csdn.net/weixin_42913992/article/details/129814643

版权

1.设计模式的目的

1.代码的重用性(即：相同功能的代码，不用多次编写)
2.可读性(即：编程规范性，便于其他程序员的阅读和理解)
3.可扩展性(即：当需要增加新的功能时，非常的方便，称为可维护性)
4.可靠性(即：当增加新的功能后，对原来的功能没有影响)
5.使程序对外呈现高内聚、低耦合的特性

2.设计模式的七大原则

设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础(即：设计模式为什么这样设计的依据)
设计模式常用的七大原则有：

单一职责原则
接口隔离原则
依赖倒转(倒置)原则
里氏替换原则
开闭原则
迪米特法则
合成复用原则

2.1单一职责原则

2.1.1基本介绍

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

2.1.2应用实例

方案1

package com.nnuo.principles.singleresponsibility;

public class SingleResponsibility1 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托车");
        vehicle.run("汽车");
        vehicle.run("飞机");
    }
}


// 交通工具类
// 方式1
// 1. 在方式1 的run方法中，违反了单一职责原则，即管了在公路上的交通工具，又管了在天上的交通工具
// 2. 解决的方案非常的简单，根据交通工具运行方法的不同，分解成不同类即可
class Vehicle{
    public void run(String vehicle){
        System.out.println(vehicle + " 在公路上运行。。。");
    }
}

方案2

package com.nnuo.principles.singleresponsibility;


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

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

        WaterVehicle waterVehicle = new WaterVehicle();
        waterVehicle.run("潜水艇");
    }
}


// 方案2的分析
// 1. 遵守单一职责原则
// 2. 但是这样做的改动很大，既将类分解，同时又修改客户端
// 3. 改进方案，直接修改Vehicle类，改动的代码会比较少=>方案3
class RoadVehicle{
    public void run(String vehicle){
        System.out.println(vehicle + " 在公路上运行。。。");
    }
}


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


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

方案3

package com.nnuo.principles.singleresponsibility;

public class SingleResponsibility3 {
    public static void main(String[] args) {
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.runRoad("汽车");
        vehicle2.runAir("飞机");
        vehicle2.runWater("潜艇");
    }
}

// 方式3的分析
// 1. 这种修改方案没有对原来的类做大的修改，只是增加方法
// 2. 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然事遵守单一职责
class Vehicle2{
    public void runRoad(String vehicle){
        System.out.println(vehicle + "在公路运行。。。");
    }

    public void runAir(String vehicle){
        System.out.println(vehicle + "在天上运行。。。");
    }

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

2.1.3 单一职责原则小结

降低类的复杂度，一个类只负责一项职责
提高类的可读性，可维护性
降低变更引起的风险
通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级别违反单一职责原则：只有类中方法量足够少，可以在方法级别保持单一职责原则

2.2接口隔离原则

2.2.1基本介绍

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

2.2.2应用实例

接口隔离之前：

package com.nnuo.principles.segregation;

public class Segregation1 {
}


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

//实现类B
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");
    }
}

//实现类D
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 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();
    }
}

接口隔离改进之后

package com.nnuo.principles.segregation.improve;




public class Segregation1 {
    public static void main(String[] args) {
        //使用一把
        A a = new A();
        a.depend1(new B());//A类通过接口去依赖(使用)B类
        a.depend1(new D());//D类也实现了Interface1，A类中的depend1()方法参数为接口Interface1,所以A类也可以通过接口Interface1使用D类
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());//C类通过接口去使用实现类D
        c.depend1(new B());//C类通过接口去使用实现类B,谁实现了接口1就可以使用谁
        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();
}

//接口1和2的实现类B
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");
    }
}

//接口1和3的实现类D
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和Interface2 依赖(使用) B类，但是只会用到1，2，3方法
    public void depend1(Interface1 i1){
        i1.operation1();
    }
    public void depend2(Interface2 i2){
        i2.operation2();
    }
    public void depend3(Interface2 i2){
        i2.operation3();
    }
}

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