【设计模式】02 软件设计五大原则

清疚 2022-02-17 06:36 198阅读 0赞

# 开闭原则 #

## 定义 ##

一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。

*  用抽象构建框架，用实现扩展细节

## 优点 ##

*  提高软件系统的可复用性及可维护性

## 代码实现 ##

课程接口 `ICourse`

public interface ICourse {
        Integer getId();
        String getName();
        Double getPrice();
    }

Java 课程 `JavaCourse`

public class JavaCourse implements ICourse {
        private Integer id;
        private String name;
        private Double price;
    
        public JavaCourse(Integer id, String name, Double price) {
            this.id = id;
            this.name = name;
            this.price = price;
        }
    
        public Integer getId() {
            return this.id;
        }
    
        public String getName() {
            return this.name;
        }
    
        public Double getPrice() {
            return this.price;
        }
    }

Java 打折课程 `JavaDiscountCourse`

public class JavaDiscountCourse extends JavaCourse {
    
        public JavaDiscountCourse(Integer id, String name, Double price) {
            super(id, name, price);
        }
    
        public Double getOriginPrice() {
            return super.getPrice();
        }
    
        @Override
        public Double getPrice() {
            return super.getPrice() * 0.8;
        }
    }

测试类 `Test`

public class Test {
        public static void main(String[] args) {
            ICourse iCourse = new JavaDiscountCourse(96, "Java从零到企业级电商开发", 348d);
            JavaDiscountCourse javaCourse = (JavaDiscountCourse) iCourse;
            System.out.println("课程ID: " + javaCourse.getId() + " 课程名字: " + javaCourse.getName() + "课程原价: " + javaCourse.getOriginPrice() + " 课程价格: " + javaCourse.getPrice());
        }
    }

# 依赖倒置原则 #

## 定义 ##

高层模块不应该依赖底层模块，二者都应该依赖其抽象

*  抽象不应该依赖细节，细节应该依赖抽象
 *  针对接口编程，不要针对实现编程

## 优点 ##

*  可以减少类间的耦合性
 *  提高系统稳定性
 *  提高代码可读性和可维护性
 *  可降低修改程序所造成的风险

## 代码实现 ##

课程 `ICourse`

public interface ICourse {
        void studyCourse();
    }

Java 课程 `JavaCourse`

public class JavaCourse implements ICourse {
        public void studyCourse() {
            System.out.println("Yuu 正在学习 Java 课程");
        }
    }

FE 课程 `FECourse`

public class FECourse implements ICourse {
        public void studyCourse() {
            System.out.println("Yuu 正在学习 FE 课程");
        }
    }

Python 课程 `PythonCourse`

public class PythonCourse implements ICourse {
        public void studyCourse() {
            System.out.println("Yuu 正在学习 Python 课程");
        }
    }

`Yuu`

public class Yuu {
        private ICourse iCourse;
        public void setiCourse(ICourse iCourse) {
            this.iCourse = iCourse;
        }
        public void studyImoocCourse() {
            iCourse.studyCourse();
        }
    }

`Test`

public class Test {
        public static void main(String[] args) {
            Yuu yuu = new Yuu();
            yuu.setiCourse(new JavaCourse());
            yuu.studyImoocCourse();
            yuu.setiCourse(new FECourse());
            yuu.studyImoocCourse();
            yuu.setiCourse(new PythonCourse());
            yuu.studyImoocCourse();
        }
    }

# 单一职责原则 #

## 定义 ##

不要存在多余一个导致类变更的原因

*  一个类/接口/方法只负责一项职责

## 优点 ##

*  降低类的复杂性
 *  提高类的可读性
 *  提高系统的可维护性
 *  降低变更引起的风险

## 代码实现 ##

`FlyBird`

public class FlyBird {
        public void mainMoveMode(String birdName) {
            System.out.println(birdName + "用翅膀飞");
        }
    }

`WalkBird`

public class WalkBird {
        public void mainMoveMode(String birdName) {
            System.out.println(birdName + "用脚走");
        }
    }

`Test`

public class Test {
        public static void main(String[] args) {
            FlyBird flyBird = new FlyBird();
            flyBird.mainMoveMode("大雁");
            WalkBird walkBird = new WalkBird();
            walkBird.mainMoveMode("鸵鸟");
        }
    }

# 接口隔离原则 #

## 定义 ##

用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口

*  一个类对一个类的依赖应该建立在最小的接口上
 *  建立单一接口，不要建立庞大臃肿的接口
 *  尽量细化接口，接口中的方法尽量少
 *  注意适度原则，一定要适度

## 优点 ##

*  符合高内聚低耦合的设计思想
 *  类具有很好的可读性、可扩展性和可维护性

## 代码实现 ##

`IEatAnimalAction`

public interface IEatAnimalAction {
        void eat();
    }

`IFlyAnimalAction`

public interface IFlyAnimalAction {
        void fly();
    }

`ISwimAction`

public interface ISwimAction {
        void swim();
    }

`Bird`

public class Bird implements IEatAnimalAction, IFlyAnimalAction {
        public void eat() {
    
        }
    
        public void fly() {
    
        }
    }

`Dog`

public class Dog implements ISwimAction, IEatAnimalAction {
        public void eat() {
    
        }
    
        public void swim() {
    
        }
    }

# 迪米特原则 #

## 定义 ##

一个对象应该对其他对象保持最少的了解。又叫最少知道原则

*  尽量降低类与类之间的耦合
 *  强调只和朋友交流，不和陌生人说话
 *  `朋友`: 出现在成员变量、方法的输入、输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。

## 优点 ##

*  降低类之间的耦合

## 代码实现 ##

`Boss`

public class Boss {
        public void commandCheckNumber(TeamLeader teamLeader) {
            teamLeader.checkNumberOfCourse();
        }
    }

`Course`

public class Course {
    }

`TeamLeader`

public class TeamLeader {
        public void checkNumberOfCourse() {
            List<Course> courseList = new ArrayList<Course>();
            for (int i = 0; i < 20; i++) {
                courseList.add(new Course());
            }
            System.out.println("在线课程的数量是: " + courseList.size());
        }
    }

`Test`

public class Test {
        public static void main(String[] args) {
            Boss boss = new Boss();
            TeamLeader teamLeader = new TeamLeader();
            boss.commandCheckNumber(teamLeader);
        }
    }