标签：最细对象 double void 接口 class 源码设计模式 public

目的

提高软件系统的可维护性和可复用性，增加软件的可拓展性和灵活性，程序员遵循 6 条原则来开发程序，从而提高软件开发效率、节约软件开发成本和维护成本。

开闭原则（OCP）

核心思想

1. 对拓展开放

软件模块应该在不修改原有代码的情况下，通过扩展的方式增加新功能。
目标：提高系统的可拓展性，适应不断变化的需求。

2. 对修改关闭

在新增需求时，尽量避免修改现有代码。
目标：降低由于修改代码引发的潜在问题，提高系统的稳定性。

实现方式

1. 使用抽象

通过定义接口或抽象类，让具体实现依赖于抽象，而不是直接依赖具体类。
增加新功能时，实现新的子类，不需要修改原有类。

2. 多态机制

借助继承与多态，在运行时决定调用哪个具体类实现。

示例

AbstractSkin：

// 皮肤抽象类
public abstract class AbstractSkin {

    public abstract void display();

}

DefaultSpecificSkin：

// 默认皮肤
public class DefaultSpecificSkin extends AbstractSkin{

    @Override
    public void display() {
        System.out.println("默认皮肤.....");
    }
}

SupermanSpecificSkin：

// 超级英雄皮肤
public class SupermanSpecificSkin extends AbstractSkin{
    @Override
    public void display() {
        System.out.println("超人皮肤.....");
    }
}

SougouInput：

// 搜狗输入法
public class SougouInput {

    private AbstractSkin skin;

    public void setSkin(AbstractSkin skin) {
        this.skin = skin;
    }

    public void display() {
        skin.display();
    }
}

Client：

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

        // 1.创建搜狗输入法对象
        SougouInput input = new SougouInput();

        // 2.创建皮肤对象
//        AbstractSkin skin = new SupermanSpecificSkin();
        AbstractSkin skin = new DefaultSpecificSkin();

        // 3.设置皮肤
        input.setSkin(skin);

        // 4.显示皮肤
        input.display();
    }
}

里氏代换原则（LSP）

核心思想

子类对象应该能够替代父类对象出现在程序中的位置，并且程序的行为不会因此受到影响。（一个程序使用父类的对象，那么在不改变程序行为的前提下，子类对象可以替代父类对象）。

实现方式

1. 子类不应该改变父类方法的预期行为，尽量保留父类的方法逻辑。

2. 方法的输入输出应符合父类的契约，子类应遵循父类的行为约定。

3. 使用接口或抽象类设计，可以减少子类对父类的依赖。

4. 确保子类与父类的行为一致性，避免引入错误或不一致的行为。

示例

Quadrilateral

// 四边形接口
public interface Quadrilateral {

    double getLength();
    double getWidth();
}

Rectangle

// 矩形类
public class Rectangle implements Quadrilateral{
    private double length;
    private double width;

    public void setLength(double length) {
        this.length = length;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    @Override
    public double getLength() {
        return length;
    }

    @Override
    public double getWidth() {
        return width;
    }
}

Square

public class Square implements Quadrilateral{

    private double side;

    public double getSide() {
        return side;
    }

    public void setSide(double side) {
        this.side = side;
    }

    @Override
    public double getLength() {
        return side;
    }

    @Override
    public double getWidth() {
        return side;
    }
}

RectangleDemo

public class RectangleDemo {

    public static void main(String[] args) {

        // 1.创建长方形对象
        Rectangle rectangle = new Rectangle();

        // 2.设置长和宽
        rectangle.setLength(20);
        rectangle.setWidth(10);

        // 3.调用扩宽方法
        resize(rectangle);

        // 4.打印长和宽
        printLengthAndWidth(rectangle);
    }

    // 扩宽方法
    public static void resize(Rectangle rectangle){
        while (rectangle.getLength() >= rectangle.getWidth()){
            rectangle.setWidth(rectangle.getWidth() + 1);
        }
    }

    // 打印长和宽
    public static void printLengthAndWidth(Quadrilateral quadrilateral){
        System.out.println("长：" + quadrilateral.getLength() + " 宽：" + quadrilateral.getWidth());
    }

}

依赖倒转原则（DIP）

核心思想：

高层模块（负责实现核心业务逻辑的模块）不应该依赖低层模块（负责实现具体的细节，比如数据存储、网络通信），二者应该依赖抽象。
抽象（接口或抽象类）不应该依赖细节（具体实现类），细节应该依赖抽象。
若没有遵循 DIP，高层模块直接依赖于低层模块，使得两者耦合度变高，且低层模块的变化可能会直接影响到高层模块，从而增加了系统的复杂性和维护难度。
DIP 的关键在于，将高层模块与低层模块之间的依赖关系通过抽象接口或抽象类来分离，从而减少直接耦合，增加系统的灵活性。

示例

CPU

// 抽象CPU接口
public interface CPU {
    // 运行cpu
    void run();
}

HardDisk

// 硬盘接口
public interface HardDisk {

    // 存储数据
    void save(String data);
    // 获取数据
    String get();
}

Memory

// 内存条接口
public interface Memory {

    void save();
}

IntelCpu

// 英特尔CPU
public class IntelCpu implements CPU{
    @Override
    public void run() {
        System.out.println("英特尔CPU运行");
    }
}

XiJieHardDisk

// 希捷硬盘
public class XiJieHardDisk implements HardDisk{
    @Override
    public void save(String data) {
        System.out.println("希捷硬盘保存数据为：" + data);
    }

    @Override
    public String get() {
        System.out.println("希捷硬盘读取数据");
        return "数据";
    }
}

KingstonMemory

// 金士顿内存条
public class KingstonMemory implements Memory{
    @Override
    public void save() {
        System.out.println("金士顿内存条");
    }
}

Computer

public class Computer {

    private HardDisk hardDisk;
    private CPU cpu;
    private Memory memory;

    public HardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public CPU getCpu() {
        return cpu;
    }

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }

    public Memory getMemory() {
        return memory;
    }

    public void setMemory(Memory memory) {
        this.memory = memory;
    }

    // 运行计算机
    public void run() {
        System.out.println("计算机开始运行...");
        String data = hardDisk.get();
        System.out.println("从硬盘中获取数据：" + data);
        cpu.run();
        memory.save();
    }
}

ComputerDemo

public class ComputerDemo {

    public static void main(String[] args) {

        // 1.创建计算机对象
        Computer computer = new Computer();

        // 2.创建计算机组件对象
        HardDisk hardDisk = new XiJieHardDisk();
        CPU cpu = new IntelCpu();
        Memory memory = new KingstonMemory();

        // 3.设置计算机组件
        computer.setHardDisk(hardDisk);
        computer.setCpu(cpu);
        computer.setMemory(memory);

        // 4.运行计算机
        computer.run();
    }
}