深入浅出Java设计模式：创建型模式

最新推荐文章于 2024-08-23 11:11:52 发布

斯陀含

最新推荐文章于 2024-08-23 11:11:52 发布

阅读量544

点赞数 13

文章标签： java 设计模式开发语言

本文链接：https://blog.csdn.net/u011464172/article/details/139888169

版权

深入浅出Java设计模式：创建型模式

一、引言

设计模式是软件开发中的最佳实践，它提供了一套经过验证的解决方案，用于解决常见的设计问题。创建型模式，顾名思义，关注对象的创建过程，帮助我们以更加灵活、可扩展的方式创建对象，提高代码的可维护性和可复用性。

二、创建型模式分类

Java中常用的创建型模式主要包括：

抽象工厂模式 (Abstract Factory)
建造者模式 (Builder)
工厂方法模式 (Factory Method)
原型模式 (Prototype)
单例模式 (Singleton)

三、详细介绍

1. 抽象工厂模式 (Abstract Factory)

定义: 提供一个接口用于创建相关或依赖对象的家族，而无需指定具体类。

应用场景: 当需要创建一组相关或依赖的对象，并且需要根据不同的配置或需求创建不同的对象族时。

示例:

假设我们要设计一个汽车制造系统，包含不同品牌和类型的汽车。

interface Car {
  void drive();
}

class BenzCar implements Car {
  @Override
  public void drive() {
    System.out.println("奔驰汽车行驶中...");
  }
}

class BmwCar implements Car {
  @Override
  public void drive() {
    System.out.println("宝马汽车行驶中...");
  }
}

interface CarFactory {
  Car createCar();
}

class BenzCarFactory implements CarFactory {
  @Override
  public Car createCar() {
    return new BenzCar();
  }
}

class BmwCarFactory implements CarFactory {
  @Override
  public Car createCar() {
    return new BmwCar();
  }
}

public class AbstractFactoryDemo {
  public static void main(String[] args) {
    CarFactory benzFactory = new BenzCarFactory();
    Car benzCar = benzFactory.createCar();
    benzCar.drive(); // 输出 "奔驰汽车行驶中..."

    CarFactory bmwFactory = new BmwCarFactory();
    Car bmwCar = bmwFactory.createCar();
    bmwCar.drive(); // 输出 "宝马汽车行驶中..."
  }
}

2. 建造者模式 (Builder)

定义: 将一个复杂对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。

应用场景: 当一个对象的构建过程较为复杂，需要多个步骤才能完成时。

示例:

假设我们要构建一个房屋，它包含多种组件，如墙壁、屋顶、窗户等。

interface HouseBuilder {
  void buildWall();
  void buildRoof();
  void buildWindow();
  House getHouse();
}

class ConcreteHouseBuilder implements HouseBuilder {
  private House house = new House();

  @Override
  public void buildWall() {
    house.setWall("砖墙");
  }

  @Override
  public void buildRoof() {
    house.setRoof("瓦片屋顶");
  }

  @Override
  public void buildWindow() {
    house.setWindow("玻璃窗");
  }

  @Override
  public House getHouse() {
    return house;
  }
}

class House {
  private String wall;
  private String roof;
  private String window;

  public void setWall(String wall) {
    this.wall = wall;
  }

  public void setRoof(String roof) {
    this.roof = roof;
  }

  public void setWindow(String window) {
    this.window = window;
  }

  @Override
  public String toString() {
    return "房屋{" +
        "墙壁='" + wall + '\'' +
        ", 屋顶='" + roof + '\'' +
        ", 窗户='" + window + '\'' +
        '}';
  }
}

public class BuilderDemo {
  public static void main(String[] args) {
    HouseBuilder builder = new ConcreteHouseBuilder();
    builder.buildWall();
    builder.buildRoof();
    builder.buildWindow();
    House house = builder.getHouse();
    System.out.println(house); // 输出 "房屋{墙壁='砖墙', 屋顶='瓦片屋顶', 窗户='玻璃窗'}"
  }
}

3. 工厂方法模式 (Factory Method)

定义: 定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。

应用场景: 当需要创建多个不同类型的对象，但创建过程类似时。

示例:

假设我们要设计一个动物园，包含多种动物，如猫、狗、鸟等。

interface Animal {
  void speak();
}

class Cat implements Animal {
  @Override
  public void speak() {
    System.out.println("喵喵喵");
  }
}

class Dog implements Animal {
  @Override
  public void speak() {
    System.out.println("汪汪汪");
  }
}

interface AnimalFactory {
  Animal createAnimal();
}

class CatFactory implements AnimalFactory {
  @Override
  public Animal createAnimal() {
    return new Cat();
  }
}

class DogFactory implements AnimalFactory {
  @Override
  public Animal createAnimal() {
    return new Dog();
  }
}

public class FactoryMethodDemo {
  public static void main(String[] args) {
    AnimalFactory catFactory = new CatFactory();
    Animal cat = catFactory.createAnimal();
    cat.speak(); // 输出 "喵喵喵"

    AnimalFactory dogFactory = new DogFactory();
    Animal dog = dogFactory.createAnimal();
    dog.speak(); // 输出 "汪汪汪"
  }
}

4. 原型模式 (Prototype)

定义: 使用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。

应用场景: 当需要创建的对象类型是可预知的，并且创建过程比较复杂时。

示例:

假设我们要设计一个文档复制功能，可以复制各种类型的文档。

interface Document {
  Document clone();
}

class TextDocument implements Document {
  private String content;

  public TextDocument(String content) {
    this.content = content;
  }

  @Override
  public TextDocument clone() {
    return new TextDocument(content);
  }

  @Override
  public String toString() {
    return "TextDocument{" +
        "content='" + content + '\'' +
        '}';
  }
}

class ImageDocument implements Document {
  private String imagePath;

  public ImageDocument(String imagePath) {
    this.imagePath = imagePath;
  }

  @Override
  public ImageDocument clone() {
    return new ImageDocument(imagePath);
  }

  @Override
  public String toString() {
    return "ImageDocument{" +
        "imagePath='" + imagePath + '\'' +
        '}';
  }
}

public class PrototypeDemo {
  public static void main(String[] args) {
    Document textDocument = new TextDocument("这是一段文本");
    Document clonedTextDocument = textDocument.clone();
    System.out.println(clonedTextDocument); // 输出 "TextDocument{content='这是一段文本'}"

    Document imageDocument = new ImageDocument("image.jpg");
    Document clonedImageDocument = imageDocument.clone();
    System.out.println(clonedImageDocument); // 输出 "ImageDocument{imagePath='image.jpg'}"
  }
}

5. 单例模式 (Singleton)

定义: 保证一个类仅有一个实例，并提供一个访问该实例的全局访问点。

应用场景: 当需要控制一个类的实例个数，并提供全局访问点时。

示例:

假设我们要设计一个数据库连接池，只能有一个实例。

public class DatabaseConnectionPool {
  private static DatabaseConnectionPool instance;

  private DatabaseConnectionPool() {
  }

  public static DatabaseConnectionPool getInstance() {
    if (instance == null) {
      instance = new DatabaseConnectionPool();
    }
    return instance;
  }

  public void getConnection() {
    System.out.println("获取数据库连接...");
  }
}

public class SingletonDemo {
  public static void main(String[] args) {
    DatabaseConnectionPool pool1 = DatabaseConnectionPool.getInstance();
    DatabaseConnectionPool pool2 = DatabaseConnectionPool.getInstance();

    System.out.println(pool1 == pool2); // 输出 "true"
    pool1.getConnection();
  }
}