设计模式说明
设计模式说明
Produce by Shjy.Nicholas
E-Mail: [email protected]
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