论坛首页 → 入门技术论坛 →

设计模式说明

浏览 3063 次
锁定老帖子 主题：设计模式说明
该帖已经被评为新手帖
作者 正文
  • shjy.nicholas
  • 等级: 初级会员
  • 性别:
  • 文章: 19
  • 积分: 64
  • 来自: 上海
   发表时间：2007-08-21  
设计模式说明
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
返回顶楼
         
  • shjy.nicholas
  • 等级: 初级会员
  • 性别:
  • 文章: 19
  • 积分: 64
  • 来自: 上海
   发表时间：2007-08-22  
这是我辛苦总结的，希望对大家有点用处。
返回顶楼
          回帖地址
0 请登录后投票
论坛首页 → 入门技术版

跳转论坛:
Global site tag (gtag.js) - Google Analytics