1.使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。
2.设计模式使代码编制真正工程化，设计模式是软件工程的基石。
3.总共有23种设计模式。这些模式可以分为三大类：
3-1：创建型模式（Creational Patterns）
3-2：结构型模式（Structural Patterns）
3-3：行为型模式（Behavioral Patterns）

1、设计模式六大原则

1.单一职责类原则：就是一个类只负责一个业务职责。

比如现在有一个用户类，用户类是负责用户的查询、修改等关于用户的操作的。现在又新增一个订单服务，你
完全可以把订单业务也扩展到用户类中实现。此时用户类就对外提供用户服务和订单服务，违背了单一职
责类原则。合理的解决办法是新创建一个订单类，每个类只负责一个业务职责。



2.里氏替换原则：子类可在扩展自身的功能，尽量不要去重写父类原有的功能。


3.依赖倒置原则：面向接口编程

4.接口隔离原则：接口设计粒度尽量细粒化。

不要一个接口既对外提供用户服务同时也对外提供订单服务，保证每个接口最小功能单元。

5.迪米特法则：降低代码耦合（局部变量耦合）

不要在一个方法中，直接定义对象的引用new对象（A a = new A）,将对象的引用定义到全局变量中
，在需要的地方通过new构建。

6.开闭原则：不要在已完成的业务类中，新增其他无关这业务类的服务，可以重新创建类，完成新增业务服务

2、抽象工厂模式

1.抽象工厂模式


凡是出现了大量的对象需要创建，并且对象具有共同的接口时，可以通过工厂方法模式进行创建。


原则：
1、解耦，把对象的创建和使用的过程分开。
2、工厂负责对象的创建，黑盒创建。
3、面向接口编程，使用者只管使用，只知接口不知道具体实现类。

实现方式：
创建一个工厂接口，创建返回不同对象的工厂接口实现类。
1.定义蔬菜抽象类

package org.example.vegetables;

/**
 * 定义一个蔬菜抽象类
 */
public abstract class Vegetables {

    public abstract void show();
}


2.定义黄瓜特定对象类

package org.example.vegetables;

public class Cuke extends Vegetables{
    @Override
    public void show() {
        System.out.println("我是黄瓜");
    }
}


3.定义南瓜特定对象类

package org.example.vegetables;

public class Pumpkin extends Vegetables{
    @Override
    public void show() {
        System.out.println("我是南瓜");
    }
}
1.定义蔬菜工厂接口


package org.example.vegetables.service;


import org.example.vegetables.Vegetables;

/**
 * 蔬菜工厂接口
 */
public interface VegetablesFactory {

  public Vegetables getVegetables();
}



2.定义黄瓜工厂实现类


package org.example.vegetables.service.imp;

import org.example.vegetables.Cuke;
import org.example.vegetables.Vegetables;
import org.example.vegetables.service.VegetablesFactory;

/**
 * 黄瓜工厂实现类
 */
public class CukeVegetablesFactory implements VegetablesFactory {
    @Override
    public Vegetables getVegetables() {
        return new Cuke();
    }
}



3.定义南瓜工厂实现类

package org.example.vegetables.service.imp;

import org.example.vegetables.Pumpkin;
import org.example.vegetables.Vegetables;
import org.example.vegetables.service.VegetablesFactory;

/**
 * 南瓜工厂实现类
 */
public class PumpkinVegetablesFactory implements VegetablesFactory {
    @Override
    public Vegetables getVegetables() {
        return new Pumpkin();
    }
}
package org.example.vegetables.service;

import org.example.vegetables.Vegetables;
import org.example.vegetables.service.imp.CukeVegetablesFactory;
import org.junit.Test;

public class VegetablesRun {

    private VegetablesFactory vegetablesFactory;

    @Test
    public void onVegetablesFactoryShow(){
        //根据黄瓜工厂子类 获取黄瓜对象
        vegetablesFactory = new CukeVegetablesFactory();
        Vegetables vegetables = vegetablesFactory.getVegetables();
        vegetables.show();
    }
}

3、单例

饿汉式

public class HungryDemo {

    private HungryDemo(){}

    private static HungryDemo hungryDemo = new HungryDemo();

    public static HungryDemo getInstance(){

        return hungryDemo;
    }
}
懒汉式--线程安全


public class LazyDemo {

    private LazyDemo(){}

    private static volatile LazyDemo lazyDemo = null;

    public static LazyDemo getInstance(){
        if(lazyDemo == null){
           synchronized (LazyDemo.class){
             if(null == lazyDemo){
                lazyDemo = new LazyDemo();
             }
           }
       }
       return lazyDemo; 
    }


    public static void main(String[] args) {
      while (true){
          new Thread(new Runnable() {
              @Override
              public void run() {
                  System.out.println(LazyDemo.getInstance());
              }
          }).start();
      }
    }
}