java设计模式之七大设计原则(1)

大家好,我是一名在算法之路上不断前进的小小程序猿!体会算法之美,领悟算法的智慧~

希望各位博友走过路过可以给我点个免费的赞,你们的支持是我不断前进的动力!!

加油吧!未来可期!!!

java设计模式之七大设计原则

设计模式常用的七大原则:

设计模式常用的七大原则有: 1) 单一职责原则 2) 接口隔离原则 3) 依赖倒转原则 4) 里氏替换原则 5) 开闭原则 ocp 6) 迪米特法则 7) 合成复用原则

本文将先介绍前三个原则:单一职责原则、接口隔离原则、依赖倒转原则。

设计模式的重要性:

编写软件过程中,程序员面临着来自耦合性,内聚性以及可维护性,可扩展性,重用性,灵活性 等多方面的挑战,设计模式是为了让程序(软件),具有更好的

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

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

3) 可扩展性 (即:当需要增加新的功能时,非常的方便,称为可维护)

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

5) 使程序呈现高内聚,低耦合的特性

6)设计模式包含了面向对象的精髓,“懂了设计模式,你就懂了面向对象分析和设计 (OOA/D)的精要”

7)Scott Mayers 在其巨著《Effective C++》就曾经说过:C++老手和 C++新手的区别就是 前者手背上有很多伤疤

单一职责原则:

基于类上实现单一职责原则:

package singleresponsibility;/* <---这是包名
-*- coding:utf-8 -*-
作者:bob-coding
日期:2022年09月25日15:28
人生苦短,自学idea!!冲冲冲!!!*/

public class SingleResponsibility {
    public static void main(String[] args) {
        Vehicle1 vehicle1 = new Vehicle1();
        vehicle1.Roadrun("汽车");
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.Airrun("飞机");
        Vehicle3 vehicle3 = new Vehicle3();
        vehicle3.Waterrun("轮船");

    }
}

class Vehicle1{
    public void Roadrun(String vehicle){
        System.out.println(vehicle + "在公路上跑...");
    }
    //对于在这个类里操作不会影响到其他类到功能
}

class Vehicle2{
    public void Airrun(String vehicle){
        System.out.println(vehicle + "在天空上跑...");
    }
}

class Vehicle3{
    public void Waterrun(String vehicle){
        System.out.println(vehicle + "在海里上跑...");
    }
}

运行截图:

java设计模式之七大设计原则(1)_第1张图片

 

基于方法上实现单一职责原则,原则上说,并没有那么严谨地遵循:

package singleresponsibility;/* <---这是包名
-*- coding:utf-8 -*-
作者:bob-coding
日期:2022年09月25日15:28
人生苦短,自学idea!!冲冲冲!!!*/

public class SingleResponsibility2 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.Roadrun("汽车");
        vehicle.Airrun("飞机");
        vehicle.Waterrun("轮船");

    }
}

class Vehicle{
    public void Roadrun(String vehicle){
        System.out.println(vehicle + "在公路上跑...");
    }
    public void Airrun(String vehicle){
        System.out.println(vehicle + "在天空上跑...");
    }
    public void Waterrun(String vehicle){
        System.out.println(vehicle + "在海里上跑...");
    }
}

运行截图

java设计模式之七大设计原则(1)_第2张图片

 单一职责原则注意事项和细节 :1) 降低类的复杂度,一个类只负责一项职责。 2) 提高类的可读性,可维护性 3) 降低变更引起的风险 4) 通常情况下,我们应当遵守单一职责原则,只有逻辑足够简单,才可以在代码级违反单一职责原则;只有类中方法数量足够少,可以在方法级别保持单一职责原则

接口隔离原则

例子:类A通过接口Interface1依赖类B,类C通过接口Interface1依赖类D,如果接口 Interface1对于类A和类C来说不是最小接口, 那么类B和类D必须去实现他们不需要的方法。

分析:按隔离原则应当这样处理: 将接口Interface1拆分为独立的几个接口, 类A和类C分别与他们需要的接口建立依赖 关系。也就是采用接口隔离原则。

java设计模式之七大设计原则(1)_第3张图片

 对接口interface1进行拆分

java设计模式之七大设计原则(1)_第4张图片

应传统方法的问题和使用接口隔离原则改进: 1) 类A通过接口Interface1依赖类B,类C通过接口Interface1依赖类D,如果接口 Interface1对于类A和类C来说不是最小接口,那么类B和类D必须去实现他们不 需要的方法 2) 将接口Interface1拆分为独立的几个接口,类A和类C分别与他们需要的接口建立 依赖关系。也就是采用接口隔离原则 3) 接口Interface1中出现的方法,根据实际情况拆分为三个接口 

代码实现:

package segregation;/* <---这是包名
-*- coding:utf-8 -*-
作者:bob-coding
日期:2022年09月25日16:21
人生苦短,自学idea!!冲冲冲!!!*/

public class Segregation {
    public static void main(String[] args) {
        A a = new A();
        C c = new C();
        a.depend1(new B());
        a.depend2(new B());
        c.depend3(new D());
        c.depend4(new D());
    }
}

interface Interface1{
    void operation1();
}

interface Interface2{
    void operation2();
    void operation3();
}

interface Interface3{
    void operation4();
    void operation5();
}

//B实现了1,2,3方法
class B implements Interface1,Interface2{

    @Override
    public void operation1() {
        System.out.println("B实现了接口1");
    }

    @Override
    public void operation2() {
        System.out.println("B实现了接口2");
    }

    @Override
    public void operation3() {
        System.out.println("B实现了接口3");
    }
}

//D实现了1,4,5方法
class D implements Interface1,Interface3{

    @Override
    public void operation1() {
        System.out.println("D实现了接口1");
    }

    @Override
    public void operation4() {
        System.out.println("D实现了接口4");
    }

    @Override
    public void operation5() {
        System.out.println("D实现了接口5");
    }
}

class A{
    public void depend1(Interface1 i){
        i.operation1();
    }
    public void depend2(Interface2 i){
        i.operation2();
        i.operation3();
    }
}

class C{
    public void depend3(Interface1 i){
        i.operation1();
    }
    public void depend4(Interface3 i){
        i.operation4();
        i.operation5();
    }
}

java设计模式之七大设计原则(1)_第5张图片

依赖倒转原则 

基本介绍:依赖倒转原则(Dependence Inversion Principle)是指: 1) 高层模块不应该依赖低层模块,二者都应该依赖其抽象 2) 抽象不应该依赖细节,细节应该依赖抽象 3) 依赖倒转(倒置)的中心思想是面向接口编程 4) 依赖倒转原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的 多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中,抽象 指的是接口或抽象类,细节就是具体的实现类 5) 使用接口或抽象类的目的是制定好规范,而不涉及任何具体的操作,把展现细节的 任务交给他们的实现类去完成。

依赖倒转原则:依赖关系传递的三种方式 1) 接口传递  2) 构造方法传递  3) setter方式传递 

package dependecyinversion;/* <---这是包名
-*- coding:utf-8 -*-
作者:bob-coding
日期:2022年09月25日17:19
人生苦短,自学idea!!冲冲冲!!!*/

//接口传递
public class DependecyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new Weixin());
    }
}

interface IReceiver{
    String getinfo();
}

class Email implements IReceiver{

    @Override
    public String getinfo() {
        return "Email信息:email";
    }
}

class Weixin implements IReceiver{

    @Override
    public String getinfo() {
        return "Weixin信息:Weixin";
    }
}

//person类依赖抽象的接口,不会对person类进行大的修改,提高可扩展性
//基于接口传递
class Person{
    public void receive(IReceiver irceiver) {
        System.out.println(irceiver.getinfo());
    }
}

java设计模式之七大设计原则(1)_第6张图片

注意:依赖倒转原则的注意事项和细节

1) 低层模块尽量都要有抽象类或接口,或者两者都有,程序稳定性更好.

2) 变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间,就存在 一个缓冲层,利于程序扩展和优化

3) 继承时遵循里氏替换原则 

你可能感兴趣的:(java设计模式,java,设计模式,学习)