设计模式（一）_设计模式根据参数生成不同的对象-CSDN博客

本文链接：https://blog.csdn.net/lh87270202/article/details/79666007

创建型：
单例模式
工厂方法模式：用一个统一工厂来创建对象，用参数来获取不同对象
工厂方法模式：将工厂也抽象，由具体子类来实现抽象工厂来创建具体对象。
抽象工厂模式：创建一组相关或相互依赖的对象提供一个接口，比如一个产品有形状和颜色2个属性，建立一个抽象工厂来定义这2组相关系的方法，具体子类继承抽象工厂来获取不同颜色不同形状。
建造者模式：用于一个复杂对象的创建
原型模式

1 v1 单例模式

/**
 * 原始的单例模式
 */
class Singleton {
    //一个静态的实例
    private static Singleton singleton;
    //私有化构造函数
    private Singleton(){}
    //给出一个公共的静态方法返回一个单一实例
    public static Singleton getInstance(){
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}
/**
 * 线程安全 1, 不推荐
 */
class BadSynchronizedSingleton {
    //一个静态的实例
    private static BadSynchronizedSingleton synchronizedSingleton;
    //私有化构造函数
    private BadSynchronizedSingleton(){}
    //给出一个公共的静态方法返回一个单一实例
    public synchronized static BadSynchronizedSingleton getInstance(){
        if (synchronizedSingleton == null) {
            synchronizedSingleton = new BadSynchronizedSingleton();
        }
        return synchronizedSingleton;
    }

}
class SynchronizedSingleton {
    //一个静态的实例
    private static SynchronizedSingleton synchronizedSingleton;
    //私有化构造函数
    private SynchronizedSingleton(){}
    //给出一个公共的静态方法返回一个单一实例
    public static SynchronizedSingleton getInstance(){
        if (synchronizedSingleton == null) {
            synchronized (SynchronizedSingleton.class) {
                if (synchronizedSingleton == null) {
                    synchronizedSingleton = new SynchronizedSingleton();
                }
            }
        }
        return synchronizedSingleton;
    }
}
class SingletonInner {
    private SingletonInner(){}
    public static SingletonInner getInstance(){
        return SingletonInstance.instance;
    }
    private static class SingletonInstance{
        static SingletonInner instance = new SingletonInner();
    }
}

2 v2 简单工厂模式

创建对象时,可根据参数来创建不同的对象。
//抽象产品类

public interface IProduct {
 public void method();
}

//具体产品类A

public class ProductA  implements IProduct {
    @Override
    public void method() {
        System.out.println("产品A方法");
    }
}

//具体产品类B

public class ProductB implements  IProduct{
    @Override
    public void method() {
        System.out.println("产品B方法");
    }
}

//简单工厂类

public class Creator {

    private Creator(){}

    public static IProduct createProduct(String productName){
        if (productName == null) {
            return null;
        }
        if (productName.equals("A")) {
            return new ProductA();
        }else if (productName.equals("B")) {
            return new ProductB();
        }else {
            return null;
        }
    }
}

2.1应用

比如如下当一个请求过来时,需要根据参数还做一些操作,
1 登录\注册\登出或一个缴费业务: 充电费\水费\燃气费

 //在一个方法里面 用参数来区分 ,处理不同的逻辑,在一个大方法里面,每次新加一个 业务都需要加个 else 判断非常不好
public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //我们加入一个操作的参数，来让servlet做出不同的业务处理
    String operation = req.getParameter("operation");
    if (operation.equals("login")) {
        System.out.println("login");
    }else if (operation.equals("register")) {
        System.out.println("register");
    }else if (operation.equals("loginout")) {
        System.out.println("loginout");
    }else {
        throw new RuntimeException("invalid operation");
    }
}

//改进,在原方法根据参数还创建一个service, 具体业务交给具体的service来操作

public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //我们加入一个操作的参数，来让servlet做出不同的业务处理
    String operation = req.getParameter("operation");
    if (operation != null) {
        //这里使用的正是简单工厂模式，创造出一个servlet，然后我们将请求转交给servlet处理
        Servlet servlet = ServletFactory.createServlet(operation);
        servlet.service(servletRequest, servletResponse);
    }else {
        filterChain.doFilter(servletRequest, servletResponse);
    }
}
//创建一个 生产对象的工厂类
public class ServletFactory {
    private ServletFactory(){}
    //一个servlet工厂，专门用来生产各个servlet，而我们生产的依据就是传入的servletName，
    //这个serlvetName由我们在filter截获，传给servlet工厂。
    public static Servlet createServlet(String servletName){
        if (servletName.equals("login")) {
            return new LoginServlet();
        }else if (servletName.equals("register")) {
            return new RegisterServlet();
        }else if (servletName.equals("loginout")) {
            return new LoginoutServlet();
        }else {
            throw new ServletException("unknown servlet");
        }
    }
}

3 v3 工厂方法模式

核心工厂不再生产子类,改成抽象工厂
//抽象产品类

public interface IProduct {
    public void method();
}

//具体产品

public class ProductA implements IProduct {
    @Override
    public void method() {
        System.out.println("产品A方法");
    }
}
public class ProductB implements IProduct {

    @Override
    public void method() {
        System.out.println("产品B方法");
    }
}

//将工厂方法抽象，具体的产品由具体的子工厂生产

public interface Creator {

    public IProduct createProduct();
}

//为每个产品创建具体的工厂

public class ProductACreator implements Creator {
    @Override
    public IProduct createProduct() {
        return null;
    }
}
public class ProductBCreator implements Creator {
    @Override
    public IProduct createProduct() {
        return null;
    }
}

//调用

public class Client {
    public static void main(String[] args) {
        Creator creator = new ProductACreator();
        IProduct product = creator.createProduct();

        creator = new ProductBCreator();
        product = creator.createProduct();
    }
}

3.1简单工厂和工厂方法区别是

工厂方法将工厂类也抽象出来，然后为每个产品都创建一个具体工厂，每次创建产品的时候直接创建具体具体产品的具体工厂，需不采用参数的方式在工厂类里面创造不同的产品。优点：每次创建产品，不用再去修改工厂类，直接创建一个工厂方法继承抽象工厂即可。缺点：工厂方法越来越多。

4 v4 抽象工厂模式

创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
比如创建一个产品，具体有颜色和大小2个属性。
//产品大小和颜色2个抽象类

public interface Size {
   void doSize();
}
public interface Color{
  void doColor();
}

//具体类

public class BigSize implements Shape {
   @Override
   public void doSize() {
      System.out.println("100*100");
   }
}
public class middleSize implements Shape {
   @Override
   public void doSize() {
      System.out.println("50*50");
   }
}
public class smallSize implements Shape {
   @Override
   public void doSize() {
      System.out.println("10*10");
   }
}
public class Red implements Color {
   @Override
   public void doColor() {
      System.out.println("Inside Red::fill() method.");
   }
} 
public class Green implements Color {
   @Override
   public void doColor() {
      System.out.println("Inside Green::fill() method.");
   }
}
public class Blue implements Color {
   @Override
   public void doColor() {
      System.out.println("Inside Blue::fill() method.");
   }
}

//创建这组相关操作的抽象工厂类

public abstract class AbstractFactory {
   abstract Color getColor(String color);
   abstract Shape getSize(String size) ;
}

//创建具体工厂类

public class SizeFactory extends AbstractFactory { 
   @Override
   public Shape getSize(String sizeType){
      if(sizeType == null){
         return null;
      }        
      if(sizeType.equalsIgnoreCase("big")){
         return new Big();
      } else if(sizeType.equalsIgnoreCase("middle")){
         return new Middle();
      } else if(sizeType.equalsIgnoreCase("small")){
         return new Small();
      }
      return null;
   }

   @Override
   Color getColor(String color) {
      return null;
   }
}
public class ColorFactory extends AbstractFactory {   
   @Override
   public Shape getShape(String shapeType){
      return null;
   } 
   @Override
   Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){
         return new Green();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}

//产品类工厂

public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("size")){
         return new SizeFactory();
      } else if(choice.equalsIgnoreCase("color")){
         return new ColorFactory();
      }
      return null;
   }
}

//应用

public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
      //获取形状工厂
      AbstractFactory sizeFactory = FactoryProducer.getFactory("size");
      //获取形状为 big 的对象
      Size size1 = sizeFactory.getSize("big");
      //调用 Size 的 doSize 方法
      size1.doSize();
      //获取形状为 middle 的对象
      Size size2 = sizeFactory.getShape("middle");
       size2.doSize();

      //获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");
      //调用 Red 的 fill 方法
      color1.doColor();
      //获取颜色为 Green 的对象
      Color color2 = colorFactory.getColor("Green");
      //调用 Green 的 doColor 方法
      color2.doColor();
      //获取颜色为 doColor 的对象
      Color color3 = colorFactory.getColor("BLUE");
      //调用 Blue 的 doColor 方法
      color3.doColor();
   }
}

9 v9创建者模式

建造模式是将复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心。

9.1 建造者模式结构组成

Product: 表示被构造的复杂对象,其中包含需要构建的部件属性。
Builder: 创建一个产品对象的各个部件指定抽象接口。
ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示。
Director：调用具体建造者角色以创建产品对象。
1.Product:组装一辆汽车首先的有各种配件，如发动机、轮胎、座椅等。

public class Car{
    public String engine;
    public String tyre;
    public String seat;
    public Car(){
    }
    public String getEngine() {
        return engine;
    }
    public void setEngine(String engine) {
        this.engine = engine;
    }
    public String getTyre() {
        return tyre;
    }
    public void setTyre(String tyre) {
        this.tyre = tyre;
    }
    public String getSeat() {
        return seat;
    }
    public void setSeat(String seat) {
        this.seat = seat;
    }
}

2.Builder:定义一个生产配件的抽象建造者接口。

public interface Builder {
    String buildEngine();
    String buildTyre();
    String buildSeat();
}

3.ConcreteBuilder:实现抽象的建造者接口生成具体的建造者，并开始生产具体的配件。

public class CarBuilder implements Builder{
    @Override
    public String buildEngine() {
        // 生产发动机
        return "发动机";
    }
    @Override
    public String buildTyre() {
        // 生产轮胎
        return "轮胎";
    }
    @Override
    public String buildSeat() {
        // 生产座椅
        return "座椅";
    }
}

4.Director:在生产出配件后，由指导者指导组装配件生成汽车。

public class CarDirector {
    CarBuilder cb;
    public CarDirector(CarBuilder cb){
        this.cb=cb;
    }
    public Car constructCar(){
        Car car=new Car();
        car.setEngine(cb.buildEngine());
        car.setTyre(cb.buildTyre());
        car.setSeat(cb.buildSeat());
        return car;
    }
}

5.最终得到一辆汽车:

public class Client {
    public static void main(String[] args) {
        CarDirector carDirector=new CarDirector(new CarBuilder());
        Car car=carDirector.constructCar();        System.out.println(car.getEngine()+car.getTyre()+car.getSeat());
    }
}