java中23种设计模式（1）

vlambda
2021-04-29

java中23种设计模式（1）

什么是设计模式？
设计模式（Design pattern）是一套被编程者反复使用、多人知晓的、经过分类编目的代码设计经验的总结。设计模式主要为了代码的重用、使代码更能被别人理解，以及保证代码的可靠性，扩展性等。
设计模式主要分为三类

创建型模式：用于描述“怎样创建对象”，它的主要特点是“将对象的创建与使用分离”。GoF 中提供了单例、原型、工厂方法、抽象工厂、建造者等 5 种创建型模式。
结构型模式：用于描述如何将类或对象按某种布局组成更大的结构，GoF 中提供了代理、适配器、桥接、装饰、外观、享元、组合等 7 种结构型模式。
行为型模式：用于描述类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，以及怎样分配职责。GoF 中提供了模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等 11 种行为型模式。

接下来我会将23中设计模式分为几篇文章分别讲解，首先从单例模式、工厂模式、建造者模式开始。

1.单列模式

单例模式简单来说就是一个类只能有一个实例，提供一个全部的访问点，单例模式具备典型的3个特点：

1、只有一个实例。

2、自我实例化。

3、提供全局访问点。

简单的实现方式分为以下两种：

懒汉式：

私有化构造方法，将本类作为一个成员属性，暂不实例化，调用提供的获取实例的方法时才去实例化，提供一个函数让外部获取实例，判断是否为null，如果为null就实例化对象。

public class Persion {  private static Persion p = null;    private Persion(){   //私有化构造函数  }  public void play(){    if (p == null) {       p = new Persion();    }    System.out.println("play....");  }}

饿汉式单例模式：

将本类作为成员静态变量并实例化，私有化构造函数，提供对外获取这个变量的方法。该类在加载时就会创建一个实例对象。

public class Persion { private static Persion p = new Persion();  private Persion(){ //私有化构造函数 }  public void play(){  System.out.println("play...."); }}

2. 工厂模式

工厂模式一般分为三种：

普通工厂模式，建一个工厂类，对实现了同一接口的一些类进行实例的创建。

多个工厂方法模式，是对普通工厂模式的改进，在普通工厂模式中，如果传递的字符创出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象

静态工厂模式：将多个工厂方法模式中的方法设置为静态的，不需要手动去new实例，直接调用方法即可。

普通工厂模式

建立一个工厂类，对实现了同一接口的一些类进行实例的创建

interface Sender { void Send();}
class MailSender implements Sender {
 @Override public void Send() { System.out.println("This is mail sender..."); }}
class SmsSender implements Sender {
 @Override public void Send() { System.out.println("This is sms sender..."); }}
public class FactoryPattern { public static void main(String[] args) { Sender sender = produce("mail"); sender.Send(); } public static Sender produce(String str) { if ("mail".equals(str)) { return new MailSender(); } else if ("sms".equals(str)) { return new SmsSender(); } else { System.out.println("输入错误..."); return null; } }}

多个工厂方法模式
该模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

 interface Sender { void Send(); }  class MailSender implements Sender {  @Override public void Send() { System.out.println("This is mail sender..."); } }  class SmsSender implements Sender {  @Override public void Send() { System.out.println("This is sms sender..."); } }  class SendFactory { public Sender produceMail() { return new MailSender(); }  public Sender produceSms() { return new SmsSender(); } }  public class FactoryPattern { public static void main(String[] args) { SendFactory factory = new SendFactory(); Sender sender = factory.produceMail(); sender.Send(); }}

抽象工厂模式

工厂方法模式有一个问题就是，类的创建依赖工厂类，如果想要扩展程序就必须得修改工厂类，

这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？

那么这就用到了抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。


interface Provider { Sender produce();}
interface Sender { void Send();}
class MailSender implements Sender {
 public void Send() { System.out.println("This is mail sender..."); }}
class SmsSender implements Sender {
 public void Send() { System.out.println("This is sms sender..."); }}
class SendMailFactory implements Provider {
 public Sender produce() { return new MailSender(); }}
class SendSmsFactory implements Provider {
 public Sender produce() { return new SmsSender(); }}

public class FactoryPattern { public static void main(String[] args) { Provider provider = new SendMailFactory(); Sender sender = provider.produce(); sender.Send(); }}

3.建造者模式

工厂类模式提供的是创建某个类的模式，而建造者模式则是将各种产品集中起来管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。

import java.util.ArrayList;import java.util.List;
/** * @Author: LiuWang * @Created: 2018/8/6 17:47 */
abstract class Builder { /** * 第一步：装CPU */ public abstract void buildCPU();
 /** * 第二步：装主板 */ public abstract void buildMainBoard();
 /** * 第三步：装硬盘 */ public abstract void buildHD();
 /** * 获得组装好的电脑 * @return */ public abstract Computer getComputer();}
/** * 装机人员装机 */class Director { public void Construct(Builder builder) { builder.buildCPU(); builder.buildMainBoard(); builder.buildHD(); }}
/** * 具体的装机人员 */class ConcreteBuilder extends Builder {
 Computer computer = new Computer();
 @Override public void buildCPU() { computer.Add("装CPU"); }
 @Override public void buildMainBoard() { computer.Add("装主板"); }
 @Override public void buildHD() { computer.Add("装硬盘"); }
 @Override public Computer getComputer() { return computer; }}
class Computer {
 /** * 电脑组件集合 */ private List<String> parts = new ArrayList<String>();
 public void Add(String part) { parts.add(part); }
 public void print() { for (int i = 0; i < parts.size(); i++) { System.out.println("组件:" + parts.get(i) + "装好了..."); } System.out.println("电脑组装完毕..."); }}
public class BuilderPattern {
 public static void main(String[] args) { Director director = new Director(); Builder builder = new ConcreteBuilder(); director.Construct(builder); Computer computer = builder.getComputer(); computer.print(); }}

总结：

单例模式：因为一个类只有一个实例，所以节省了很多资源，比如在项目中日志对象，多个地方都需要写出log信息，所以log打印对象就设计成单例的。

工厂模式：用于创建对象实例化的模式，像jdbc中常用的SqlsessionFactory就是工厂模式。

建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

vlambda博客
学习文章列表