设计原则

五大设计原则：SOLID

单一职责原则（S：SRP(The Single-Responsibility Principle) ）：表示对象应该具有一种单一功能的原则，降低各个功能之间的耦合，保证高内聚、低耦合的功能，就是说对于类和方法，职责应该尽量单一；

// 校验邮箱
const validateEmail = () => {
        return new Promise((resolve, reject) => {
                // todo ...
                resolve(true)
        })
}

// 校验年龄
const validateAge = () => {
        return new Promise((resolve, reject) => {
                // todo ...
                resolve(true)
        })
}

开放-封闭原则（O：OCP(The Open/Closed Principle)：表示“程序中对于扩展开发，对于修改封闭”，一个类或者函数确定其能力之后，便不能再对其原有能力进行修改，只能在其原有功能之上进行扩展新的能力）；

/** 
 * 校验通过走 resolve， 不通过走 reject
*/
const validate = () => {
        return new Promise((resolve, reject) => {
                Promise.all([validateEmail(), validateAge()]).then(res => {
                        console.log('校验成功', res);
                        resolve(true)
                }).catch(err => {
                        console.log('校验失败',err);
                        resolve(err)
                })
        })
}

/** 
 * 提交数据
*/
const submit = async () => {
        // 1. 校验数据
        const pass = await validate()
        console.log('pass', pass);

        if(pass) {
                // 2 提交数据
        }else {
                // todo ...
        }
}

// 增加一种校验
// 校验时间
const validateTime = () => {
        return new Promise((resolve, reject) => {
                // todo ...
                resolve(true)
        })
}

里氏替换原则（L：LSP(The Liskov Substitution Principle) ）：表示“程序中的对象应该是可以在不改变程序正确性的前提下被它的子类所替换”，基类能够使用的地方，子类都可以完全覆盖、替换基类，使用基类和子类都不影响程序的正常运转，功能完全一致，主要强调的就是继承的实现。

class Cat {
        constructor(name) {
                this.name = name;
        }

        eat() {}
}

class BritishShorthair extends Cat {
        constructor(name) {
                super(name);
        }

        eat() {}
}

const animal = new Cat("猫类");
const bs = new BritishShorthair("英短");

const my = {
        pet(p: Cat) { // 限制传递是Cat或者Cat的子类
                console.log(`我的宠物是${p.name}`);
        }
}

接口隔离原则（I：ISP(The Interface Segregation Principle) ）：表示一个接口应该拥有尽可能少的行为，保持其单一独立，避免出现胖接口。对于不同的功能的模块分别使用不同接口，而不是使用同一个通用的接口。

// 不好的例子
public interface IAnimal {
    void run();
    void fly();
    void swim();
}

public class bird implements IAnimal{
    @Override
    public void run() {

    }

    @Override
    public void fly() {
        System.out.println("bird fly");
    }

    @Override
    public void swim() {

    }
}

// 优化
public interface IFlyAnimal {
    void fly();
}

public interface IRunAnimal {
    void run();
}

public class bird implements IFlyAnimal{
    @Override
    public void fly() {
        System.out.println("bird fly");
    }
}

依赖倒置原则（DIP(The Dependency-Inversion Principle)）：高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖于抽象，使用方只关注接口而不关注具体类的实现；

// 一般
public class User {
    public void pay(Course course,Integer payType){
        //获取到课程的价格
        Double price = course.getPrice();
        switch (payType) {
            case 1 -> //支付宝
                    //调用支付宝支付sdk
                    System.out.println("支付宝支付了" + price + "元");
            case 2 ->  //微信支付
                    //调用微信支付sdk
                    System.out.println("微信支付了" + price + "元");
            default -> {
            }
        }
    }

}

// 优化
public interface IPay {
    void pay(Course course);
}

public class AliPay implements IPay{
    @Override
    public void pay(Course course) {
        //调用支付宝支付sdk
        System.out.println("支付宝支付了" + course.getPrice() + "元");
    }
}

public class WeixinPay implements IPay{
    @Override
    public void pay(Course course) {
        //调用微信支付sdk
        System.out.println("微信支付了" + course.getPrice() + "元");
    }
}

public class User {
    public void pay(IPay pay,Course course){
        pay.pay(course);
    }

}

public class Test {
    public static void main(String[] args) {
        User user = new User();
        Course course = new Course(100.0);
        user.pay(new WeixinPay(),course);
        user.pay(new AliPay(),course);
    }
}

另外加两个原则：

迪米特原则（Law of Demeter LoD）是指一个对象应该对其他对象保持最少的了解，又叫最少知道原则（Least Knowledge Principle,LKP）
合成复用原则（Composite/Aggregate Reuse Principle,CARP）是指尽量使用对象组合(has-a)/ 聚合(contanis-a)，而不是继承关系达到软件复用的目的。