设计模式原则

单一职责原则，就是一个类只负责做一件事情。这样就可以做到解耦合的效果，让代码看起来比较清爽，也体现了java的封装性。还有个原则叫迪米特法则，就是一个对象对另一个对象有尽量少的了解，说的也是解耦合的事情。
里氏替换原则和依赖导致原则，说的是继承的事情。父类可以做的事情，子类都可以去做，子类可以尽量去依赖父类去做事情；但是反过来，父类不能依赖子类去做一些事情。体现了java的继承特性。
接口隔离原则，接口也应该尽可能的隔离开来。其实类写多了，的确耦合性低，为了让他们交流起来，用的最多的就是接口，毕竟只需要知道做什么，怎么做，去访问那个具体的类吧。
开闭原则，对修改关闭，对拓展开放。就是代码需要有很好的延展性，对原有代码结构不能破坏。

Java设计模式

单例模式


/**
 * 双重校验
 * 对懒汉式单例模式做了线程安全处理增加锁机制
 * volatile变量级
 * synchronized 类级
 */
public class DoubleCheckSingleton {
    //特点一 静态私有变量，增加volatile变量级锁
    private static volatile DoubleCheckSingleton instance;
    //特点二 构造函数私有
    private DoubleCheckSingleton(){

    }
    //特点三 双重null判断  synchronized类级锁
    public static DoubleCheckSingleton getInstance(){
        if (instance == null){
            synchronized(DoubleCheckSingleton.class){
                if (instance == null){
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

简单工厂模式

这个用的比较少，就是有个工厂，告诉你我要什么东西，你造好了给我就行。比如说：

public interface Ball {
    public String create();
}
public class Soccer implements Ball {
    @Override
    public String create() {
        return "give you a soccer";
    }
}
public class BasketBall implements Ball {
    @Override
    public String create() {
        return "give you a basketBall";
    }
}
public class EasyBallFactory  {
    public static Ball createBall(String name){
        if (name.equals("basketball")){
            return new BasketBall();
        }else if(name.equals("soccer")){
            return new Soccer();
        }else {
            return null;
        }
    }
    public static void main(String[] args) {
        Ball soccer = EasyBallFactory.createBall("soccer");
        Ball basketBall = EasyBallFactory.createBall("basketball");
        System.out.println(soccer.create()); //give you a soccer
        System.out.println(basketBall.create()); //give you a basketBall
    }
}

工厂模式

这个其实和简单工厂模式差不太多，就是将工厂继续拆分，比如说刚刚EasyBallFactory是一个总工厂，
我们现在拆分成SoccerFactory和BasketBallFactory分别生产足球和篮球。某个工厂内部可以根据需求生产不同的产品，比如说soccer可以生产不同大小的出来。

public interface BallFactory {
    public Ball create();
}

public class SoccerFactory implements BallFactory {
    @Override
    public Ball create() {
        //do something
        return null;
    }
}

public class BasketBallFactory implements BallFactory {
    @Override
    public Ball create() {
        //do something
        return null;
    }
}

抽象工厂模式

抽象工厂模式主要设计产品组的概念，就是某一个工厂生产出配套的一系列产品。例如，在生产足球的同时，SoccerFactory还可以生产与之配套的足球杂志。

public interface Journal {
    public String create();
}
public class SoccerJournal implements Journal{
    @Override
    public String create() {
        return "give you a Soccer Journal...";
    }
}
public class SoccerFactory implements BallFactory {
    @Override
    public Ball create() {
        return new Soccer();
    }
    public Journal createJournal(){
        return new SoccerJournal();
    }
}

建造者模式

将一个复杂对象分布创建。如果一个超大的类的属性特别多，我们可以把属性分门别类，不同属性组成一个稍微小一点的类，
再把好几个稍微小点的类窜起来。比方说一个电脑，可以分成不同的稍微小点的部分CPU、主板、显示器。CPU、主板、显示器分别有更多的组件，不再细分。

@Data
public class Computer{
    private CPU cpu;//cpu 是个接口，有不同实现如InterCPU AMDCPU 等等
    private MainBoard mainBoard;//mainBoard 是个接口，有不同的实现
    private DisPlayer disPlayer;//disPlayer 是个接口，有不同的实现
}

public abstract class Builder { 
    abstract void buildCPU(); 
    abstract void buildMainBoard(); 
    abstract void buildDisPlayer(); 
    abstract Computer createComputer(); 
} 

public class XiaoMiBuilder extends Builder{
    private Computer computer = new Computer();
    @Override
    void buildCPU() {
        computer.setCpu(new InterCPU());
    }
    @Override
    void buildMainBoard() {
        computer.setMainBoard(new AMainBoard());
    }
    @Override
    void buildDisPlayer() {
        computer.setDisPlayer(new ADisPlayer());
    }
    @Override
    Computer createComputer() {
        return computer;
    }
}

SpringBoot实现了0配置，几乎所有的配置都写到了java代码中，大量的配置不得不让配置类采用建造者模式，这样层次比较清晰。

上面的设计模式可以帮助我们非常优雅的创建出来对象，下面看几个对象关系之间的模型。

代理模式

Spring的AOP用的是动态代理，何为动态不看了，用过Spring的小伙伴都知道吧。单纯看一下最基础代理模式是什么样的。
代理就是，一个对象辅助另一个对象去做某件事，同时还可以增加一点辅助功能。
例如，你买车，的确是你花钱把车买到了，但是你不可能直接去和厂家谈吧，你应该通过4S店购买，同时4S店帮助你入保险扣税等操作，最终你才得到了你想要的车。

public interface Buy {
    public void buyCar();
}
public class People implements Buy {
    @Override
    public void buyCar() {
        System.out.println("you get a car");
    }
}
public class ProxyPeople implements Buy{
    private People people;
    public ProxyPeople(People people){
        this.people=people;
    }
    @Override
    public void buyCar() {
        System.out.println("4s店帮你纳税、上保险...");
        people.buyCar();
    }
    public static void main(String[] args) {
        Buy buy = new ProxyPeople(new People());
        buy.buyCar();
    }
}
输出：
4s店帮你纳税、上保险...
you get a car

桥接模式

就是用于抽象化和实现化的解耦。又是解耦，貌似设计模式就是教我们如何优雅的解耦。
提高了代码的拓展性，并且可以实现代码的动态切换。最开始的Ball、Soccer、BasketBall接着用，增加新的类.

public  class BallCut {
    private Ball ball;
    public Ball getBall() {
        return ball;
    }
    public void setBall(Ball ball) {
        this.ball = ball;
    }
    public void create(){
         System.out.println(ball.create());
    }
    public static void main(String[] args) {
        BallCut ballCut = new BallCut();
        ballCut.setBall(new Soccer());
        ballCut.create(); //give you a soccer
        ballCut.setBall(new BasketBall());
        ballCut.create(); //give you a basketBall
    }
}