设计模式

设计原则

开闭原则

对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。

以搜狗输入法举例

首先创建抽象皮肤类

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

自带默认的皮肤

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

下载的皮肤

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

创建搜狗输入法对象
为输入法设置皮肤

public class SouGouOutput {

    private AbstractSkin abstractSkin;

    public void setAbstractSkin(AbstractSkin abstractSkin) {
        this.abstractSkin = abstractSkin;
    }
    public void display(){
        abstractSkin.display();
    }
}

测试类

public class test {
    public static void main(String[] args) {
        //创建搜狗对象
        SouGouOutput souGouOutput = new SouGouOutput();

        //创建默认皮肤 只需要调整此处代码即可完成皮肤调换
        //DownloadSkin downloadSkin=new DownloadSkin();
        DefaultSkin defaultSkin = new DefaultSkin();

        //设置搜狗皮肤
        souGouOutput.setAbstractSkin(defaultSkin);

        //展示
        souGouOutput.display();
    }
}

里氏代换原则

里氏代换原则中，任何父类可以出现的地方，子类一定可以出现。只有当子类可以替换掉父类，且软件单位的功能不受到影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。

里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化，而父类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

// 父类：形状（Shape）
public class Shape {
    public int getArea() {
        return 0; // 形状具有面积
    }
}

// 子类：圆形（Circle），继承自形状（Shape）
public class Circle extends Shape {
    private int radius;

    public Circle(int radius) {
        this.radius = radius;
    }

    @Override
    public int getArea() {
        // 计算圆形的面积
        return (int) (Math.PI * Math.pow(radius, 2));
    }
}

// 子类：正方形（Square），继承自形状（Shape）
public class Square extends Shape {
    private int side;

    public Square(int side) {
        this.side = side;
    }

    @Override
    public int getArea() {
        // 计算正方形的面积
        return side * side;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 使用父类类型的变量引用子类对象
        Shape shape = new Shape(); // 这里原本是Shape，但我们可以替换为任何Shape的子类对象
        System.out.println("Area of Shape: " + shape.getArea());

        // 替换为Circle对象
        shape = new Circle(5);
        System.out.println("Area of Circle: " + shape.getArea());

        // 替换为Square对象
        shape = new Square(4);
        System.out.println("Area of Square: " + shape.getArea());
    }
}

依赖倒转原则

这个原则是开闭原则的基础，具体内容：针对接口编程，依赖于抽象而不依赖于具体。

// 抽象接口
public interface Vehicle {
    void drive();
}

// 具体实现类：自行车
public class Bicycle implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Bicycle is driven by pedaling.");
    }
}

// 具体实现类：汽车
public class Car implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Car is driven with engine.");
    }
}

// 客户端代码，依赖于抽象接口
public class Client {
    public static void main(String[] args) {
        // 高层模块通过抽象接口与低层模块交互
        Vehicle vehicle1 = new Bicycle();
        Vehicle vehicle2 = new Car();

        driveVehicle(vehicle1); // 通过抽象接口调用方法，细节被隐藏
        driveVehicle(vehicle2); // 同样通过抽象接口调用方法
    }

    public static void driveVehicle(Vehicle vehicle) {
        vehicle.drive();
    }
}

接口隔离原则

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。它还有另外一个意思是：降低类之间的耦合度。它强调降低依赖，降低耦合。

// 一个庞大的接口，违反了接口隔离原则
public interface OldControl {
    void start();
    void stop();
    void zoomIn();
    void zoomOut();
    // ... 其他方法 ...
}

// 一个类实现了OldControl接口
public class OldRemoteControl implements OldControl {
    public void start() {
        // 启动操作
    }

    public void stop() {
        // 停止操作
    }

    public void zoomIn() {
        // 放大操作
    }

    public void zoomOut() {
        // 缩小操作
    }

    // ... 实现其他方法 ...
}

// 改进后的接口，遵循接口隔离原则
public interface Control {
    void start();
    void stop();
}

public interface Zoom {
    void zoomIn();
    void zoomOut();
}

// 一个类实现了Control接口
public class NewRemoteControl implements Control {
    public void start() {
        // 启动操作
    }

    public void stop() {
        // 停止操作
    }
}

// 另一个类同时实现了Zoom接口
public class AdvancedRemoteControl implements Zoom {
    public void zoomIn() {
        // 放大操作
    }

    public void zoomOut() {
        // 缩小操作
    }
}

迪米特法则

最少知道原则是指：一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

// 一个类，违反了迪米特法则
public class School {
    public void showStudents() {
        for (Student student : students) {
            student.showDetails(); // 直接访问Student的内部方法
        }
    }

    private List<Student> students = new ArrayList<>();
}

// 一个类，遵循迪米特法则
public class School {
    public void showStudents() {
        for (Student student : students) {
            student.showStudentInfo(); // 只通过公共方法交互
        }
    }

    private List<Student> students = new ArrayList<>();
}

public class Student {
    public void showStudentInfo() {
        System.out.println("Student info: " + getName());
    }

    private void showDetails() {
        // 这里包含了一些不应该被外部直接访问的私有信息
        System.out.println("Details: " + getName() + ", " + getAge());
    }

    public String getName() {
        return "Student Name";
    }

    private int getAge() {
        return 20;
    }
}

合成复用原则

合成复用原则是指：尽量使用合成/聚合的方式，而不是使用继承。

// 一个抽象类，表示图形对象的共同行为
public abstract class GraphicObject {
    public abstract void draw();
}

// 一个具体的图形类，表示圆形
public class Circle extends GraphicObject {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

// 一个具体的图形类，表示矩形
public class Rectangle extends GraphicObject {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

// 一个组合类，表示由多个图形对象组成的复杂图形
public class CompositeGraphic extends GraphicObject {
    private List<GraphicObject> objects = new ArrayList<>();

    public void addObject(GraphicObject object) {
        objects.add(object);
    }

    public void removeObject(GraphicObject object) {
        objects.remove(object);
    }

    @Override
    public void draw() {
        for (GraphicObject object : objects) {
            object.draw(); // 通过组合的方式复用图形对象
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建单个图形对象
        Circle circle = new Circle();
        Rectangle rectangle = new Rectangle();

        // 使用组合的方式创建复杂图形
        CompositeGraphic composite = new CompositeGraphic();
        composite.addObject(circle);
        composite.addObject(rectangle);

        // 绘制复杂图形
        composite.draw(); // 输出：Drawing a circle. Drawing a rectangle.
    }
}

设计模式的学习