《设计模式》

原创

已于 2024-10-02 09:58:04 修改 · 1.3k 阅读

于 2024-10-01 20:29:11 首次发布

积累知识，分享智慧，让成长之路不再孤单

设计模式概述

设计模式主要是为了解决某类重复出现的问题而出现的一套成功或有效的解决方案
设计模式(Design Pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，使用设计模式是为了可重用代码、让代码更容易被他人理解并且保证代码可靠性。

面向对象设计原则

设计原则定义
单一职责原则一个类只负责一个功能领域中的相应职责
开闭原则软件实体应对扩展开放，而对修改关闭
里氏替换原则所有引用基类对象的地方能够透明地使用其子类的对象（多态）
依赖倒置原则抽象不应该依赖于细节，细节应该依赖于抽象
接口隔离原则使用多个专门的接口，而不使用单一的总接口
迪米特法则一个软件实体应当尽可能少地与其他实体发生相互作用

创建型模式

创建型模式主要用于描述如何创建对象

简单工厂模式

静态工厂模式，根据参数的不同返回不同的实例。
工厂角色
抽象产品角色
具体产品角色
在这里插入图片描述

工厂方法模式

定义一个创建对象的接口，允许子类决定实例化对象的类型，工厂模式使其创建过程延迟到子类进行。
在这里插入图片描述
例如：假设你在一个餐厅点餐，你可以选择汉堡、披萨或沙拉。每种食物都是由对应的厨师独立制作的。这里，每个厨师就是一个工厂，负责制作一种特定的食物。你只需要告诉服务员你要什么食物，服务员会将你的请求交给对应的厨师去制作。这就是工厂方法模式，通过工厂来生产相应的产品。

// 产品接口
interface Food {
   
   
    void prepare();
    void cook();
    void serve();
}

// 具体产品1
class Burger implements Food {
   
   
    @Override
    public void prepare() {
   
   
        System.out.println("Preparing burger...");
    }

    @Override
    public void cook() {
   
   
        System.out.println("Cooking burger...");
    }

    @Override
    public void serve() {
   
   
        System.out.println("Serving burger.");
    }
}

// 具体产品2
class Pizza implements Food {
   
   
    @Override
    public void prepare() {
   
   
        System.out.println("Preparing pizza...");
    }

    @Override
    public void cook() {
   
   
        System.out.println("Cooking pizza...");
    }

    @Override
    public void serve() {
   
   
        System.out.println("Serving pizza.");
    }
}

// 工厂接口
interface FoodFactory {
   
   
    Food createFood();
}

// 具体工厂1 - 汉堡工厂
class BurgerFactory implements FoodFactory {
   
   
    @Override
    public Food createFood() {
   
   
        return new Burger();
    }
}

// 具体工厂2 - 披萨工厂
class PizzaFactory implements FoodFactory {
   
   
    @Override
    public Food createFood() {
   
   
        return new Pizza();
    }
}   

// 客户端代码
public class FactoryMethodExample {
   
   
    public static void main(String[] args) {
   
   
        FoodFactory burgerFactory = new BurgerFactory();
        Food burger = burgerFactory.createFood();
        burger.prepare();
        burger.cook();
        burger.serve();

        FoodFactory pizzaFactory = new PizzaFactory();
        Food pizza = pizzaFactory.createFood();
        pizza.prepare();
        pizza.cook();
        pizza.serve();
    }
}

抽象工厂模式

提供⼀个创建⼀系列相关或相互依赖对象的接口，而无需指定它们具体的类。
解决的问题是在⼀个产品族，存在多个不同类型的产品情况下，接口选择的问题
在这里插入图片描述

例如：假设你正在设计一个电子产品系列，包括手机、平板和笔记本电脑。每个系列有不同的品牌和型号。你可以创建一个抽象工厂，它负责创建整个系列的产品，如手机、平板和笔记本电脑。然后，你可以根据不同的品牌，比如苹果、三星和小米，来创建具体的工厂（如苹果工厂、三星工厂和小米工厂），每个具体的工厂生产对应品牌的产品。抽象工厂模式帮助你创建一族相关的产品系列。
工厂方法模式注重于创建一种类型（食物）的对象，
而抽象工厂模式注重于创建一组相关类型（电子产品）的对象。

// 手机接口
  interface Phone {
   
   
      void makeCall();
  }
  
  // 平板接口
  interface Tablet {
   
   
      void playGame();
  }
  
  // 笔记本电脑接口
  interface Laptop {
   
   
      void doWork();
  }
  
  // 具体手机 - 苹果手机
  class ApplePhone implements Phone {
   
   
      @Override
      public void makeCall() {
   
   
          System.out.println("Making a call with an Apple phone.");
      }
  }
  
  // 具体手机 - 小米手机
  class XiaomiPhone implements Phone {
   
   
      @Override
      public void makeCall() {
   
   
          System.out.println("Making a call with a Xiaomi phone.");
      }
  }
  
  // 具体平板 - 苹果平板
  class AppleTablet implements Tablet {
   
   
      @Override
      public void playGame() {
   
   
          System.out.println("Playing game on an Apple tablet.");
      }
  }
  
  // 具体平板 - 小米平板
  class XiaomiTablet implements Tablet {
   
   
      @Override
      public void playGame() {
   
   
          System.out.println("Playing game on a Xiaomi tablet.");
      }
  }
  
  // 具体笔记本电脑 - 苹果笔记本电脑
  class AppleLaptop implements Laptop {
   
   
      @Override
      public void doWork() {
   
   
          System.out.println("Doing work on an Apple laptop.");
      }
  }
  
  // 具体笔记本电脑 - 小米笔记本电脑
  class XiaomiLaptop implements Laptop {
   
   
      @Override
      public void doWork() {
   
   
          System.out.println("Doing work on a Xiaomi laptop.");
      }
  }
  
  // 抽象工厂接口
  interface ElectronicFactory {
   
   
      Phone createPhone();
      Tablet createTablet();
      Laptop createLaptop();
  }
  
  // 具体工厂 - 苹果电子产品工厂
  class AppleFactory implements ElectronicFactory {
   
   
      @Override
      public Phone createPhone() {
   
   
          return new ApplePhone();
      }
  
      @Override
      public Tablet createTablet() {
   
   
          return new AppleTablet();
      }
  
      @Override
      public Laptop createLaptop() {
   
   
          return new AppleLaptop();
      }
  }
  
  // 具体工厂 - 小米电子产品工厂
  class XiaomiFactory implements ElectronicFactory {
   
   
      @Override
      public Phone createPhone() {
   
   
          return new XiaomiPhone();
      }
  
      @Override
      public Tablet createTablet() {
   
   
          return new XiaomiTablet();
      }
  
      @Override
      public Laptop createLaptop() {
   
   
          return new XiaomiLaptop();
      }
  }
  
  // 客户端代码
  public class AbstractFactoryExample {
   
   
      public static void main(String[] args) {
   
   
          ElectronicFactory appleFactory = new AppleFactory();
          Phone apple = appleFactory.createPhone();
      }
  }

单例模式

保证⼀个类仅有⼀个实例，并提供⼀个访问它的全局访问点

● 懒汉模式

// 线程不安全
  public class Single {
   
   
    private static Single instance;
    
    private Single() {
   
   };
    
    public static Single getInstance() {
   
   
      if(instance != null) return instance;
      instance = new Single();
      return instance;
    }
  }
  
  
  // 线程安全
  public class Single {
   
   
    private static Single instance;
    
    private Single() {
   
   };
    
    public static synchronized Single getInstance() {
   
   
      if(instance != null) return instance;
      instance = new Single();
      return instance;
    }
  }

● 饿汉模式（线程安全）

public class Single {
   
   
    private static Single instance = new Single();
    
    private Single() {
   
   };
    
    public static Single getInstance() {
   
   
      return instance;
    }