Java笔记19 – 设计模式 – 创建性模式

2023年4月16日下午8:37 • 设计模式

使用设计模式的目的是为了可重用代码, 提高代码的可扩展性和可维护性
尽量复用代码, 降低代码的偶合度
设计模式主要是基于OOP编程提炼的
开闭原则: 尽量对扩展开发, 对修改关闭. 能不修改代码, 只增加代码即可完成新功能, 是最好的.
里氏替换原则: 如果我们调用父类的方法可以成功, 替换成子类调用也可以成功

创建性模式

关注如何创建对象, 核心是把对象的创建和使用分开, 两者可以相对独立的变换

工厂方法

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

工厂方法目的: 使得创建对象和使用对象是分离的, 并且客户端总是引用抽象工场和抽象产品.

public class Main {
  public static void main(String[] args) {
    NumberFactory factory = NumberFactory.getFactory();
    Number result = factory.parse("1234");
    System.out.println(result);
  }
}

// 实现一个解析字符串到`Number`的Factory
interface NumberFactory {
  Number parse(String s);
  // 获取工厂实例
  static NumberFactory getFactory() {
    return impl;
  }
  static NumberFactory impl = new NumberFactoryImpl();
}

// 工厂的实现类
class NumberFactoryImpl implements NumberFactory {
  public Number parse(String s) {
    return new BigDecimal(s);
  }
}

可以完全忽略真正的工程NumberFactoryImpl和产品BigDecimal
允许创建产品的代码独立变化, 而不会影响到调用方

interface NumberFactory {
  public static Number parse(String s) {
    return new BigDecimal(s);
  }
}

静态工厂方法
工厂方法可以隐藏创建产品的细节, 且不会每一次都会真正的创建的产品. 也可能是从缓存中拿出, 从而提升速度并减少内存消耗
例如Integer.valueOf(), 可以提前初始化很多常用的, 实例, 每次都调用缓存中的实例, 当没有的时候, 再放一个进去
总是引用接口, 能允许变化子类, 而不影响调用方, 尽可能面向对象编程

// TODO: 没搞明白List.of()是如何执行并返回的.
List<String> list = List.of("a", "b", "c", "d");
System.out.println(list);

class LocalDateFactory {
  private static Map<Integer, LocalDate> cache = new HashMap<Integer, LocalDate>();

  public static LocalDate fromIn(int yyyyMMdd) {
    if (yyyyMMdd > 20000101 && yyyyMMdd < 20200101) {
      if (cache.containsKey(yyyyMMdd)) return cache.get(yyyyMMdd);
      LocalDate value = createDate(yyyyMMdd);
      cache.put(yyyyMMdd, value);
      return value;
    } else {
      return createDate(yyyyMMdd);
    }
  }

  private static LocalDate createDate(int yyyyMMdd) {
    System.out.println("run createDate");
    return LocalDate.of(yyyyMMdd / 1000, yyyyMMdd / 100 % 100, yyyyMMdd % 100);
  }
}

产生实例的过程外界并不知道, 可以进行适当的缓存, 增加产生实例的效率

抽象工厂

提供一个创建一系列相关或者相互依赖对象的接口, 而无需指定他们具体的类

工厂是抽象的, 工厂产出的产品也是抽象的.
然后有个具体的工厂1, 实现了工厂, 工厂1中的产品1-1, 实现了产品

├── lib
└── src
    ├── App.java
    ├── fastfactory
    │   ├── FastFactory.java // 实际工厂
    │   ├── FastHtmlDocument.java // 实际产品
    │   └── FastWordDocument.java // 实际产品
    ├── goodfactory
    │   ├── GoodFactory.java // 实际工厂
    │   ├── GoodHtmlDocument.java // 实际产品
    │   └── GoodWordDocument.java // 实际产品
    └── services
        ├── AbstractFactory.java // 虚拟工厂
        ├── HtmlDocument.java // 虚拟产品
        └── WordDocument.java // 虚拟产品

// 虚拟工厂
public interface AbstractFactory {
  HtmlDocument createHtml(String md);

  WordDocument createWord(String md);
}
// 虚拟产品
public interface HtmlDocument {
  String toHtml();

  void save(Path path);
}
// 虚拟产品
public interface WordDocument {
  void save(Path path);
}
// 实际工厂
public class GoodFactory implements AbstractFactory {

  @Override
  public HtmlDocument createHtml(String md) {
    return new GoodHtmlDocument(md);
  }

  @Override
  public WordDocument createWord(String md) {
    return new GoodWordDocument(md);
  }

}
// 实际产品
public class GoodHtmlDocument implements HtmlDocument {
  private String md;

  public GoodHtmlDocument(String md) {
    this.md = md;
  }

  @Override
  public String toHtml() {
    System.out.println(md);
    return null;
  }

  @Override
  public void save(Path path) {
  }

}
// 实际产品
public class GoodWordDocument implements WordDocument {
  private String md;

  public GoodWordDocument(String md) {
    this.md = md;
  }

  @Override
  public void save(Path path) {
    System.out.println(md);
  }

}

生成器

将一个复杂对象的构建与表示分离, 使得同样的构建过程可以创建不同表示

public class HtmlBuilder {
  // 分成多个builder, 一步步构建
  private HeadingBuilder headingBuilder = new HeadingBuilder();
  private HrBuilder hrBuilder = new HrBuilder();
  private ParagraphBuilder paragraphBuilder = new ParagraphBuilder();
  private QuoteBuilder quoteBuilder = new QuoteBuilder();

  public String toHtml(String md) {
    StringBuilder buffer = new StringBuilder();
    md.lines().forEach(line -> {
      if (line.startsWith("#")) {
        buffer.append(headingBuilder.buildHeading(line))
          .append("\n");
      } else if (line.startsWith(">")) {
        buffer.append(quoteBuilder.buildQuote(line))
          .append("\n");
      } else if (line.startsWith("---")) {
        buffer.append(hrBuilder.buildHr(line))
         .append("\n");
      } else {
        buffer.append(paragraphBuilder.buildParagraph(line))
          .append("\n");
      }
    });
    return buffer.toString();
  }
}

// 分步骤构建
public class URLBuilderImpl implements URLBuilder {

  private String domain = "www.baidu.com";
  private String scheme = "http";
  private String path = null;
  private Map<String, String> query;

  @Override
  public URLBuilder setDomain(String domain) {
    this.domain = Objects.requireNonNull(domain);
    return this;
  }

  @Override
  public URLBuilder setScheme(String scheme) {
    this.scheme = Objects.requireNonNull(scheme);
    return this;
  }

  @Override
  public URLBuilder setPath(String path) {
    this.path = Objects.requireNonNull(path);
    return this;
  }

  @Override
  public URLBuilder setQuery(Map<String, String> query) {
    this.query = query;
    return this;
  }

  @Override
  public String build() {
    StringBuilder sb =  new StringBuilder();
    sb.append(scheme)
      .append("://")
      .append(domain)
      .append(path);
    if (this.query.size() > 0) {
      sb.append("?");
      this.query.forEach((k, v) -> {
        sb.append(k).append("=").append(v).append("&");
      });
      sb.setLength(sb.length() - 1);
    }
    return sb.toString();
  }

  public URLBuilderImpl() {
  }
}

原型

用原型实例指定创建对象的种类, 并且通过拷贝这些原型创建新的对象

原型模式就是 Prototype, 只指创建新对象的时候, 根据现有的一个原型来创建.

public class Student  {
  private int id;
  private String name;
  private int score;

  // 复制对象并, 直接返回相同类型, 省去类型转换
  public Student copy() {
    Student std = new Student();
    std.id = this.id;
    std.name = this.name;
    std.score = this.score;
    return std;
  }
}

单例

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

单例模式的目的是为了保证在一个进程中, 某个类有且仅有一个实例.

public class Singleton {
  // 静态字段引用唯一实例:
  private static final Singleton INSTANCE = new Singleton();

  // 通过静态方法返回实例
  public static Singleton getInstance() {
    return INSTANCE;
  }

  // private构造方法, 保证外部不能实例化
  private Singleton() {
  }
}

public class Singleton {
  // 静态字段引用唯一实例:
  public static final Singleton INSTANCE = new Singleton();

  // private构造方法, 保证外部不能实例化
  private Singleton() {
  }
}

对构造函数进行private私有化保护
延迟加载的方式, 多线程的方式会导致错误
使用枚举的方式实现单例
- 可以避免序列化和反序列化会绕过普通类的private方法
- 也可以定自己的字段方法等

// java保证枚举类的每个枚举, 都是单例
public enum World {
  // 唯一枚举
  INSTANCE;

  private String name = "world";

  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
}

通过约定, 在框架中直接使用单例. 例如@Component

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Java笔记19 – 设计模式 – 创建性模式 - Python技术站

设计模式

0 0 打赏

微信扫一扫

支付宝扫一扫

[设计模式]设计模式之六大原则

上一篇 2023年4月16日

Java笔记21 – 设计模式 – 行为型模式

下一篇 2023年4月16日

GoLang设计模式01 – 建造者模式

建造者模式是一种创建型模式，主要用来创建比较复杂的对象。建造者模式的使用场景：建造者模式通常适用于有多个构造器参数或者需要较多构建步骤的场景。使用建造者模式可以精简构造器参数的数量，让构建过程更有条理。可以为同一个产品提供两个不同的实现。比如，在下面的代码中，为house类型创建了两个不同的实现：通过iglooBuilder构建的igloo（冰屋），以…

设计模式 2023年4月13日
000
C#面向对象设计模式纵横谈

C#面向对象设计模式纵横谈(25)：设计模式总结 — LEVEL 300主讲：李建忠系列：C#面向对象设计模式纵横谈类别：Patterns & Practices讲座内容：本培训课程是对整个设计模式系列讲座的总结，综合对比、分析与运用各种设计模式。 C#面向对象设计模式纵横谈(24)：(行为型模式) Visitor 访…

设计模式 2023年4月16日
000
C#设计模式（12）－Decorator Pattern

一、装饰（Decorator）模式装饰（Decorator）模式又名包装（Wrapper）模式[GOF95]。装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。引言孙悟空有七十二般变化，他的每一种变化都给他带来一种附加的本领。他变成鱼儿时，就可以到水里游泳；他变成雀儿时，就可以在天上飞行。而不管悟空怎么变化，在二郎神眼里，他永远是…

设计模式 2023年4月12日
000
Java设计模式：代理模式（一）

问题的提出现在生活中，常常在微信朋友圈里面看到代购的信息，你想在国外买什么，香港买什么，但是又懒得自己过去，于是常常委托别人帮忙买奶粉买那啥的。这类问题的缘由是因为客户和原产地没有直接的接触，所以需要一个代理（代购）的第三者来实现间接引用。代理对象可以在客户端和目标对象间起到中介作用，而且可以通过代理对象去掉客户不能看到的内容和服务或者添加客户需要的额外服…

设计模式 2023年4月13日
000
关系型数据库：关系模式设计原则

关系型数据库：关系模式设计原则 1.范式与数据冗余度从0NF到1NF、2NF、3NF、BCNF、4NF、5NF？数据库设计的过程是个拆分表的过程，拆分的目的是降低数据的冗余度。数据的冗余度越低，事务持续时间就越短（它不需要额外的操作去维持数据一致性和完整性）。与此同时，拆得越细，查询的代价越高（需要更多耗时的连接运算）。 2.关系模式的设计原则如果表（集…

设计模式 2023年4月9日
000
javascript中的设计模式之单例模式

一、定义保证一个类仅有一个实例，并提供一个访问它的全局访问点单击按键弹出弹出框，这个弹出框是唯一的，无论单击多少次，这个弹出框都应该只被创建一次。三、实现单例模式分为两种，一种是立即执行，另一种是惰性执行 1.立即执行所谓立即执行就是当js代码加载后，就会立刻创建一个单例对象。那么根据单例模式的定义，我们在全局环境下声明变量： var a = {…

设计模式 2023年4月10日
000
设计模式之-组合模式

定义：组合模式(Composite Pattern)：将对象组合成树形结构以表示“部分整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。组合模式参与者 Component：组合中对象的抽象和接口。 Leaf：在组合中表示叶节点对象，叶节点没有子节点。 Composite：在组合中表示枝节点对象，用来存储子部件，实现Component…

设计模式 2023年4月13日
000
MediatRPC – 基于MediatR和Quic通讯实现的RPC框架，比GRPC更简洁更低耦合，开源发布第一版

大家好，我是失业在家，正在找工作的博主Jerry。作为一个.Net架构师，就要研究编程艺术，例如SOLID原则和各种设计模式。根据这些原则和实践，实现了一个更简洁更低耦合的RPC（Remote Procedure Calls）框架，名叫MediatRPC。一、MediatR 编程思想 SOLID的总原则是开闭原则(Open Closed Principle…

设计模式 2023年4月12日
000

Java笔记19 – 设计模式 – 创建性模式

工厂方法

抽象工厂

生成器

原型

单例

相关文章