Java设计模式01-CSDN博客

本文链接：https://blog.csdn.net/qq_44646316/article/details/109137708

文章目录

- - Java设计模式01

Java设计模式01

定义

设计模式：对软件设计中普遍存在或反复出现的各种问题提出的解决方案，站在项目结构而非功能实现的角度思考，使程序具有更好的代码重用性、可读性、可靠性，程序呈现高内聚低耦合的特性。

在软件中哪里使用：面向对象=>功能模块[设计模式+数据结构和算法]=>框架[多种设计模式]=>架构[服务器集群]

设计模式七大原则

设计原则核心思想

找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
针对接口编程，而不是针对实现编程。
为了交互对象之间的松耦合设计努力。

七大原则

单一职责原则

概念：对类来说，一个类只负责一项职责。

通常情况应该遵守单一职责原则，只有逻辑足够简单才可以在代码级别违反，类中方法数量足够少时才可以在方法级别违反单一职责原则。
接口隔离原则

概念：一个类对另一个类的依赖应该建立在最小的接口上，将用不到的接口隔离，接口拆成最小。

接口权限问题：接口默认public访问权限，继承后重写的方法不能缩小范围。

多态：

依赖倒转原则

概念：相对细节的多变性，抽象的东西更为稳定。所以以抽象为基础搭建的架构比以细节为基础的更稳定。高层模块不应该依赖低层模块，二者都应该依赖其抽象。抽象不依赖细节，细节应该依赖抽象（即抽象类或接口）。依赖倒转原则的中心思想是面向接口编程。使用接口或抽象类的目的是制定好规范（设计）而不涉及任何具体操作，把展现细节的任务交给其实现类完成。

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

interface IReceiver{
    public String getInfo();
}
class Email implements IReceiver{
    public String getInfo(){
        return "邮件消息：早上好";
    }
}
class WeChat implements IReceiver{
    public String getInfo(){
        return "微信消息：晚上好";
    }
}

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

依赖关系传递的三种方式：

接口传递

示例：

public class InterfaceTransmit {
    public static void main(String[] args) {
        Changhong changhong = new Changhong();
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.open(changhong);

    }
}

interface IOpenAndClose{
    public void open(ITV itv);
    public void close(ITV itv);
}

interface ITV{
    public void play();
    public void close();
}

class Changhong implements ITV {

    @Override
    public void play() {
        System.out.println("正在播放");
    }

    @Override
    public void close() {
        System.out.println("已关闭");
    }


}

class OpenAndClose implements IOpenAndClose{

    @Override
    public void open(ITV itv) {
        itv.play();
    }

    @Override
    public void close(ITV itv) {
        itv.close();
    }
}

构造方法传递

示例：

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

        OpenAndClose openAndClose = new OpenAndClose(new ChangHong());
        openAndClose.open();

    }
}

interface IOpenAndClose{
    public void open();
}

interface ITV{
    public void play();
}

class OpenAndClose implements IOpenAndClose{

    public ITV tv;
    public OpenAndClose(ITV tv){
        this.tv = tv;
    }

    @Override
    public void open() {
        tv.play();
    }
}

class ChangHong implements ITV{

    @Override
    public void play() {
        System.out.println("正在播放");
    }
}

setter方法传递

示例：

public class InterfaceTransmit {
    public static void main(String[] args) {
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setTv(new Changhong());
        openAndClose.open();
    }
}

interface IOpenAndClose{
    public void open();
}

interface ITV{
    public void play();
}

class OpenAndClose implements IOpenAndClose{
    private ITV tv;

    public void setTv(ITV tv){
        this.tv = tv;
    }

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

class Changhong implements ITV{

    @Override
    public void play() {
        System.out.println("正在播放");
    }
}

注意事项和细节：

低层模块尽量都要有抽象类和接口，或者两者都有，程序稳定性更好。

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

继承时遵循里氏转换原则。

里氏替换原则

概念：所有引用基类的地方必须能够透明地使用其子类的对象。
开闭原则（OCP）

概念：一个软件实体比如类、模块和函数应该对扩展开放（对提供方），对修改关闭（对使用方），用抽象构造框架，用实现扩展细节。

当软件需要变化时，尽量通过扩展软件实体的行为实现变化，而不是通过修改已有的代码实现。
迪米特法则

概念：又叫“最少知道原则”，核心是降低类之间的耦合，只与直接朋友通信。

直接朋友：我们称出现成员变量，方法参数，方法返回值中的类为直接朋友，而出现在局部变量中的类不是直接朋友。
合成复用原则

概念：尽量使用合成/聚合的方式而非继承。

依赖（dependency）：传类A的实例进类B的方法。

聚合（aggregation）：在类B中添加类A的属性（attribute）并创建A的set方法。

组合（composite）：在类B中new A()