3.设计原则

3.1 目的

提高软件系统可维护性与可复用性
增加软件可扩展性与灵活性
节约开发成本与维护成本

3.2 开闭原则

3.2.1 特点

对扩展开放，对修改关闭
使用接口及抽象类
若需要直接派生实现类即可

3.2.2 案例(搜狗皮肤更换功能)

抽象类代码

public abstract class AbstractSkin {  
    public abstract void display();  
}

默认皮肤代码

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

自定义皮肤代码

public class mySkin extends AbstractSkin{  
    @Override  
    public void display() {  
        System.out.println("我的皮肤");  
    }  
}

输入法对象代码

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

测试代码

    public static void main(String[] args) {  
//        创建对象  
        souGouInput souGouInput = new souGouInput();  
//        创建皮肤对象  
//        defaultSkin defaultSkin = new defaultSkin();  
        mySkin mySkin = new mySkin();  
//        加载皮肤  
//        souGouInput.setSkin(defaultSkin);  
            souGouInput.setSkin(mySkin);  
//        使用皮肤,更改皮肤不需要改皮肤代码，只需要额外创建派生皮肤并加载进去即可
        souGouInput.display();  
    }

关系图如图![[Pasted image 20221226163048.png]]

3.3 里氏代换原则

3.3.1 特点

子类可以扩展父类功能，但不能改变原有父类功能

3.3.2 案例(正方形不是长方形)

3.3.2.1 正方形不是长方形子类

长方形类：两个属性，宽度和高度；正方形类：一个属性，边
设定一个resize方法，一直增加长方形的宽度，直到增加到宽度超过高度才可以
若子类正方形的对象调用resize方法，这个方法会导致正方形的边不断地增加下去，直到溢出为止，违反里氏代换原则

3.3.2.2 解决

四边形接口代码

public interface Quadrilateral {  
    double getLength();  
    double getWidth();  
}

长方形实现类代码

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;  
    }  
}

正方形实现类代码

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;  
    }  
}

测试代码

public class test {  
    public static void main(String[] args) {  
//        创建长方形对象  
        Rectangle r = new Rectangle();  
        r.setLength(20);  
        r.setWidth(10);  
//        调用扩宽  
        resize(r);  
        printMessage(r);  
    }  
    //    扩宽  
    public static void resize(Rectangle r)  
    {  
//        若长比宽大，使宽增长  
        while(r.getLength() > r.getWidth())  
        {  
            r.setWidth(r.getWidth()+1);  
        }  
    }  
    public static void printMessage(Quadrilateral q)  
    {  
        System.out.println(q.getLength());  
        System.out.println(q.getWidth());  
    }  
}

3.4 依赖倒转原则

3.4.1 特性

高层模块和底层模块均依赖于抽象
细节依赖抽象
对抽象编程

3.4.2 案例(组装电脑)

CPU接口及实现类代码

public interface CPU {  
//    运行CPU  
    public void run();  
}

public class InterlCPU implements CPU  
{  
    @Override  
    public void run() {  
        System.out.println("使用IntelCPU ");  
    }  
}

Memory接口及实现类代码

public interface Memory {  
    public void save();  
}

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

HardDisk接口及实现类代码

public interface HardDisk {  
//    存储数据  
    public void save(String data);  
    public String get();  
}

public class XiShuHardDisk implements HardDisk{  
    @Override  
    public void save(String data) {  
        System.out.println("使用西数硬盘存储数据为："+data);  
    }  
    @Override  
    public String get() {  
        System.out.println("从西数硬盘获取数据");  
        return "数据";  
    }  
}

Computer类代码

public class Computer {  
    public CPU cpu;  
    public Memory memory;  
    public 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 HardDisk getHardDisk() {  
        return hardDisk;  
    }  
    public void setHardDisk(HardDisk hardDisk) {  
        this.hardDisk = hardDisk;  
    }  
//    运行计算机  
    public  void run()  
    {  
        System.out.println("运行计算机");  
        String data = hardDisk.get();  
        System.out.println("从硬盘获取数据为：" + data);  
        cpu.run();  
        memory.save();  
    }  
}

测试类代码

public class test {  
    public static void main(String[] args) {  
//        创建组件对象  
        HardDisk hardDisk = new XiShuHardDisk();  
        CPU cpu = new InterlCPU();  
        Memory memory = new KingStonMemory();  
//        创建计算机对象  
        Computer computer = new Computer();  
//        组装  
        computer.setCpu(cpu);  
        computer.setHardDisk(hardDisk);  
        computer.setMemory(memory);  
//        运行  
        computer.run();  
    }  
}