BlogJava-努力创造未来！-随笔分类-Patterns

设计模式之行为

有猫相伴的日子 — Mon, 24 Sep 2007 15:36:00 GMT

类是没有行为的，只有对象才可能有行为，但对象的行为肯定是由类来定义的。
今天讲要10个行为设计模式，记下它们的思想！
1、Template（模版）
      定义一个操作中算法的骨架,将一些步骤的执行延迟到其子类中. 如Struts中的execute()方法，通俗的说法是在父类的方法中，调用操象的方法。而操象的方法是由实现类来实现。

2、Memento（备忘录模式）
      备忘录模录实际上是对象内部状态的拷贝，运行到某个时候可以恢复它原有的状态，在实际开发中我们经常会用到该模式，但写法可能不一样。
3、Observer（临听模式）
     别人说是观察者，我喜欢说这是监听模式，就是设置一个对象的监听对象，当被监听对象的状态改变时触发一个事件，JDK已经提供实现了。需要用到时GOOGLE一样就OK。
4、Chain of Responsibility（职责链）
    就是一个对象当作一个参数传递给不同的对进行职责处理。
5、Command（命令模式）
    就看具体封装了，实际开发中用一得也挺多。
6、State（状态模式）

7、Strategy(策略)
    是对算法的一种封装
8、Mediator(中介者)
   各个对象之间的交互操作非常多;每个对象的行为操作都依赖彼此对方,修改一个对象的行为,同时会涉及到修改很多其他对象的行为,如果使用Mediator模式,可以使各个对象间的耦合松散,只需关心和 Mediator的关系,使多对多的关系变成了一对多的关系,可以降低系统的复杂性,提高可修改扩展性.

9、Interpreter(解释器)
10、Visitor（参观者模式）
就是遍历类集中的对象吧

有猫相伴的日子 2007-09-24 23:36 发表评论

设计模式之结构

有猫相伴的日子 — Sat, 22 Sep 2007 06:58:00 GMT

结构模式有7个小模式，下面分别说一下它们的思想：
1、门面模式(Facade)也称外观模式
      为子系统提供统一的接口，这个接口就叫门在了，客户只需与门面来的交道，内部调用那个功能模块对客户类来说是隐藏的。现实生活中去医院看病捡药的例子是一样的。
2、代理模式(Proxy)
     有两种方式一种是静态代理，另一种是动态代理。代理模式就是为其它对象提供代理以控制对这个对象的访问。
3、适配器模式（Adapter）
     将两个不兼容的类纠合在一起使用,使用这个模式时，最好以面向接口的方式实一，而不用继承。这是一个比较好理解的模块，不需要看例程就应该能回忆起它的结构。
4、组合模式（Composite）
     将对象以树的形式组合起来，以达成整体与部份的结构。并在类中提供添加，删除，遍历这三个方法。通常以操象类为父类来实现。
5、油漆工模式（Decorator）
说白了就是给一个类再添加些功能，通常可以在设计中可以使用继承，再实现个接口。该模式可以避免这样做，实一方法是在实现接口的类方法中，添中一些额外功能函数。
6、桥接模式（Bridge）
    将操象与行为分离。
7、享元模式(Flyweight)
    说白了就是一个Map 用来存储对象时，先判断Map中是否有该对象，如果有就不需再存进。或者要从别的地方联一个对象时，先在Map里找，如果找到就不用去别的地方了。有点类似于一个池。具体实现就不说了

有猫相伴的日子 2007-09-22 14:58 发表评论

设计模式之创建模式

有猫相伴的日子 — Wed, 19 Sep 2007 15:26:00 GMT

设计模式分三大类：创建、结构、行为!
设计模式是对软件建立的一个方法，也可以说是一种行为规范！在面向对象的软件开发思想里，最为关键的我想是OOA/OOD，这是面向对象程序设计的基础，而设计模式分的这三大类，是OOD中所必须的元素。设计模式分类与对象三大特征吻合。
1、对象创建：任何一个对象都有一个建立过程，就是从类生成对象。
2、对象结构：更准确来讲是类的结构，我们要创建一个类（对象）就必须先确定它的结构。
3、对象行为：对象（类）由构造函数、属性、方法构成，而方法通常就是指对象的行为。

设计模式分类可以说是以类到对象创建过程来划分的。

设计模式有些书是长篇大论，让我不知所措，俺文化水平低只能从个人的见解上做简单的分析，并反简单的思想用到实际开发中。
创建模式有4个子模式：
这4个模式都是创建对象的，只不是创建的方式不一样，有的对象只能创建一个；有的对象是通过工厂来生产；有的对象由很多小对象组成（有整体与部份关系）就通过Builder(构造),下面做介绍

1、Factory （工厂模式）:分为工厂方法，操象工厂。单一个接口有多个实现时通常可以用工厂方法来实现，如果要创建多个接口的实现类，并现对构建比较复杂时我们就用操象工厂。
2、Prototype（原型模式）：基本不用，实际上是父类实现了一个Cloneable接口。我不喜欢用这种方式，也找到更好的方法来实现Cloneable。
3、Builder（构造模式）：是为了将构建复杂对象的过程和它的部件解耦.注意: 是解耦过程和部件 ,通常先定义构造类的接口，实现不同的部件构造，然后有一个装配的过程。
4、Singleton（单态模式）：太常用，不用介绍，通常有三种创建单态类的方法。

学习设计模式不是要牢记它是怎么实现的，不要记住列子，只要记住思想就可以了，当你在现实中做设计的时候，让这些思想浮现在你脑海里，选择最适用你的实现方法。

有猫相伴的日子 2007-09-19 23:26 发表评论

设计模式--command(命令模式)

有猫相伴的日子 — Thu, 13 Jul 2006 15:00:00 GMT

Command有很多种实现方式，可以随便的按便这个规律来自由发挥。
package com.pdw.pattern;

import java.util.*;
import org.apache.commons.lang.StringUtils;

interface Command{
public void execute();
}
interface Parameter{
public String getCommandType();
}
class Engineer implements Command{

public void execute() {
// TODO Auto-generated method stub
System.out.println("Enginer....");
}

}

class Programer implements Command{

public void execute() {
// TODO Auto-generated method stub
System.out.println("Programer....");
}

}
class Doctor implements Command{

public void execute() {
// TODO Auto-generated method stub
System.out.println("Doctor.............");
}

}
class EngineerParameter implements Parameter{

public String getCommandType() {
  // TODO Auto-generated method stub
  return "Engineer";
}

}
class CommandProduce{
public static List commandList=new ArrayList();
public CommandProduce(){
  commandList.add(new Engineer());
  commandList.add(new Programer());
  commandList.add(new Doctor());
}
public static Command getCommand(Parameter p){
  Iterator it=commandList.iterator();
  while(it.hasNext()){
   Object c=(Object)it.next();
   System.out.println(c.getClass().getName());
   if(StringUtils.indexOf(c.getClass().getName(),p.getCommandType())>0){
    return (Command)c;
   }
  }
  return null;
}
}
public class CommandImpl {

public static void main(String[] args) {
// TODO Auto-generated method stub

  EngineerParameter ep=new EngineerParameter();
  CommandProduce cp=new CommandProduce();
  (CommandProduce.getCommand(ep)).execute();
}

}

有猫相伴的日子 2006-07-13 23:00 发表评论

设计模式---Observer(观察)

有猫相伴的日子 — Mon, 10 Jul 2006 15:05:00 GMT

Observer 的定义：
当被观察的对象特定属性改变时，就通知被它的观察对象。
在这个模式中就两个角色一个是被观察者，一个是观察者。当被观察者做了某些改变时就通知它的观察者。一个被观察对象可以有N个观察者。java.util.*包中已经实现了这种模式。请参考如下例子：
package com.pdw.pattern;

import java.util.*;

class Product extends Observable{//被观察者必继承于Observable

private String pname;
private float price;

public String getPname() {
  return pname;
}
public void setPname(String pname) {
  this.pname = pname;
  setChanged();
  notifyObservers(pname);
}
public float getPrice() {
  return price;
}
public void setPrice(float price) {
  this.price = price;
  setChanged();
  notifyObservers(new Float(price));
}
}
class NameObserver implements Observer{ //观察者必须实现Observer接口

public void update(Observable arg0, Object arg1) {
  if(arg1 instanceof String){
   System.out.println("产品名--->"+arg1);
  }
}

}
class PriceObserver implements Observer{

public void update(Observable arg0, Object arg1) {
  if(arg1 instanceof Float){
   System.out.println("产品价格是->"+arg1);
  }
}

}
public class ObserverImpl {

/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  Product p=new Product();
  p.setPname("电脑");
  p.setPrice(Float.valueOf("5632.6"));
  NameObserver no=new NameObserver();
  PriceObserver po=new PriceObserver();
  p.addObserver(no);
  p.addObserver(po);
  p.setPname("笔记本电脑");
  p.setPrice(Float.valueOf("9635.5"));
}

}

有猫相伴的日子 2006-07-10 23:05 发表评论

设计模式---Memento(备忘录)

有猫相伴的日子 — Mon, 10 Jul 2006 14:58:00 GMT

Memento的定义：
Memento是一个保存另外一个对象的内部状态拷贝的对象，这样就可以把对象恢复到原先状态。

确的没必要用这个东西，耗内存，麻烦。我想备份对象为什么不用对象的深度拷贝呢。这样不是很省事吗？谁能告诉我一个理由呢？

下面是一个Memento模式例子，很简单：
package com.pdw.pattern;

import java.io.*;
import java.util.*;

class Originator{
private int number;
private File file;

public File getFile() {
return file;
}

public void setFile(File file) {
this.file = file;
}

public int getNumber() {
return number;
}

public void setNumber(int number) {
this.number = number;
}

public Originator(){}
//创建备份
public Memento getMemento(){
  return new Memento(this);
}
//恢复到原始值
public void setMemento(Memento m){
  this.file=m.getFile();
  this.number=m.getNumber();
}
}
class Memento implements Serializable{
private int number;
private File file;

public File getFile() {
return file;
}

public void setFile(File file) {
this.file = file;
}

public int getNumber() {
return number;
}

public void setNumber(int number) {
this.number = number;
}

public Memento(Originator o){
this.number=o.getNumber();
this.file=o.getFile();
}

}
public class MemebtoImpl {

/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  Originator o=new Originator();
  o.setNumber(100);
  Memento m=o.getMemento();//建备一个备份对象
  o.setNumber(50); //改变对象属性
  o.setMemento(m); //还原
  System.out.println(o.getNumber());
}

}

有猫相伴的日子 2006-07-10 22:58 发表评论

设计模式---Template(模板)

有猫相伴的日子 — Sun, 09 Jul 2006 14:58:00 GMT

定义：
定义一个算法中的骨架，将一些步骤的执行延期到子类，其实JAVA中的操象类就是一个Template模式，因些使用得很普遍，很容易理解。如：
package com.pdw.pattern;

abstract class Benchmark{
public abstract void benchmark();

/**
* 重复执行的次数
* @param count
* @return
*/
public final long repeat(int count){
  long startTime;
  if(count<0){
   return 0;
  }else{
   startTime=System.currentTimeMillis();
   for(int i=0;i    benchmark();
   }
  }
  long stopTime=System.currentTimeMillis();
  return stopTime-startTime;

}
}
class MethodBenchmark extends Benchmark{

public void benchmark() {
  for(int i=0;i<200000;i++){
   System.out.println("i="+i);
  }
}

}

public class TemplateImpl {
/**
* @param args
*/
public static void main(String[] args) {
  Benchmark operation=new MethodBenchmark();
  long d=operation.repeat(1);
  System.out.println("执行一次所需要用的时间："+d);
}

}

有猫相伴的日子 2006-07-09 22:58 发表评论

设计模式----Flyweight(享元)

有猫相伴的日子 — Sun, 09 Jul 2006 14:50:00 GMT

Flyweight的定义：
避免大量拥有相同内容的小类开销（如消耗内存），使大家共享一个类叫元类。
为什么使用：
面向对角的原则是一切都是对象，但如果对象数非常庞大，如果字处理软件，对数据表的DAO操作。等耗内存的操作，我们就要求同存异，找出共同体，设计为一个元类。另外一些特性取决于context是不可共享的。

使用例子如：
package com.pdw.pattern;

import java.util.*;

class CD{
private String title;
private int year;
private Artist artist;

public Artist getArtist() {
  return artist;
}
public void setArtist(Artist artist) {
  this.artist = artist;
}
public String getTitle() {
  return title;
}
public void setTitle(String title) {
  this.title = title;
}
public int getYear() {
  return year;
}
public void setYear(int year) {
  this.year = year;
}

}
class Artist{
private String name;
public String getName(){
  return this.name;
}
public Artist(String n){
  this.name=n;
}

}
class ArtistFactory{

Hashtable flyweights=new Hashtable();
Artist getArtist(String key){
  Artist result;
  result=(Artist)flyweights.get(key);
  if(result==null){
   result=new Artist(key);
   flyweights.put(key,result);
  }
  return result;
}

}

public class FlyweightImpl {

/**
* @param args
*/
public static void main(String[] args) {
  CD cd=new CD();
  ArtistFactory af=new ArtistFactory();
  cd.setArtist(new Artist("李"));
  cd.setTitle("测试");
  cd.setYear(1998);
  Artist va=af.getArtist("裴");
  System.out.println(va.getName());
  af.getArtist("李");

  System.out.println(af.flyweights.size());
}

}

有猫相伴的日子 2006-07-09 22:50 发表评论

设计模式---Adapter(适配器)

有猫相伴的日子 — Mon, 03 Jul 2006 15:03:00 GMT

1 定义：
将两个不兼容的类纠合在一起使用，属于结构型模式，需要有被适配者（Adaptee）和适配器(Adapor)两个身份。
2 为何使用：
我们经常需要将两上没有关系的类组合在一起使用，第一解决方案是修改各自类的接口，便如没有源代码，或者我们不愿意为一个应用而修改接口怎么办，就用Adapter创建混血的组合体。
至于怎么用可以参考《think in java》的“类再生”这一节所提到的两个方式：组合(Composition)和继承(inheritance)

参考例子：
package com.pdw.pattern;
/**
* 两个不兼容的类纠合在一起使用，属于结构模型，需有被适配器（Adaptee)和适配器(Adaptor)两个身份
*
* @author Administrator
*
*/

//打方型
class SquarePeg{
public void insert(String str){
System.out.println("打方型-->"+str);
}
}
//打圆柱型
class RoundPeg{
public void insertIntohole(String msg){
System.out.println("打圆柱型-->"+msg);
}
}

class PegAdapter extends SquarePeg{
private RoundPeg rp;
public PegAdapter(RoundPeg vrp){
  this.rp=vrp;
}
public void insertRound(String str){
  rp.insertIntohole(str);
}
public void insertSquare(String str){
  super.insert(str);
}
}
public class AdapterImpl {

/**
* @param args
*/
public static void main(String[] args) {
  RoundPeg rp=new RoundPeg();
  PegAdapter pg=new PegAdapter(rp);
  pg.insertRound("圆柱型");
  pg.insertSquare("方型");
}

}

有猫相伴的日子 2006-07-03 23:03 发表评论

设计模式之----Facade(外观)

有猫相伴的日子 — Sun, 02 Jul 2006 15:21:00 GMT

实现上就是把各种复的实现的类，操象出一个统一的接口。没找到好的例子！！！

有猫相伴的日子 2006-07-02 23:21 发表评论

设计模式---Singleton

有猫相伴的日子 — Thu, 29 Jun 2006 15:01:00 GMT

单态的作用就不用说了，经常用过，就是一个类只产生一个对象。
它有两个种实现方法。实现在大同小异，可以根据需要改进。
例程如下：
package com.pdw.pattern;

class SingletonA{
private SingletonA(){

}
private static SingletonA _instance=new SingletonA();
public static SingletonA getInstance(){
  return _instance;
}
}
class SingletonB{
private static SingletonB _instance;
public static SingletonB getInstance(){
  if(_instance==null){
   return new SingletonB();
  }else{
   return _instance;
  }

}
}
public class SingletonImpl {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

}

有猫相伴的日子 2006-06-29 23:01 发表评论

设计模式----builder

有猫相伴的日子 — Thu, 29 Jun 2006 14:52:00 GMT

构建模式的定义：
将一个复杂的对象构建与它的表示分离开来，使用样的构建过程可以创建不同的表示。
Builder 模式是一步一步创建一个复杂的对象，它充许用户通过指定复杂对象类型和内容就可以构建它们。用户不需知道其内部细节。Builder非常类似操象工厂模式，只有在使用中才能区别开来。一个使用例子：
package com.pdw.pattern;

/*
* 小对象的创建接口
*/
interface PartA{
public void builderA();
public void outPartAInfo();
}
interface PartB{
public void builderB();
}
/*
* 大对象创建接口
*/
interface Builder{
void buildPartA();
void buildPartB();
Produce getResult();
}

/*
* 产品接口
*/
interface Produce{
public void OutProduceInfo();
}

/*
* 构建部件
*/
class Director{
private Builder builder;

public Director(Builder vbuilder){
  this.builder=vbuilder;
}

public void construct(){
  builder.buildPartA();
  builder.buildPartB();
}

}
/*
* 部件实现类
*/
class PartAImpl implements PartA{

public void builderA() {
// TODO Auto-generated method stub
System.out.print("PartA组装完成...");
}

public void outPartAInfo() {
// TODO Auto-generated method stub
System.out.println("PartA 信息。。。 ");
}

}
class PartBImpl implements PartB{

public void builderB() {
// TODO Auto-generated method stub
System.out.println("构造部件B完成....");
}

}
class ProduceImpl implements Produce{

private PartA pa;
private PartB pb;
private ProduceImpl(){}

public ProduceImpl(PartA pa,PartB pb){
  this.pa=pa;
  this.pb=pb;
}
public void OutProduceInfo() {
  // TODO Auto-generated method stub
  pa.builderA();
  pb.builderB();
  pa.outPartAInfo();
  System.out.println("这里输入了产品信息，当然产品还有很多功能方法没写呵");
}

}
class Cbuilder implements Builder{
PartA pa;
PartB pb;
public void buildPartA() {
  pa=new PartAImpl(); //具体子部件实现代码

}

public void buildPartB() {

pb=new PartBImpl();
}

public Produce getResult() {
ProduceImpl pi=new ProduceImpl(pa,pb);
return pi;
}

}

public class BuilderImpl {

/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  Cbuilder builder=new Cbuilder();
  Director d=new Director(builder);
  d.construct();
  Produce p=builder.getResult();
  p.OutProduceInfo();
}

}

有猫相伴的日子 2006-06-29 22:52 发表评论

设计模式之--Prototype

有猫相伴的日子 — Wed, 28 Jun 2006 15:26:00 GMT

用原型实例指定创建对象的种类，并且都过拷贝这些原型建建新的对象。
prototype模式充许一个对象再创建另一个可定制的对象，根本无需知道创建的细节。
java中提供了clone()来实现对象克隆。所以prototype模式变得了很简单。请参考以下例程：
package com.pdw.pattern;

abstract class AbsHello implements Cloneable{

String username;

public String getUsername() {
return username;
}

public void setUsername(String username) {
  this.username = username;
}

public abstract void sayHello();

public Object clone(){
  Object object=null;
  try{
   object=super.clone();

  }catch(Exception e){
   System.err.println(e);
  }
  return object;
}
}
class OneHello extends AbsHello{
public OneHello(){
  setUsername("peidw");
}
@Override
public void sayHello() {
  // TODO Auto-generated method stub
  System.out.println("OneHello-->SayHello to "+username);
}

}

class TwoHello extends AbsHello{
public TwoHello(){
  setUsername("pxm");
}
@Override
public void sayHello() {
  // TODO Auto-generated method stub
  System.out.println("TwoHello-->sayHello to "+username);
}

}

public class Prototype {

/**
* @param args
*/
public static void main(String[] args) {
  // TODO Auto-generated method stub
  AbsHello oneh=new OneHello();
  AbsHello twoh=new TwoHello();
  oneh.sayHello();
  twoh.sayHello();
}

}

有猫相伴的日子 2006-06-28 23:26 发表评论

设计模式之Factory

有猫相伴的日子 — Wed, 28 Jun 2006 14:54:00 GMT

package com.pdw.pattern;

interface Me{
public void sayHello();
public void sayBay();
}

class SampleFacotry implements Me{

public void sayHello() {
// TODO Auto-generated method stub
System.out.println("sampleFacotry->SayHello....");
}

public void sayBay() {
// TODO Auto-generated method stub
System.out.println("sampleFacotry->Bay....");
}

}
class PPFacotry implements Me{

public void sayHello() {
// TODO Auto-generated method stub
System.out.println("PPFacotry-->"+"Say Hello");
}

public void sayBay() {
  // TODO Auto-generated method stub
  System.out.println("PPFacotry-->"+"Say Bay.");
}

}
/**
   * 以一般工厂方法构造类
   * @author Administrator
   *
   */
class CreateFacotry{
public static Me createFacotry(String aa){
  if(aa.equalsIgnoreCase("Sample")){
   return new SampleFacotry();
  }else if(aa.equalsIgnoreCase("")){
   return new PPFacotry();
  }else{
   return null;
  }
}
}
/**
* 操象工厂的实现。
* @author Administrator
*
*/
abstract class CFacory{
public abstract SampleFacotry mecreator();
public abstract PPFacotry kkmeicreator();
}

class CFacoryImple extends CFacory{

@Override
public SampleFacotry mecreator() {
// TODO Auto-generated method stub
return new SampleFacotry();
}

@Override
public PPFacotry kkmeicreator() {
// TODO Auto-generated method stub
return new PPFacotry();
}

}

public class Facotry {
public static void main(String[] args){
  Me a=CreateFacotry.createFacotry("Sample");
  a.sayHello();
  CFacoryImple cfi=new CFacoryImple();
  Me me=cfi.mecreator();
  Me ppme=cfi.kkmeicreator();
  me.sayBay();
  ppme.sayBay();
}
}

以上这个例程，说明了一般工厂以及操象工厂的实现。
工厂这个构造模式在开发中会经常用到

有猫相伴的日子 2006-06-28 22:54 发表评论