文章目录

• 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类，其中Girl有kiss方法，即Girl想要Kiss一个Boy。那么，我们的问题是，Girl如何能够认识这个Boy？
在我们中国，常见的ＭＭ与GG的认识方式有以下几种
１　青梅竹马； ２　亲友介绍； ３　父母包办
那么哪一种才是最好呢？
青梅竹马：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。