设计模式说明
Produce by Shjy.Nicholas
E-Mail: shjy.nicholas@gmail.com
Version: 1.0
说明
:
本文是
<<
设计模式
--
可复用面向对象软件的基础
>>,
英文名称
"Design Patterns -- Elements of Reusable Object-Oriented Software"
一书的复习资料
.
原书的作者是
: Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides.
译者是
:
李英军
,
马晓星
,
蔡敏
,
刘建中
.
文中所表示的页码也是中文版的页码数
.
一
. OMT
表示法的简单实例
1.
类
public class Name { // Name
为类名
private String data ; // data
为数据
public void operation() {} // operation()
为操作
}
2.
实例化
在
Java
中
,
就是
new
操作
,
此时会使对象内部的数据分配存储空间
.
3.
继承关系
public class ParentClass {
public void sayHello() {
System.out.println(“Hello in ParentClass”) ;
}
}
public class SubClass extends ParentClass {
public void sayHi() {
System.out.println(“Hi in SubClass”) ;
}
public static void main(String [] args) {
SubClass sc = new SubClass() ;
sc.sayHello() ;
sc.sayHi() ;
}
}
/**
*
运行结果
:
* Hello in ParentClass //
子类继承了父类中的方法
SayHello()
* Hi in SubClass
*/
4.
抽象类与具体类
abstract class AbstractClass {
public abstract void operation() ;
}
class ConcreteSubClass extends AbstractClass {
public void operation() {
System.out.println("operation...") ;
}
}
5.
混入类
在
java
中不直接支持多继承
,
可以通过
implements
多个接口来实现
.
interface ExistingInterface {
void existingOperation() ;
}
interface Mixin {
void mixinOperation() ;
}
class AugmentedClass implements ExistingInterface, Mixin {
public void existingOperation() {
System.out.println("existingOperation()") ;
}
public void mixinOperation() {
System.out.println("mixinOperation()") ;
}
}
二
.
委托
class Rectangle {
public int width ;
public int height ;
public int area(){
return width * height ;
}
}
class Window {
Rectangle rectangle = new Rectangle() ;
public int area() {
return rectangle.area() ;
}
}
三
. Lexi
说明
.
1.
设计中涉及到
7
种设计模式
,
分别是
Abstract Factory, Composite, Strategy, Decorator, Bridge, Command, Iterator.
2.
设计问题
:
u
文档结构
:Lexi
的用户可以直接操纵行
,
列
,
图形
,
表等子结构
.
使用到的模式
:
组合模式
.
u
格式化
:
将一个图元集合分解为若干行
.
格式化不同于表示
,Lexi
必须将文本分解成行
,
将行分解成列等操作
,
同时还要满足用户的高层次要求
,
如
:
指定边界宽度
,
缩进大小和表格形式
,
是否隔行显示以及其他可能的许多格式限制条件
.
使用的模式
:
策略模式
.
u
修饰用户界面
:
支持两种修饰
:
n
在文本编辑区域周围加边界以界定文本页
.
n
加滚动条
.
使用的模式
:
装饰模式
.
u
支持多种视感标准
:
支持多种视感标准
,
以满足平台移植的要求
.
使用模式
:
抽象工厂
.
u
支持多种窗口系统
:
解决移植中的窗口环境
.
使用模式
:
桥接模式
.
u
用户操作
:
通过文档的
WYSIWYG(
所见即所得
)
得到
,
并支持撤销和重做功能
,
以及命令历史记录
.
使用得模式
:
命令模式
.
u
拼写检查和连字符
:
1.
访问以图元形式存在的
,
分散在文档结构中的信息
.
2.
分析这些信息
使用的模式
:
迭代器模式
.
四
.
重要模式的说明
:
1. Abstract Factory
抽象工厂模式
抽象工厂模式涉及到以下角色
:
u
抽象工厂角色
:
担任这个角色的是工厂方法模式的核心
,
它是与应用系统的商业逻辑无关的
.
u
具体工厂角色
:
这个角色直接在客户端的调用下创建产品的实例
.
u
抽象产品角色
:
担任这个角色的类是工厂方法模式所创建的对象的父类
,
或它们共同拥有的接口
.
u
具体产品角色
:
抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例
.
在书
P58
页的结构图中
,
抽象工厂角色
:AbstractFactory
具体工厂角色
:ConcreteFactory1, ConcreteFactory2
抽象产品角色
:AbstractProductA, AbstractProductB
具体产品角色
:ProductA1, ProductA2, ProductB1, ProductB2
2. Builder
生成器模式
Builder
涉及到的角色
: (
括号内为所举例子中所对应的类名
)
u
抽象创造者
(Builder)
u
具体创造者
(ConcreteBuilder)
u
导演者
(Director)
u
产品
(Product)
举例说明
:
abstract public class Builder {
public abstract void buildPart1();
public abstract void buildPart2();
public abstract Product retrieveResult();
}
public class ConcreteBuilder extends Builder {
private Product product = new Product() ;
public void buildPart1() {
product.setPart1(“Part1 be build”) ;
}
public void buildPart2() {
product.setPart2(“Part2 be build”) ;
}
public Product retrieveResult(){
return product;
}
}
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public Product construct()
builder.buildPart1();
builder.buildPart2();
return builder.retrieveResult();
}
}
public class Product {
private String part1 = null ;
private String part2 = null ;
public Product() {}
public void setPart1(String part1){
this.part1 = part1 ;
}
public String getPart1() {
return this.part1 ;
}
public void setPart2(String part2){
this.part2 = part2 ;
}
public String getPart2() {
return this.part2 ;
}
public String toString(){
System.out.println(“part1: ” + this.getPart1()) ;
System.out.println(“part2: ” + this.getPart2()) ;
}
}
public class Client {
private Director director = null ;
private Builder builder = null ;
public void doBuild() {
director = new Director(new ConcreteBuilder());
System.out.println(director. construct()) ;
}
}
3. Composite
合成模式
涉及到的角色
:
u
抽象构件
(Component)
u
树叶构件
(Leaf)
u
树枝构件
(Conmposite)
举例
:
public interface Component {
Composite getComposite();
void sampleOperation();
}
public class Leaf implements Component {
public Composite getComposite(){
return null;
}
public void sampleOperation(){
System.out.println("leaf say hello") ;
}
}
import java.util.Vector;
import java.util.Enumeration;
public class Composite implements Component{
private Vector componentVector = new java.util.Vector();
public Composite getComposite(){
return this;
}
public void add(Component component){
componentVector.addElement(component);
}
public void remove(Component component){
componentVector.removeElement(component);
}
public Enumeration components(){
return componentVector.elements();
}
public void sampleOperation(){
Enumeration enumeration = components();
while (enumeration.hasMoreElements()){
((Component)enumeration.nextElement())
.sampleOperation();
}
}
}
4
．
Strategy
策略模式
对应于
P209
的结构图
,
public class Context{
private Strategy strategy;
public Strategy setStrategy(Strategy strategy) {
this.strategy = strategy ;
}
public void contextInterface(){
this.strategy.strategyInterface();
}
}
abstract public class Strategy{
public abstract void algorithmInterface();
}
public class ConcreteStrategyA extends Strategy{
public void algorithmInterface(){
System.out.println("A") ;
}
}
public class ConcreteStrategyB extends Strategy{
public void algorithmInterface(){
System.out.println("B") ;
}
}
public class ConcreteStrategyC extends Strategy{
public void algorithmInterface(){
System.out.println("C") ;
}
}
5.Decorator
装饰模式
基于
P116
的结构图
,
有如下代码
:
public interface Component{
void operation();
}
public class ConcreteComponent implements Component{
public void operation(){
//
给对象添加一些指责
}
}
public class Decorator implements Component{
private Component component = null ;
public Decorator(Component component){
this.component = component;
}
public void operation(){
component.operation();
}
}
public class ConcreteDecorator extends Decorator{
public void operation(){
super.operation();
//
调用
Component
对象的
operation
方法
,
来给组件添加指责
}
}
6.Bridge
桥接模式
基于
P101
的结构图
:
abstract public class Abstraction{
private Implementor imp;
public void operation(){
imp.operationImp();
}
}
public class RefinedAbstraction extends Abstraction{
public void operation() {
super.operation() ;
//
可以增加进一步的处理
}
}
abstract public class Implementor{
public abstract void operationImp();
}
public class ConcreteImplementorA extends Implementor{
public void operationImp(){
System.out.println(
"Do something in ConcreteImplementorA ...");
}
}
public class ConcreteImplementorB extends Implementor{
public void operationImp() {
System.out.println(
"Do something in ConcreteImplementorB ...");
}
}
7.Command
命令模式
基于
P157,
有如下示例
:
public class Receiver {
public Receiver() {}
public void action() {
System.out.println("Action has been taken.");
}
}
public interface Command {
void execute();
}
public class ConcreteCommand implements Command{
private Receiver receiver;
public ConcreteCommand(Receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.action();
}
}
public class Invoker {
private Command command;
public Invoker(Command command){
this.command = command;
}
public void action() {
command.execute();
}
}
public class Client {
public static void main(String [] args) {
Receiver receiver = new Receiver();
//
关键
:
将接受者绑定到一个动作
Command command = new ConcreteCommand(receiver);
Invoker invoker = new Invoker( command );
invoker.action();
}
}
8. Iterator
迭代器模式
基于
P172,
有如下代码
:
public interface Iterator{
void first();
void next();
boolean isDone();
Object currentItem();
}
public class ConcreteIterator implements Iterator{
private ConcreteAggregate agg;
private int index = 0;
private int size = 0;
public ConcreteIterator(ConcreteAggregate agg) {
this.agg = agg;
size = agg.size();
index = 0 ;
}
public void first() {
index = 0 ;
}
public void next(){
if (index < size){
index++;
}
}
public boolean isDone() {
return (index >= size);
}
public Object currentItem() {
return agg.getElement(index);
}
}
abstract public class Aggregate{
public Iterator createIterator() {
return null;
}
}
public class ConcreteAggregate extends Aggregate{
private Object objs[]= {"
Item1
",
"
Item2
",
"
Item3
",
"Item4
"
"Item5"};
public Iterator createIterator(){
return new ConcreteIterator(this);
}
public Object getElement(int index) {
if (index < objs.length) {
return objs[index];
} else {
return null;
}
}
public int size(){
return objs.length;
}
}
public class Client{
private Iterator it;
private Aggregate agg = new ConcreteAggregate();
public void operation(){
it = agg.createIterator();
while( !it.isDone() ){
System.out.println(it.currentItem().toString());
it.next();
}
}
public static void main(String[] args) {
Client client = new Client();
client.operation();
}
}