开闭原则

对扩展开放，对修改关闭
大概就是你不要改动你已经写好的代码...比如写好的类

里氏代换原则

任何父类出现的地方子类一定可以出现。多用多态。

依赖倒转原则

尽量多依赖于抽象类和接口。抽象类/接口对子类有强制性

接口隔离原则

尽可能依赖于小接口而不是大接口。避免接口的污染，降低耦合度。

迪米特原则 （最少知识原则）

高内聚，低耦合。
一个实体应该尽量少的与其他实体发生相互作用。使系统功能模块相互独立。

合成复用原则

多用组合/聚合，少用继承

设计模式

分为创建型、结构型、行为型
用于固定场合的固定套路。

单例-懒汉 （没用volatile）

public class Singleton {
    private static Singleton singleton;

    private Singleton(){}

    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

普通工厂

用于处理复杂的创建对象场景。

public interface Sender {
    void send();
}

class MailSender implements Sender {

    @Override
    public void send() {
        System.out.println("sending mail");
    }
}

class EmailSender implements Sender {

    @Override
    public void send() {
        System.out.println("sending email");
    }
}

static class SendFactory {
    //当然，我也可以对每种实现类设计一个创建方法。
    public static Sender produce(String type) {
        if ("mail".equals(type)) {
            return new MailSender();
        }
        if ("email".equals(type)) {
            return new EmailSender();
        }
        return null;
    }
}

抽象工厂

public interface Sender {
    void send();
}

interface Provider {
    Sender produce();
}

class MailSender implements Sender {

    @Override
    public void send() {
        System.out.println("sending mail");
    }
}

class EmailSender implements Sender {

    @Override
    public void send() {
        System.out.println("sending email");
    }
}

class MailSenderFactory implements Provider {

    @Override
    public MailSender produce() {
        return new MailSender();
    }
}

class EmailSenderFactory implements Provider {

    @Override
    public Sender produce() {
        return new EmailSender();
    }
}

就是把生产对象做成一个接口，让不同的工厂实现这个接口。用普通工厂模式的话，日后加新的类你要修改你已有的普通工厂。

装饰器模式

public class DecoratorTest {
    public static void main(String[] args) {
        Sourceable sourceable = new Decorator(new Source());
        sourceable.method();
    }
}

interface Sourceable {
    void method();
}

class Source implements Sourceable {

    @Override
    public void method() {
        System.out.println("本源");
    }
}

class Decorator implements Sourceable {

    private Sourceable sourceable;

    public Decorator(Sourceable sourceable) {
        this.sourceable = sourceable;
    }

    @Override
    public void method() {
        sourceable.method();
        System.out.println("装饰");
    }
}

代理模式

//直接new对象，而不是靠传入参数
class Proxy implements Sourceable {

    private Sourceable source;

    public Proxy() {
        this.source = new Source();
    }

    @Override
    public void method() {
        source.method();
        System.out.println("代理");
    }
}

模板方法模式

//让抽象类封装固定流程，子类具体实现。
public class TemplateTest {
    public static void main(String[] args) {
        AbstractCalculator calculator = new Plus();
        int res = calculator.splitExpression("1+1", "\\+");
        System.out.println(res);
    }
}

abstract class AbstractCalculator {
    public abstract int calculate(int a, int b);
    public int splitExpression(String exp, String op) {
        String[] arr = exp.split(op);
        return calculate(Integer.parseInt(arr[0]), Integer.parseInt(arr[1]));
    }
}

class Plus extends AbstractCalculator {

    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

class Minus extends AbstractCalculator {

    @Override
    public int calculate(int a, int b) {
        return a - b;
    }
}