Java中JDK设计模式

2021/11/4 11:11:43

本文主要是介绍Java中JDK设计模式,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

文章目录

  • 1 JDK设计模式
    • 1.1 问题引入
    • 1.2 jdk中设计模式
      • 1.2.1 Singleton(单例)
      • 1.2.2 Factory(静态工厂)
      • 1.2.3 Factory Method(工厂方法)
      • 1.2.4 bstract Factory(抽象工厂)
      • 1.2.5 Builder(构造者)
      • 1.2.6 Prototype(原型)
      • 1.2.7 Adapter(适配器)
      • 1.2.8 Bridge(桥接)
      • 1.2.9 Composite(组合)
      • 1.2.10 Decorator(装饰器)
      • 1.2.11 Façade(外观)
      • 1.2.12 Flyweight(享元)
      • 1.2.13 Proxy(代理)
      • 1.2.14 Iterator(迭代器)
      • 1.2.15 Observer(观察者)
      • 1.2.16 Mediator(协调者)
      • 1.2.17 Template method(模板方法)
      • 1.2.18 Strategy(策略)
      • 1.2.19 Chain of Responsibility(责任链)
      • 1.2.20 Command(命令)
      • 1.2.21 State(状态)
      • 1.2.22 Visitor(访问者)
      • 1.2.23 Interpreter(解释器)
      • 1.2.24 Memento(备忘录)
  • 2 Java的IOC设计模式
    • 1.1 什么是IOC

1 JDK设计模式

1.1 问题引入

本文主要是归纳了JDK中所包含的设计模式,包括作用和其设计类图。
首先来个总结,具体的某个模式可以一个一个慢慢写,希望能对研究JDK和设计模式有所帮助。

设计模式是什么:

  1. 反复出现问题的解决方案
  2. 增强软件的灵活性
  3. 适应软件不断变化

类间关系:继承、委托、依赖、聚合、组合
在这里插入图片描述
介绍方式:

  • 作用:归纳某设计模式的基本要点
  • JDK中体现:某设计模式在JDK中是怎样体现出来的
  • 类图:某设计模式在JDK中所对应的类图

1.2 jdk中设计模式

1.2.1 Singleton(单例)

作用:保证类只有一个实例;提供一个全局访问点
JDK中体现:
(1)Runtime
(2)NumberFormat
类图:
在这里插入图片描述

1.2.2 Factory(静态工厂)

作用:
(1)代替构造函数创建对象
(2)方法名比构造函数清晰
JDK中体现:
(1)Integer.valueOf
(2)Class.forName
类图:
在这里插入图片描述

1.2.3 Factory Method(工厂方法)

作用:子类决定哪一个类实例化
JDK中体现:Collection.iterator方法
类图:
在这里插入图片描述

1.2.4 bstract Factory(抽象工厂)

作用:创建某一种类的对象
JDK中体现:
(1)java.sql包
(2)UIManager(swing外观)
类图:
在这里插入图片描述

1.2.5 Builder(构造者)

作用:
(1)将构造逻辑提到单独的类中
(2)分离类的构造逻辑和表现
JDK中体现:DocumentBuilder(org.w3c.dom)
类图:
在这里插入图片描述

1.2.6 Prototype(原型)

作用:
(1)复制对象
(2)浅复制、深复制
JDK中体现:Object.clone;Cloneable
类图:
在这里插入图片描述

1.2.7 Adapter(适配器)

作用:使不兼容的接口相容
JDK中体现:
(1)java.io.InputStreamReader(InputStream)
(2)java.io.OutputStreamWriter(OutputStream)
类图:
在这里插入图片描述

1.2.8 Bridge(桥接)

作用:将抽象部分与其实现部分分离,使它们都可以独立地变化
JDK中体现:java.util.logging中的Handler和Formatter
类图:
在这里插入图片描述

1.2.9 Composite(组合)

作用:一致地对待组合对象和独立对象
JDK中体现:
(1)org.w3c.dom
(2)javax.swing.JComponent#add(Component)
类图:
在这里插入图片描述

1.2.10 Decorator(装饰器)

作用:为类添加新的功能;防止类继承带来的爆炸式增长
JDK中体现:
(1)java.io包
(2)java.util.Collections#synchronizedList(List)
类图:
在这里插入图片描述

1.2.11 Façade(外观)

作用:
(1)封装一组交互类,一致地对外提供接口
(2)封装子系统,简化子系统调用
JDK中体现:java.util.logging包
类图:
在这里插入图片描述

1.2.12 Flyweight(享元)

作用:共享对象,节省内存
JDK中体现:
(1)Integer.valueOf(int i);Character.valueOf(char c)
(2)String常量池
类图:
在这里插入图片描述

1.2.13 Proxy(代理)

作用:
(1)透明调用被代理对象,无须知道复杂实现细节
(2)增加被代理类的功能
JDK中体现:动态代理;RMI
类图:
在这里插入图片描述

1.2.14 Iterator(迭代器)

作用:将集合的迭代和集合本身分离
JDK中体现:Iterator、Enumeration接口
类图:
在这里插入图片描述

1.2.15 Observer(观察者)

作用:通知对象状态改变
JDK中体现:
(1)java.util.Observer,Observable
(2)Swing中的Listener
类图:
在这里插入图片描述

1.2.16 Mediator(协调者)

作用:用于协调多个类的操作
JDK中体现:Swing的ButtonGroup
类图:
在这里插入图片描述

1.2.17 Template method(模板方法)

作用:定义算法的结构,子类只实现不同的部分
JDK中体现:ThreadPoolExecutor.Worker
类图:
在这里插入图片描述

1.2.18 Strategy(策略)

作用:提供不同的算法
JDK中的体现:ThreadPoolExecutor中的四种拒绝策略
类图:
在这里插入图片描述

1.2.19 Chain of Responsibility(责任链)

作用:请求会被链上的对象处理,但是客户端不知道请求会被哪些对象处理
JDK中体现:
(1)java.util.logging.Logger会将log委托给parent logger
(2)ClassLoader的委托模型
类图:
在这里插入图片描述

1.2.20 Command(命令)

作用:
(1)封装操作,使接口一致
(2)将调用者和接收者在空间和时间上解耦合
JDK中体现:Runnable;Callable;ThreadPoolExecutor
类图:
在这里插入图片描述

1.2.21 State(状态)

作用:将主对象和其状态分离,状态对象负责主对象的状态转换,使主对象类功能减轻
JDK中体现:未发现
类图:
在这里插入图片描述

1.2.22 Visitor(访问者)

作用:异构的类间添加聚合操作;搜集聚合数据
JDK中的体现:未发现
类图:
在这里插入图片描述

1.2.23 Interpreter(解释器)

作用:用一组类代表某一规则
JDK中体现:java.util.regex.Pattern
类图:四则运算
在这里插入图片描述

1.2.24 Memento(备忘录)

作用:保持对象状态,需要时可恢复
JDK中体现:未发现
类图:
在这里插入图片描述

2 Java的IOC设计模式

1.1 什么是IOC

IOC就是Inversion of Control,控制反转。在Java开发中,IOC意味着将你设计好的类交给系统去控制,而不是在类内部控制。这称为控制反转。
下面我们以几个例子来说明什么是IOC
假设我们要设计一个Girl和一个Boy类,其中Girlkiss方法,即Girl想要Kiss一个Boy。那么,我们的问题是,Girl如何能够认识这个Boy?
在我们中国,常见的MM与GG的认识方式有以下几种
1 青梅竹马; 2 亲友介绍; 3 父母包办
那么哪一种才是最好呢?
青梅竹马:Girl从小就知道自己的Boy。

public class Girl {  
    void kiss(){
       Boy boy = new Boy();
    }
}

然而从开始就创建的Boy缺点就是无法在更换。并且要负责Boy的整个生命周期。如果我们的Girl想要换一个怎么办?(笔者严重不支持Girl经常更换Boy)
亲友介绍:由中间人负责提供Boy来见面

public class Girl {
    void kiss(){
       Boy boy = BoyFactory.createBoy();      
    }
}

亲友介绍,固然是好。如果不满意,尽管另外换一个好了。但是,亲友BoyFactory经常是以Singleton的形式出现,不然就是,存在于Globals,无处不在,无处不能。实在是太繁琐了一点,不够灵活。
父母包办:一切交给父母,自己不用费吹灰之力,只需要等着Kiss就好了。

public
class Girl {
    void kiss(Boy boy){
       // kiss boy  
      boy.kiss();
    }
}

Well,这是对Girl最好的方法,只要想办法贿赂了Girl的父母,并把Boy交给他。那么我们就可以轻松的和Girl来Kiss了
这就是IOC,将对象的创建和获取提取到外部。由外部容器提供需要的组件。

我们知道好莱坞原则:Do not call us, we will call you. 意思就是,You, girlie, do not call the boy. We will feed you a boy。

我们还应该知道依赖倒转原则即 Dependence Inversion Princinple,DIP。

Eric Gamma说,要面向抽象编程。面向接口编程是面向对象的核心。
组件应该分为两部分,即
Service, 所提供功能的声明
Implementation, Service的实现
好处是:多实现可以任意切换,防止 “everything depends on everything” 问题.即具体依赖于具体。
所以,我们的Boy应该是实现Kissable接口。这样一旦Girl不想kiss可恶的Boy的话,还可以kiss可爱的kitten和慈祥的grandmother。



这篇关于Java中JDK设计模式的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程