工厂设计模式

不要在业务代码中自己创建对象，用工厂类创建对象，目标就是解耦

  1. /**
  2.  * 定义接口
  3.  */
  4. interface  Car {
  5.     public void getCar();
  6. }
  8. /**
  9.  * 定义子类实现接口
  10.  */
  11. public class BMW implements Car{
  13.     @Override
  14.     public void getCar() {
  15.         System.out.printf("来一辆BMW！");
  16.     }
  17. }
  19. /**
  20.  * 工厂类创建对象
  21.  */
  22. public class CarFactor {
  24.     public static Car carFactor(Class<?> tClass){
  26.             return new BMW();    
  27.     }
  28. }
  30. /**
  31.  * 运用工厂创建对象
  32.  */
  33. public class testFactory {
  35.     public static void main(String[] args) {
  36.         Car car = CarFactor.carFactor(BYD.class);
  37.         car.getCar();
  38.     }
  39. }

策略设计模式

把业务代码中的if else替换，降低耦合，使业务代码变得优雅。

  1. /**
  2.  * 定义接口
  3.  */
  4. interface  Car {
  5.     public void getCar();
  6. }
  8. /**
  9.  * 定义子类实现接口
  10.  */
  11. public class BMW implements Car{
  13.     @Override
  14.     public void getCar() {
  15.         System.out.printf("来一辆BMW！");
  16.     }
  17. }
  19. /**
  20.  * 定义子类实现接口
  21.  */
  22. public class BYD implements Car {
  23.     @Override
  24.     public void getCar() {
  25.         System.out.printf("来一辆BYD！");
  26.     }
  27. }
  29. /**
  30.  * 工厂类创建对象
  31.  */
  32. public class CarFactor {
  34.     public static Car carFactor(Class<?> tClass){
  35.         if (tClass.getName().equals(BMW.class.getName())){
  36.             return new BMW();
  37.         }else
  38.         if (tClass.getName().equals(BYD.class.getName())){
  39.             return new BYD();
  40.         }else
  41.         return null;
  42.     }
  43. }
  45. /**
  46.  * 运用工厂创建对象
  47.  */
  48. public class testFactory {
  50.     public static void main(String[] args) {
  51.         Car car = CarFactor.carFactor(BYD.class);
  52.         car.getCar();
  53.     }
  54. }

模板设计模式

  • 应用场景
    • 当子类中的方法有相同的执行逻辑，且子类的方法必须执行该逻辑，就可以用到模板设计模式（例如：当我们到ATM机上取钱，插卡，输入密码，取卡，这几个步骤是必不可少的，我们就可以把这几个步骤设计成模板，强制子类必须执行）。
  • 实现步骤
    • 定义一个接口，接口中定义一个方法；
    • 定义一个抽象类，实现这个接口并重写接口中的方法，在抽象类中定义插卡，输入密码，取卡的方法，而抽象类的子类只需要实现自己特有的方法就行。
  • demo实现 ```java public class BrandATM { public static void main(String[] args) { BrandMoBan brandMoBan = new QuQian(); brandMoBan.yeWu(); System.out.println(“==================”); BrandMoBan brandMoBan1 = new ChaXunYuE(); brandMoBan1.yeWu(); System.out.println(“==================”); BrandMoBan brandMoBan2 = new ChaXunAndQuQian(); brandMoBan2.yeWu(); } }

/**

  • 定义接口 */ interface BrandMoBan { void yeWu(); }

/**

  • 定义抽象类实现接口 */ abstract class AbstractBrandMoBan implements BrandMoBan { //业务流程方法 @Override public void yeWu() {

    1.  this.chaKa();
    2.  this.inputPassword();
    3.  this.chaXunYuE();
    4.  this.quQian();
    5.  this.quKa();

    }

    /**

    • 查询余额 / protected abstract void chaXunYuE(); /*

    • 取钱 */ public abstract void quQian();

      /**

    • 取卡 / private final void quKa() { System.out.println(“取卡”); } /*
    • 输入密码 / public static final void inputPassword() { System.out.println(“输入密码！”); } /*
    • 插卡 */ private final void chaKa() { System.out.println(“插卡”); } }

/**

  • 只取钱
  • 重写父类所有抽象方法 */ class QuQian extends AbstractBrandMoBan { @Override protected void chaXunYuE() { } @Override public void quQian() {
    1.  System.out.println("取钱");
    2.  AbstractBrandMoBan.inputPassword();
    } }

/**

  • 只查询余额

  • 重写父类所有抽象方法 */ class ChaXunYuE extends AbstractBrandMoBan { @Override public void chaXunYuE() {

    1.  System.out.println("查询余额");

    }

    @Override public void quQian() { } }

/**

  • 查询余额并取钱

  • 重写父类所有抽象方法 */ class ChaXunAndQuQian extends AbstractBrandMoBan { @Override public void chaXunYuE() {

    1.  System.out.println("查询余额");

    }

    @Override public void quQian() {

    1.  System.out.println("取钱");
    2.  AbstractBrandMoBan.inputPassword();

    } }

执行结果： 插卡 输入密码！ 取钱 输入密码！

  1. 取卡

================== 插卡 输入密码！ 查询余额

  1. 取卡

================== 插卡 输入密码！ 查询余额 取钱 输入密码！ 取卡

  1. ```java
  2. public class DesignModeDemo {
  3.     public static void main(String[] args) {
  5.         doSortArray sortStrategy = SortStrategyFacotry.getSortStrategy(discount);
  6.         sortStrategy.sort(arr);
  8.     }
  10.     public interface doSortArray {
  11.           void sort(int [] arr);
  12.     }
  14.     public static abstract class AbstractSort implements doSortArray{
  15.         //定义出来一套模板
  16.         @Override
  17.         public void sort(int[] arr) {
  18.             //咱们先普通排序
  19.             doCommentSort(arr);
  20.             //咱们得特殊排序
  21.             doSpeciaSort(arr);
  22.             //再进行打印
  23.             doCommentPrint(arr);
  24.         }
  26.         protected  void doCommentPrint(int[] arr){
  27.             System.out.println(Arrays.toString(arr));
  28.         }
  30.         protected abstract void doSpeciaSort(int[] arr);
  32.         // 普通排序
  33.         protected  void doCommentSort(int[] arr){
  34.             Arrays.sort(arr);
  35.         }
  36.     }
  39.     /*
  40. 子类继承抽象类重写抽象方法，实现子类特有逻辑
  41. */
  42.     public static class  NomalSort extends AbstractSort{
  43.         //普通排序由于父类已经把这个模板流程固定下来了，而且已经进行了排序
  44.         @Override
  45.         protected void doSpeciaSort(int[] arr) {
  46.             // doNothing
  47.         }
  48.     }
  49. /*
  50. 子类继承抽象类重写抽象方法，实现子类特有逻辑
  51. 特殊排序
  52. */
  53.     public static class SpeciaSort extends AbstractSort{
  55.         @Override
  56.         protected void doSpeciaSort(int[] arr) {
  57.             //[1 ,2 ,3, 6, 7, 8, 9] source
  58.             //[1, 3, 7, 9, 8, 6, 2] target
  59.             int incrNum = 0;
  60.             int lastNum = arr.length -1;
  61.             int [] targetArr = new int[arr.length];
  62.             for (int i = 0; i < arr.length; i++) {
  63.                 if(i % 2 ==0){
  64.                     // 第一位
  65.                     targetArr[incrNum]  =  arr[i];
  66.                     incrNum ++;
  67.                 }else{
  68.                     //第二位
  69.                     targetArr[lastNum]  =  arr[i];
  70.                     lastNum --;
  71.                 }
  72.             }
  74.             for (int i = 0; i < arr.length; i++) {
  75.                 arr[i]  = targetArr[i];
  76.             }
  77.         }
  78.     }
  79. /*
  80. 用工厂创建对象
  81. */
  82.     public static class SortStrategyFacotry{
  84.         public static doSortArray getSortStrategy(int discount){
  85.             if(discount == 0){
  86.                  //普通排序
  87.                   return new NomalSort();
  88.             }else{
  89.                 // 特殊排序
  90.                 return new  SpeciaSort();
  92.             }
  93.         }
  94.     }
  95. }

状态设计模式

构造器设计模式

命令设计模式

组合设计模式

装饰者设计模式

  • 作用：
    • 在不影响原始目标类的情况下，对原始目标类的功能进行增强 ```java
  1. // 接口
  2. public interface  Component{
  3.     void execute();
  4. }
  7. public static class ConcreateComponent implements Component{
  8.     @Override
  9.     public void execute() {
  10.         System.out.println("我要吃饭");
  11.     }
  12. }
  14. // 1、装饰类需要和原始目标类实现相同得接口
  15. // 2、装饰类要缓存原始目标类得 对象
  16. //装饰类 ---> 对原来的那个接口进行增强
  18. public static class Decorator implements Component{
  19.     private ConcreateComponent  concreateComponent;
  20.     public Decorator(ConcreateComponent concreateComponent){
  21.         this.concreateComponent = concreateComponent;
  22.     }
  23.     @Override
  24.     public void execute() {
  25.         System.out.println("吃饭之前洗洗手");
  26.         concreateComponent.execute();
  27.         System.out.println("吃完之后洗洗手");
  28.     }
  29. }

public class WithDecoratorDesignMode2 { public static void main(String[] args) { Component component = new Decorator(new ConcreateComponent()); component.execute(); }

}

  1. <a name="fHLtJ"></a>
  2. ### 单例设计模式
  4. - 原理：一个对象在项目中只创建了一个
  5. - 使用场景：这个项目中有一个对象从始至终都是同一个，但这个对象我们又不想交给spring帮我们管理
  6.    - 饿汉式：一上来就通过成员变量创建对象，把构造方法私有化，不让别人通过构造方法创建对象
  7.    - 懒汉式：只有使用到的时候才创建对象，同样把构造方法私有化
  8. ```java
  9. public class SingletonDesignEH {
  10.     //volatile避免指令重排问题
  11.     private volatile static SingletonDesignEH singletonDesignEH;
  14.     // 构造方法私有不让别人来创建我们的对象
  15.     private SingletonDesignEH() {
  17.     }
  18.     //多线程下操作同一个成员变量会出现指令重排问题，需要给成员变量加上volatile
  19.     //关键字避免指令重排问题
  20.     public static SingletonDesignEH getSingletonDesignEH() {
  21.         //提升性能，多线程下排队线程太多问题
  22.         if (singletonDesignEH == null) {
  23.             //解决多线程时线程安全问题
  24.             synchronized (SingletonDesignEH.class) {
  25.                 //判断是否已经创建过这个对象
  26.                 if (singletonDesignEH == null) {
  27.                     singletonDesignEH = new SingletonDesignEH();
  29.                     return singletonDesignEH;
  30.                 }
  31.                 return singletonDesignEH;
  32.             }
  33.         }
  34.         return singletonDesignEH;
  35.     }
  38. }