国产精品美乳一区二区免费,亚洲国产精品ⅴa在线观看,宅男av一区二区三区

设计模式�ȝ��Q�State模式

飞熊 — Mon, 18 Jan 2010 14:31:00 GMT

http://www.aygfsteel.com/pengpenglin/archive/2008/04/07/191325.html

飞熊 2010-01-18 22:31 发表评论

设计模式�ȝ��Q�Strategy模式

飞熊 — Mon, 18 Jan 2010 14:29:00 GMT

http://www.aygfsteel.com/pengpenglin/archive/2008/04/08/191422.html

飞熊 2010-01-18 22:29 发表评论

设计模式�ȝ��Q�Visitor模式

飞熊 — Mon, 18 Jan 2010 14:28:00 GMT

http://www.aygfsteel.com/pengpenglin/archive/2008/04/15/193170.html

飞熊 2010-01-18 22:28 发表评论

设计模式�ȝ��-Composite模式

飞熊 — Mon, 18 Jan 2010 14:04:00 GMT

一、Composite模式的定�?br />
��对象以树�Ş�l�构�l�织��h��,以达成“部分－整体�?的层�ơ结构，使得客户端对单个对象和组合对象的使用��h��一致�?/strong>.

二、Composite模式的特�?/strong>

Composite比较�Ҏ��理解�Q�想到Composite��应该想到树形结构图。组合体内这�?strong style="COLOR: red">对象都有共同接口,当组合体一个对象的�Ҏ��被调用执行时�Q�Composite��?strong style="COLOR: red">遍历(Iterator)整个树�Ş�l�构,��L��同样包含�q�个�Ҏ��的对象�ƈ实现调用执行。可以用牵一动百来�Ş宏V�?/span>

所以Composite模式使用到Iterator模式�Q�和Chain of Responsibility模式�c�M��?/span>

三、Composite好处

1.使客��L��调用��单，客户端可以一致的使用�l�合�l�构或其中单个对象，用户��׃��必关�p�自己处理的是单个对象还是整个组合结构，�q�就��化了客户端代码�?br />2.更容易在�l�合体内加入对象部�g. 客户端不必因为加入了新的对象部�g而更改代码�?/span>

四、如何��用Composite

首先定义一个接口或抽象�c�，�q�是设计模式通用方式了，其他设计模式�Ҏ��口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和��理Composite�l�合体的对象们（或称部�gComponent�Q?

---- 以上内容摘自Jdon�|�站的《Gof 23�U�设计模式》系列文�?br />
五、Composite模式的分�?/strong>

·Composite模式的结构：
基类/接口(构�g抽象)
    |
    |--- 原子构�g(extends 基类 / implements 接口)
    |
    |--- �l�合构�g(extends 基类 / implements 接口)
               |--- 原子构�g1
               |--- 原子构�g2
               |--- �l�合构�g3
　　　　　　         |--- 原子构�g3-1
                        |--- 原子构�g3-2

·Composite模式的特点：
   ·Composite模式一般都有一个抽象类或接口来表示最基本的构件�?br />   ·Composite模式一般都�׃��c�d��象构成：表示单个元素的对�?Primitive)和表�C�多个元素组合的对象(Composite)
   ·Composite模式下Primitive和Composite对象都��承或实现上层接口或父�c?br />   ·Composite模式下每个构仉��含有三个基础�Ҏ��Q�add(构�g)、remove(构�g)、iterator()
   ·Composite对象含有一个用来保存其下所有基��元素的的集合�Q�例如：Vector�Q�ArrayList�Q�HashMap
   ·Composite对象的方法被调用时一般都会引起其下所有基��元素相同�Ҏ��的调用，即递归调用�?br />
·Composite模式中Primitive对象和Composite对象的方法区别：
   ·add(构�g)�Q�如果是基础对象�Q�则此方法直接返回false�Q�如果是�l�合对象�Q�则先添加新构�g然后�q�回true
   ·remove(构�g)�Q�如果是基础对象�Q�则此方法直接返回false�Q�如果是�l�合对象�Q�则先删除构件然后返回true
   ·iterator()�Q�如果是基础对象�Q�则此方法直接返回null�Q�如果是�l�合对象�Q�则�q�回一个包含所有对象的集合

·客户端调用Composite模式的代码示例：
   ·创徏一个原子构件对�?br />   ·创徏一个组合构件对�?br />   ·调用�l�合构�g对象的add/remove�Ҏ��d��/删除对象
   ·调用�l�合够对象的iteratore�Ҏ��q�代昄��对象
本文摘自�Q?a href="/pengpenglin/archive/2008/01/21/176675.html">http://www.aygfsteel.com/pengpenglin/archive/2008/01/21/176675.html
�l�：

一个二叉树的例子：
1.Component 是抽象组�?br />Tree 和Leaf �l�承Component

private String name; //树或叶子的名�U?br />addChild(Component leftChild,Component rightChild);
//�l�一个树上加上一个左孩子�Q�一个右孩子
getName(){return name;}
getTreeInfo(){} //得到树或叶子的详�l�信�?br />getLength(); //得到树的高度

2.Tree 二叉树，一个左孩子�Q�一个右孩子

3.Leaf 是叶子节�?br />4.Test 是测试节�?

/** Component.java **************/
package binarytree;

public abstract class Component {
private String name;

public abstract Component addChild(Component leftChild, Component rightChild);

public String getName() {
  return name;
}

public void getTreeInfo() {
}

public abstract int getLength();
}

/** Leaf.java **************/
package binarytree;

public class Leaf extends Component {
private String name;

private Component leaf = null;

public Leaf(String name) {
  this.name = name;
}

public Component addChild(Component leftChild, Component rightChild) {
  return this;
}

public String getName() {
  return name;
}

public int getLength() {
  return 1;
}

public static void main(String[] args) {
}
}

/** Tree.java **************/
package binarytree;

public class Tree extends Component {
private String name;

private Component leftChild;

private Component rightChild;

public Tree(String name, Component leftChild, Component rightChild) {
  this.name = name;
  this.leftChild = leftChild;
  this.rightChild = rightChild;
}

public Tree(String name) {
  this.name = name;
  this.leftChild = null;
  this.rightChild = null;
}

public Component addChild(Component leftChild, Component rightChild) {
  this.leftChild = leftChild;
  this.rightChild = rightChild;
  return this;
}

public String getName() {
  return name;
}

public void getTreeInfo()
// 得到树或叶子的详�l�信�?br /> // 先打印自��q��名字�Q�再遍例左孩子，再遍例右孩子
// 如果左孩子或叛_��子是树，递归调用
{
  System.out.println(" this trees name is " + getName());
  if (this.leftChild instanceof Leaf) {
   System.out.println(getName() + "s left child is "
     + this.leftChild.getName() + ",it is a Leaf");
  }
  if (this.leftChild instanceof Tree) {
   System.out.println(getName() + "s left child is "
     + this.leftChild.getName() + ",it is a Tree");
   this.leftChild.getTreeInfo();
  }
  if (this.leftChild == null) {
   System.out.println(getName() + "s left child is a null");
  }
  if (this.rightChild instanceof Leaf) {
   System.out.println(getName() + "s right child is "
     + this.rightChild.getName() + ",it is a Leaf");
  }
  if (this.rightChild instanceof Tree) {
   System.out.println(getName() + "s right child is "
     + this.rightChild.getName() + ",it is a Tree");
   this.rightChild.getTreeInfo();
  }
  if (this.rightChild == null) {
   System.out.println(getName() + "s right child is a null");
  }
  // System.out.println(getName()+"s 高度 �?"+getLength());
}

public int getLength() {
  // 比较左孩子或叛_��子的高度�Q�谁大，+1 �q�回
  // �I�孩子的处理
  if (this.leftChild == null) {
   if (this.rightChild == null)
    return 1;
   else
    return this.rightChild.getLength() + 1;
  } else {
   if (this.rightChild == null) {
    return this.leftChild.getLength() + 1;
   } else {
    if ((this.leftChild.getLength()) >= (this.rightChild
      .getLength()))
     return this.leftChild.getLength() + 1;
    else
     return this.rightChild.getLength() + 1;
   }
  }
}

public static void main(String[] args) {
}
}

/** Test.java ��试�c?**************/
package binarytree;

public class Test {

public Test() {
}

public static void main(String[] args) {
  Component tree = new Tree("luopeng");
  Component left_child = new Leaf("luopeng1");
  Component right_child = new Leaf("luopeng2");
  tree = tree.addChild(left_child, right_child);
  // tree=tree.addRightChild(right_child);
  tree.getTreeInfo();
  Component tree1 = new Tree("luopeng2");
  tree1.addChild(tree, left_child);
  tree1.getTreeInfo();
  Component tree2 = new Tree("luopeng3");
  tree2.addChild(tree, null);
  tree2.getTreeInfo();
  Component tree4 = new Tree("luopeng4");
  tree4.addChild(null, tree);
  tree4.getTreeInfo();
  System.out.println(tree4.getName() + "的高度是 " + tree4.getLength());
}
}

飞熊 2010-01-18 22:04 发表评论

�q�代器模�?Iterator pattern)

飞熊 — Mon, 18 Jan 2010 13:51:00 GMT

一�?引言
　　�q�代�q�个名词对于熟悉Java的�h来说�l�对不陌生。我们常�怋�用JDK提供的�P代接口进行java collection的遍历：
Iterator it = list.iterator();
while(it.hasNext()){
　//using “it.next();”do some businesss logic
}
而这��是关于�q�代器模式应用很好的例子�?br />
　　二�?定义与结�?/strong>

　　�q�代器（Iterator�Q�模式，又叫做游标（Cursor�Q�模式。GOF�l�出的定义�ؓ�Q�提供一�U�方法访问一个容器（container�Q�对象中各个元素�Q�而又不需暴露该对象的内部�l�节�?br />
　　从定义可见，�q�代器模式是为容器而生。很明显�Q�对容器对象的访问必然涉及到遍历��法。你可以一股脑的将遍历�Ҏ��塞到容器对象中去�Q�或者根本不��L��供什么遍历算法，让��用容器的��己去实现��d��。这两种情况好像都能够解决问题�?br />
　　然而在前一�U�情况，容器承受了过多的功能�Q�它不仅要负责自己“容器”内的元素维护（��d��、删除等�{�）�Q�而且�q�要提供遍历自��n的接口；而且�׃��遍历状态保存的问题�Q�不能对同一个容器对象同时进行多个遍历。第二种方式倒是省事�Q�却又将容器的内部细节暴露无遗�?br />
　　而�P代器模式的出玎ͼ�很好的解决了上面两种情况的弊端。先来看下�P代器模式的真面目吧�?

　　�q�代器模式由以下角色�l�成�Q?br />
　　1) �q�代器角�Ԍ��Iterator�Q�：�q�代器角色负责定义访问和遍历元素的接口�?br />
　　2) 具体�q�代器角�Ԍ��Concrete Iterator�Q�：具体�q�代器角色要实现�q�代器接口，�q�要记录遍历中的当前位置�?br />
　　3) 容器角色�Q�Container�Q�：容器角色负责提供创徏具体�q�代器角色的接口�?br />
　　4) 具体容器角色�Q�Concrete Container�Q�：具体容器角色实现创徏具体�q�代器角色的接口——这个具体�P代器角色于该容器的结构相兟�?br />
　　�q�代器模式的�c�d��如下�Q?br />

　　从结构上可以看出�Q��P代器模式在客户与容器之间加入了�P代器角色。�P代器角色的加入，��可以很好的避免容器内部�l�节的暴�Ԍ��而且也��得设计符号“单一职责原则”�?br />
　　注意�Q�在�q�代器模式中�Q�具体�P代器角色和具体容器角色是耦合在一��L��——遍历算法是与容器的内部�l�节紧密相关的。�ؓ了��客户�E�序从与具体�q�代器角色耦合的困境中��q��出来�Q�避免具体�P代器角色的更换给客户�E�序带来的修改，�q�代器模式抽象了具体�q�代器角�Ԍ��使得客户�E�序更具一般性和重用性。这被称为多态�P代�?br />
　　三�?举例

　　�׃��q�代器模式本�w�的规定比较松散�Q�所以具体实��C��׃��花八门。我们在此仅举一例，�Ҏ��不能��实现方式一一呈现。因此在举例前，我们先来列�D下�P代器模式的实现方式�?

　　1�Q��P代器角色定义了遍历的接口�Q�但是没有规定由谁来控制�q�代。在Java collection的应用中�Q�是由客��L��序来控制遍历的进�E�，被称为外部�P代器�Q�还有一�U�实现方式便是由�q�代器自�w�来控制�q�代�Q�被�U�Cؓ内部�q�代器。外部�P代器要比内部�q�代器灵�z�R��强大，而且内部�q�代器在java语言环境中，可用性很弱�?br />
　　2�Q�在�q�代器模式中没有规定谁来实现遍历��法。好像理所当然的要在�P代器角色中实现。因为既便于一个容器上使用不同的遍历算法，也便于将一�U�遍历算法应用于不同的容器。但是这样就破坏掉了容器的封装——容器角色就要公开自己的私有属性，在java中便意味着向其他类公开了自��q��U�有属性�?br />
　　那我们把它放到容器角色里来实现好了。这栯��P代器角色��p��架空��Z��仅存放一个遍历当前位�|�的功能。但是遍历算法便和特定的容器紧紧�l�在一起了�?br />
　　而在Java Collection的应用中�Q�提供的具体�q�代器角色是定义在容器角色中的内部类。这样便保护了容器的��装。但是同时容器也提供了遍历算法接口，你可以扩展自��q��q�代器�?br />
　　好了�Q�我们来看下Java Collection中的�q�代器是怎么实现的吧�?br />//�q�代器角�Ԍ��仅仅定义了遍历接�?p>public interface Iterator {
　boolean hasNext();
　Object next();
　void remove();
}
//容器角色�Q�这里以List��Z��。它也仅仅是一个接口，��׃��|�列出来�?br />//具体容器角色�Q�便是实��C��List接口的ArrayList�{�类。�ؓ了突出重点这里指�|�列和�P代器相关的内�?br />//具体�q�代器角�Ԍ��它是以内部类的�Ş式出来的。AbstractList是�ؓ了将各个具体容器角色的公共部分提取出来而存在的�?/p>
public abstract class AbstractList extends AbstractCollection implements List {
…�?
//�q�个便是负责创徏具体�q�代器角色的工厂�Ҏ��
public Iterator iterator() {
　return new Itr();
}
//作�ؓ内部�cȝ��具体�q�代器角�?/p>
private class Itr implements Iterator {
　int cursor = 0;
　int lastRet = -1;
　int expectedModCount = modCount;
　public boolean hasNext() {
　　return cursor != size();
　}
　public Object next() {
　　checkForComodification();
　　try {
　　　Object next = get(cursor);
　　　lastRet = cursor++;
　　　return next;
　　} catch(IndexOutOfBoundsException e) {
　　　checkForComodification();
　　　throw new NoSuchElementException();
　　}
　}
　public void remove() {
　　if (lastRet == -1)
　　　throw new IllegalStateException();
　　　checkForComodification();
　　try {
　　　AbstractList.this.remove(lastRet);
　　　if (lastRet < cursor)
　　　　cursor--;
　　　lastRet = -1;
　　　expectedModCount = modCount;
　　} catch(IndexOutOfBoundsException e) {
　　　throw new ConcurrentModificationException();
　　}
　}
　final void checkForComodification() {
　　if (modCount != expectedModCount)
　　　throw new ConcurrentModificationException();
　}
}
至于�q�代器模式的使用。正如引�a�中所列那��P��客户�E�序要先得到具体容器角色�Q�然后再通过具体容器角色得到具体�q�代器角艌Ӏ�这样便可以使用具体�q�代器角色来遍历容器了…�?br />
　　四�?实现自己的�P代器

　　在实现自��q��q�代器的时候，一般要操作的容器有支持的接口才可以。而且我们�q�要注意以下问题�Q?

　　在�P代器遍历的过�E�中�Q�通过该�P代器�q�行容器元素的增减操作是否安全呢�Q?br />
　　在容器中存在复合对象的情况，�q�代器怎样才能支持深层遍历和多�U�遍历呢�Q?br />
　　以上两个问题对于不同�l�构的容器角�Ԍ��各不相同�Q�值得考虑�?br />
　　五�?适用情况

　　�׃��面的讲述�Q�我们可以看��P代器模式�l�容器的应用带来以下好处�Q?br />
　　1) 支持以不同的方式遍历一个容器角艌Ӏ�根据实现方式的不同�Q�效果上会有差别�?br />
　　2) ��化了容器的接口。但是在java Collection中�ؓ了提高可扩展性，容器�q�是提供了遍历的接口�?br />
　　3) 对同一个容器对象，可以同时�q�行多个遍历。因为遍历状态是保存在每一个�P代器对象中的�?br />
　　由此也能得出�q�代器模式的适用范围�Q?br />
　　1) 讉K��一个容器对象的内容而无需暴露它的内部表示�?br />
　　2) 支持对容器对象的多种遍历�?br />
　　3) 为遍历不同的容器�l�构提供一个统一的接口（多态�P代）�?br />
实例�Q?br />

public class IteratorDemo {
private List strList;

public IteratorDemo() {
  strList = new ArrayList();
}

public void add(String item) {
  strList.add(item);
}

public String remove(int index) {
  String item = strList.get(index);
  strList.remove(index);
  return item;
}

public Iterator iterator() {
  return new Iterator() {
   // 游标
   private int cursor = 0;

   public boolean hasNext() {
    return cursor < strList.size();
   }

   public String next() {
    return strList.get(cursor++);
   }

   public void remove() {

   }

  };
}

public static void main(String[] args) {
  IteratorDemo demo = new IteratorDemo();
  demo.add("1");
  demo.add("2");
  demo.add("3");
  demo.add("4");

  Iterator iterator = demo.iterator();
  while (iterator.hasNext()) {
   System.out.println(iterator.next());
  }
}
}

飞熊 2010-01-18 21:51 发表评论

Java设计模式使用率排行榜

飞熊 — Sun, 17 Jan 2010 14:28:00 GMT

Java设计模式使用率爬行榜

使用频率所属类�?/td> 模式名称模式 ��单定�?/td>

5 创徏�?/td> Singleton 单例模式保证一个类只有一个实例，�q�提供一个访问它的全局讉K��炏V�?/td>

5 �l�构�?/td> Composite 复合模式 ��对象组合成树�Ş�l�构以表�C�部分整体的关系�Q�Composite使得用户对单个对象和�l�合对象的��用具有一致性�?/td>

5 �l�构�?/td> FASADE 面模�?/td> 为子�pȝ��中的一�l�接口提供一致的界面�Q�fasade提供了一高层接口�Q�这个接口��得子�pȝ��更容易��用�?/td>

5 �l�构�?/td> Proxy 代理为其他对象提供一�U�代理以控制对这个对象的讉K��

5 行�ؓ�?/td> Iterator �q�代�?/td> 提供一个方法顺序访问一个聚合对象的各个元素�Q�而又不需要暴露该对象的内部表�C��?/td>

5 行�ؓ�?/td> Observer 观察�?/td> 定义对象间一对多的依赖关�p�，当一个对象的状态发生改变时�Q�所有依赖于它的对象都得到通知自动更新�?/td>

5 行�ؓ�?/td> Template Method 模板�Ҏ�� 定义一个操作中的算法的骨架�Q�而将一些步骤�g�q�到子类中，TemplateMethod使得子类可以不改变一个算法的�l�构卛_��以重定义该算法得某些特定步骤�?/td>

4 创徏�?/td> Abstract Factory 抽象工厂提供一个创��Z��p�d��相关或相互依赖对象的接口�Q�而无��L��定它们的具体�c�R�?/td>

4 创徏�?/td> Factory Method 工厂�Ҏ�� 定义一个用于创建对象的接口�Q�让子类军_��实例化哪一个类�Q�Factory Method使一个类的实例化延迟��C��子类�?/td>

4 �l�构�?/td> Adapter 适配�?/td> ��一�cȝ��接口转换成客户希望的另外一个接口，Adapter模式使得原本�׃��接口不兼容而不能一起工作那些类可以一起工作�?/td>

4 �l�构�?/td> Decrator 装饰模式动态地�l�一个对象增加一些额外的职责�Q�就增加的功能来��_��Decorator模式相比生成子类更加灉|��?/td>

4 行�ؓ�?/td> Command 指��o模式 ��一个请求封装�ؓ一个对象，从而��你可以用不同的请求对客户�q�行参数化，对请求排队和记录��h��日志�Q�以及支持可撤销的操作�?/td>

4 行�ؓ�?/td> State 状态模�?/td> 允许对象在其内部状态改变时改变他的行�ؓ。对象看��h��g��改变了他的类�?/td>

4 行�ؓ�?/td> Strategy �{�略模式定义一�p�d��的算法，把他们一个个��装��h��Q��ƈ使他们可以互相替换，本模式��得算法可以独立于使用它们的客戗��?/td>

3 创徏�?/td> Builder 生成�?/td> ��一个复杂对象的构徏与他的表�C�相分离�Q��得同��L��构徏�q�程可以创徏不同的表�C��?/td>

3 �l�构�?/td> Bridge 桥模�?/td> ��抽象部分与它的实现部分相分��，使他们可以独立的变化�?/td>

3 行�ؓ�?/td> Chain of Responsibility 职责�?/td> 使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系

2 创徏�?/td> Prototype 原型用原型实例指定创建对象的�U�类�Q��ƈ且通过拯��q�些原型来创建新的对象�?/td>

2 �l�构�?/td> Flyweight 享元

2 行�ؓ�?/td> Mediator 中介�?/td> 用一个中介对象封装一些列的对象交互�?/td>

2 行�ؓ�?/td> Visitor 讉K��?/td> 表示一个作用于某对象结构中的各元素的操作，它��你可以在不改变各元素�cȝ��前提下定义作用于�q�个元素的新操作�?/td>

1 行�ؓ�?/td> Interpreter 解释�?/td> �l�定一个语�a��Q�定义他的文法的一个表�C�，�q�定义一个解释器�Q�这个解释器使用该表�C�来解释语言中的句子�?/td>

1 行�ؓ�?/td> Memento 备忘�?/td> 在不破坏对象的前提下�Q�捕获一个对象的内部状态，�q�在该对象之外保存这个状态�?/td>

转自2004�q?期《CSDN开发高手�?/p>

飞熊 2010-01-17 22:28 发表评论

Java解读--桥接Bridge

飞熊 — Sun, 17 Jan 2010 12:39:00 GMT
     摘要: 1、核心意图： ��抽象部分和实现部分分离�Q��它们都可以独立的变化�? 该模式的目标是通过把高层的抽象和底层的实现分开�Q�分别构��q��c�d��ơ结构，�q��过实现部分的接口将两部分进行桥接，从而达到高层抽象和底层实现可以独立的方便扩展的目的。其核心是分��，和委托�? 2、��n边实例： Java语言的一个非帔R��要的特点是��^台的无关性，对于一般的高��语言...  阅读全文

飞熊 2010-01-17 20:39 发表评论

飞熊 — Sun, 17 Jan 2010 10:15:00 GMT

核心提示�Q�观察者模�?Java自定义事�?[正文]: MyEventTest.java: package wintys.event; import javax.swing.event.EventListenerList; import java.util.Date; import java.text.DateFormat; import java.text.SimpleDateFormat; /** *Java的事件机�?自定义事�? �q?
观察者模�?Java自定义事�?/strong>

MyEventTest.java:

package wintys.event;

import javax.swing.event.EventListenerList;

import java.util.Date;

import java.text.DateFormat;

import java.text.SimpleDateFormat;



/**

* Java的事件机�?自定义事�?

�q�行�l�果:

do something interesting in source here.

listener detects [event]:wintys.event.MyEvent[source=wintys.event.MySource@18158

59] [occur at]:2009-10-11 16:27:49

listener detects [event]:wintys.event.MyEvent[source=wintys.event.MySource@18158

59] [occur at]:2009-10-11 16:27:49

* @version 2009-10-11

* @author 天堂露珠 (wintys@gmail.com)

* @see http://www.aygfsteel.com/wintys

*/

class MyEventTest{

     public static void main(String[] args){

        MySource source = new MySource();

        MyListener myListener = new MyListener(){

             public void doMyAction(MyEvent e){

                System.out.println( "listener detects " + e);

            }

        };

        source.addMyListener(myListener);

        source.addMyListener(myListener);

        source.addMyListener(myListener);

        source.removeMyListener(myListener);



        source.doSomething();

    }

}



/**

* 自定义的事�g.

* @version 2009-10-11

* @author 天堂露珠(wintys@gmail.com)

* @see http://www.aygfsteel.com/wintys

*/

class MyEvent extends java.util.EventObject{

     private Date date; //记录事�g发生的时闾b?



     public MyEvent(Object source , Date date){

         super (source);



         this .date = date;

    }



     public String toString(){

        DateFormat df = new SimpleDateFormat( "yyyy-MM-dd HH:mm:ss" );

        String dt = df.format(date);



         return "[event]:" + super .toString() + " [occur at]:" + dt;

    }

}



/**

* 自定义事件监听器接口.

* @version 2009-10-11

* @author 天堂露珠(wintys@gmail.com)

* @see http://www.aygfsteel.com/wintys

*/

interface MyListener extends java.util.EventListener{

     void doMyAction(MyEvent e);

}



/**

* 自定义事件源.

* @version 2009-10-11

* @author 天堂露珠(wintys@gmail.com)

* @see http://www.aygfsteel.com/wintys

*/

class MySource{

     /**

     * 保存注册的监听器列表.

     * 子类可以使用它保存自��q��事�g监听�?非MyListener监听�?列表.

     */

     protected EventListenerList listenerList = new EventListenerList();

     private MyEvent myEvent = null ; //fireDoMyAction()使用此变量�?



     /**

     * 没有做�Q何事

     */

     public MySource(){

    }

     /**

     * ��d��一个MyListener监听器�?

     */

     public void addMyListener(MyListener listener){

        listenerList.add(MyListener. class , listener);

    }



     /**

     * �U�除一个已注册的MyListener监听�?

     * 如果监听器列表中已有相同的监听器listener1、listener2,

     * �q�且listener1==listener2,

     * 那么只移除最�q�注册的一个监听器。�?

     */

     public void removeMyListener(MyListener listener){

        listenerList.remove(MyListener. class , listener);

    }



     /**

     * @return 在此对象上监听的所有MyListener�c�d��的监听器

     */

     public MyListener[] getMyListeners(){

         return (MyListener[])listenerList.getListeners(MyListener. class );

    }



     //Winty:Copy directly from javax.swing.event.EventListenerList

     /*Notify all listeners that have registered interest for

       notification on this event type.  The event instance

       is lazily created using the parameters passed into

       the fire method.

     */

     protected void fireDoMyAction() {

          // getListenerList() Guaranteed to return a non-null array

         Object[] listeners = listenerList.getListenerList();

          // Process the listeners last to first, notifying

          // those that are interested in this event

         for ( int i = listeners.length- 2 ; i>= 0 ; i-= 2 ) {

             if (listeners[i]==MyListener. class ) {

                 // Lazily create the event:

                 if (myEvent == null )

                    myEvent = new MyEvent( this , new Date());

                ((MyListener)listeners[i+ 1 ]).doMyAction(myEvent);

            }

        }

    }



     /**

     * 做一些事件源应该做的有意义的事，然后通知监听�?

     * �q�里只是一个示例方�?

     * 例如:MySource如果是一个按钮，则doSomething()��可以命名�ؓclick(),

     * 当用��L��L��钮时调用click()�Ҏ��.

     */

     public void doSomething() {

        System.out.println( "do something interesting here." );



        fireDoMyAction(); //通知监听器�?

    }

}

         EventListenerList是特别需要说明的�Q�它内部使用一个Object数组存放监听器。但是它�q�不是直接存放，而是先存监听器的class�c�d��Q�然后再存监听器本��n。即存放(MyListener.class , myListener)。一个Object数组可以存放多种�c�d��的Listener�Q�如果还有一�U�监听器AnotherListener�Q�那�?AnotherListener.class , anotherListener)也可以存放。无论增删都是两个对象一同被��d��或删除。上�q�C��码中的listenerList.add(MyListener.class , listener)或listenerList.remove(MyListener.class , listener)�Q�以及fireDoMyAction()中的"i-=2"�Q�就是这��h��作的�?/strong>

飞熊 2010-01-17 18:15 发表评论

适配器Adapter

飞熊 — Sun, 17 Jan 2010 09:54:00 GMT

1.意图:
            ��一个类的接口�{换成客户希望的另一个接口。Adapter模式使得原来�׃��版本不兼容而不能在一��L��够哦那个做的那些�c�d��以在一起工作。有�Ӟ��为复用而设计的工具��q��不能够被复用的原因仅仅是因�ؓ它的接口与专业应用领域所需要的接口不匹配�?br />2.适配器模式有�cȝ��适配器模式和对象的适配器模式两�U�不同的形式�?br />
一、类的适配器模�?br />    �cȝ��适配器模式把适配的类的API转换成目标类的API�?

目标(Target)角色�Q�这��是所期待得到的接口�?

�?Adaptee)角色�Q�现有需要适配的接口�?

适配�?Adapter)角色�Q�适配器类是本模式的核心。适配器把源接口�{换成目标接口。显然这一角色不可以是接口�Q�而必��L��具体�c�R�?

/**
* 定义Client使用的与特定领域相关的接�?br /> */
public interface Target {
    void sampleOperation1();
    void sampleOperation2();
}
/**
* 定义一个已�l�存在的接口�Q�这个接口需要适配
*/
public class Adaptee {
    public void sampleOperation1() {
        // ......
    }
}
/**
* 对Adaptee与Target接口�q�行适配
*/
public class Adapter extends Adaptee implements Target {
    public void sampleOperation2() {
        // ......
    }
}

二、对象适配�?br />    与类的适配器模式一��P��对象适配器模式把适配的类的API转换成�ؓ目标�cȝ��API�Q�与�cȝ��适配器模式不同的是，对象的适配器模式不是��用��承关�p�连接到Adaptee�c�，而是使用委派关系�q�接到Adaptee�c�R��示意代码如下：
/**
* 定义Client使用的与特定领域相关的接�?br /> */
public interface Target {
    void sampleOperation1();
    void sampleOperation2();
}
/**
* 定义一个已�l�存在的接口�Q�这个接口需要适配
*/
public class Adaptee {
    public void sampleOperation1() {
        // ......
    }
}
/**
* 对Adaptee与Target接口�q�行适配
*/
public class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        super();
        this.adaptee = adaptee;
    }
    public void sampleOperation1() {
        adaptee.sampleOperation1(); // 看点
    }
    public void sampleOperation2() {
        // ......
    }
}

�c�适配器模式和对象适配器模式的异同�Q�Target接口和Adaptee�c�都相同�Q�不同的是类适配器的Adapter�l�承Adaptee实现Target�Q�对象适配器的Adapter实现Target聚集Adaptee�?br />
适配器模式的用意是将接口不同而功能相同或者相�q�的两个接口加以转换�?br />

飞熊 2010-01-17 17:54 发表评论

飞熊 — Sun, 17 Jan 2010 09:53:00 GMT
aa

飞熊 2010-01-17 17:53 发表评论

Java代理模式及动态代理类

飞熊 — Sun, 17 Jan 2010 08:52:00 GMT

1.       代理模式

代理模式的作用是�Q��ؓ其他对象提供一�U�代理以控制对这个对象的讉K��。在某些情况下，一个客户不��x��者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用�?/span>

代理模式一般涉及到的角色有�Q?/span>

抽象角色 �Q�声明真实对象和代理对象的共同接口；

代理角色 �Q�代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在�Q何时刻都能代替真实对象。同�Ӟ��代理对象可以在执行真实对象操作时�Q�附加其他的操作�Q�相当于对真实对象进行封装�?/span>

真实角色 �Q�代理角色所代表的真实对象，是我们最�l�要引用的对象�?/span> ( 参见文献 1)

以下以�?/span> Java 与模式》中的示例�ؓ例：

抽象角色�Q?/span>

abstract public class Subject

{

    abstract public void request();

}

真实角色�Q�实��C�� Subject �?/span> request() �Ҏ��?/span>

public class RealSubject extends Subject

{

       public RealSubject()

       {

       }



       public void request()

       {

              System.out.println("From real subject.");

       }

}

代理角色�Q?/span>

public class ProxySubject extends Subject

{

    private RealSubject realSubject; // 以真实角色作��Z��理角色的属�?/span>



       public ProxySubject()

       {

       }

       public void request() // 该方法封装了真实对象�?/span> request �Ҏ��

       {

        preRequest();

              if( realSubject == null )

        {

                     realSubject = new RealSubject();

              }

        realSubject.request(); // 此处执行真实对象�?/span> request �Ҏ��

        postRequest();

       }

    private void preRequest()

    {

        //something you want to do before requesting

    }

    private void postRequest()

    {

        //something you want to do after requesting

    }

}

客户端调用：

Subject sub=new ProxySubject();

Sub.request();

       �׃��上代码可以看出，客户实际需要调用的�?/span> RealSubject �cȝ�� request() �Ҏ��Q�现在用 ProxySubject 来代�?/span> RealSubject �c�，同样辑ֈ�目的�Q�同时还��装了其他方�?/span> (preRequest(),postRequest()) �Q�可以处理一些其他问题�?/span>

       另外�Q�如果要按照上述的方法��用代理模式，那么真实角色必须是事先已�l�存在的�Q��ƈ��其作�ؓ代理对象的内部属性。但是实际��用时�Q�一个真实角色必��d��应一个代理角�Ԍ��如果大量使用会导致类的急剧膨胀�Q�此外，如果事先�q�不知道真实角色�Q�该如何使用代理呢？�q�个问题可以通过 Java 的动态代理类来解冟�?/span>

2. 动态代理类

       Java 动态代理类位于 Java.lang.reflect 包下�Q�一般主要涉及到以下两个�c�：

(1). Interface InvocationHandler �Q�该接口中仅定义了一个方�?/span> Object �Q?/span> invoke(Object obj,Method method, Object[] args) 。在实际使用�Ӟ��W�一个参�?/span> obj 一般是指代理类�Q?/span> method 是被代理的方法，如上例中�?/span> request() �Q?/span> args ��Ҏ��的参数数�l�。这个抽象方法在代理�c�M��动态实现�?/span>

(2).Proxy �Q�该�c�d��为动态代理类�Q�作用类��g��上例中的 ProxySubject �Q�其中主要包含以下内容：

Protected Proxy(InvocationHandler h) �Q�构造函敎ͼ�估计用于�l�内部的 h 赋倹{�?/span>

Static Class getProxyClass (ClassLoader loader, Class[] interfaces) �Q�获得一个代理类�Q�其�?/span> loader 是类装蝲器， interfaces 是真实类所拥有的全部接口的数组�?/span>

Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) �Q�返回代理类的一个实例，�q�回后的代理�c�d��以当作被代理�c�M��?/span> ( 可��用被代理�cȝ��?/span> Subject 接口中声明过的方�?/span> ) �?/span>

       所�?/span> Dynamic Proxy 是这样一�U?/span> class �Q�它是在�q�行时生成的 class �Q�在生成它时你必��L��供一�l?/span> interface �l�它�Q�然后该 class ��宣�U�它实现了这�?/span> interface 。你当然可以把该 class 的实例当作这�?/span> interface 中的��M��一个来用。当然啦�Q�这�?/span> Dynamic Proxy 其实��是一�?/span> Proxy �Q�它不会替你作实质性的工作�Q�在生成它的实例时你必须提供一�?/span> handler �Q�由它接��实际的工作�?/span> ( 参见文献 3)

    在��用动态代理类�Ӟ��我们必须实现 InvocationHandler 接口�Q�以�W�一节中的示例�ؓ例：

抽象角色 ( 之前是抽象类�Q�此处应改�ؓ接口 ) �Q?/span>

public interface Subject

{

    abstract public void request();

}

具体角色 RealSubject �Q�同上；

代理角色�Q?/span>

import java.lang.reflect.Method;

import java.lang.reflect.InvocationHandler;

public class DynamicSubject implements InvocationHandler {

private Object sub;

public DynamicSubject() {

}

public DynamicSubject(Object obj) {

    sub = obj;

}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    System.out.println("before calling " + method);

    method.invoke(sub,args);

    System.out.println("after calling " + method);

    return null;

}

}

       该代理类的内部属性�ؓ Object �c�，实际使用旉��过该类的构造函�?/span> DynamicSubject(Object obj) 对其赋��|��此外�Q�在该类�q�实��C�� invoke �Ҏ��Q�该�Ҏ��中的

method.invoke(sub,args);

其实��是调用被代理对象的��要被执行的�Ҏ��Q�方法参�?/span> sub 是实际的被代理对象， args 为执行被代理对象相应操作所需的参数。通过动态代理类�Q�我们可以在调用之前或之后执行一些相��x��作�?/span>

客户�?/span> �Q?/span>

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

public class Client

{

    static public void main(String[] args) throws Throwable

       {

      RealSubject rs = new RealSubject(); // 在这里指定被代理�c?/span>

      InvocationHandler ds = new DynamicSubject(rs); // 初始化代理类

       Class cls = rs.getClass();

      // 以下是分解步�?/span>

      /*

     Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces()) ;

     Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});

     Subject subject =(Subject) ct.newInstance(new Object[]{ds});

     */

     // 以下是一�ơ性生�?/span>

      Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),

                                 cls.getInterfaces(),ds );

      subject.request();

}

       通过�q�种方式�Q�被代理的对�?/span> (RealSubject) 可以在运行时动态改变，需要控制的接口 (Subject 接口 ) 可以在运行时改变�Q�控制的方式 (DynamicSubject �c?/span> ) 也可以动态改变，从而实��C��非常灉|��的动态代理关�p?/span> ( 参见文献 2) �?/span>

飞熊 2010-01-17 16:52 发表评论

单例模式

飞熊 — Thu, 14 Jan 2010 14:55:00 GMT

1.饿汉式单例类
public class Singleton {

　　private Singleton(){}

　　//在自己内部定义自�׃��个实例，是不是很奇怪？
　　//注意�q�是private 只供内部调用

　　private static Singleton instance = new Singleton();

　　//�q�里提供了一个供外部讉K��本class的静态方法，可以直接讉K��　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}

2.懒汉式单例类
public class Singleton2 {
    //�U�有的默认构造子
    private Singleton2() {}

    //注意�Q�这里没有final
    private static Singleton2 single;

    //只实例化一��?/span>
    static{
        single = new Singleton2();
    }

    //静态工厂方法�?/span>
    public synchronized  static Singleton2 getInstance() {
         if (single == null) {
             single = new Singleton2();
         }
        return single;
    }
}
        上面�l�出懒汉式单例类实现里对静态工厂方法��用了同步化，以处理多�U�程环境。有些设计师在这里徏议��用所谓的"双重��查成�?.必须指出的是�Q?双重��查成�?不可以在Java 语言中��用。不十分熟悉的读者，可以看看后面�l�出的小节�?同样�Q�由于构造子是私有的�Q�因此，此类不能被��ѝ��饿汉式单例�c�d��自己被加载时��将自己实例化。即便加载器是静态的�Q�在饿汉式单例类被加载时仍会��自己实例化。单从资源利用效率角度来�Ԍ��q�个比懒汉式单例�cȝ��差些。从速度和反应时间角度来�Ԍ��则比懒汉式单例类�E�好些。然而，懒汉式单例类在实例化�Ӟ��必须处理好在多个�U�程同时首次引用此类时的讉K��限制问题�Q�特别是当单例类作�ؓ资源控制器，在实例化时必然涉及资源初始化�Q�而资源初始化很有可能耗费旉��。这意味着出现多线�E�同旉��ơ引用此�cȝ��机率变得较大�?br />
3.单例模式 -- 双重��查锁机制
public class DoubleLockSingleton {
    private static DoubleLockSingleton instance = null;
    private DoubleLockSingleton() {
    }

    public static DoubleLockSingleton getInstance()
   {
     if (instance == null)
     {
       synchronized(DoubleLockSingleton .class) { //1
         if (instance == null)          //2
           instance = new DoubleLockSingleton (); //3
       }
     }
     return instance;
   }
}
Singleton的好处还在于可以节省内存�Q�因为它限制�?br />实例的个敎ͼ�有利于Java垃圾回收�Q�garbage collection�Q��?br />
4.发明者是Google公司的Bob lee:
public   class Singleton   {

   static   class SingletonHolder   {
     static Singleton instance =   new Singleton();
}

   public   static Singleton getInstance()   {
     return SingletonHolder.instance;
}

}

飞熊 2010-01-14 22:55 发表评论

使用频率	所属类�?/td>	模式名称	模式	��单定�?/td>
5	创徏�?/td>	Singleton	单例模式	保证一个类只有一个实例，�q�提供一个访问它的全局讉K��炏V�?/td>
5	�l�构�?/td>	Composite	复合模式	��对象组合成树�Ş�l�构以表�C�部分整体的关系�Q�Composite使得用户对单个对象和�l�合对象的��用具有一致性�?/td>
5	�l�构�?/td>	FASADE	面模�?/td>	为子�pȝ��中的一�l�接口提供一致的界面�Q�fasade提供了一高层接口�Q�这个接口��得子�pȝ��更容易��用�?/td>
5	�l�构�?/td>	Proxy	代理	为其他对象提供一�U�代理以控制对这个对象的讉K��
5	行�ؓ�?/td>	Iterator	�q�代�?/td>	提供一个方法顺序访问一个聚合对象的各个元素�Q�而又不需要暴露该对象的内部表�C��?/td>
5	行�ؓ�?/td>	Observer	观察�?/td>	定义对象间一对多的依赖关�p�，当一个对象的状态发生改变时�Q�所有依赖于它的对象都得到通知自动更新�?/td>
5	行�ؓ�?/td>	Template Method	模板�Ҏ��	定义一个操作中的算法的骨架�Q�而将一些步骤�g�q�到子类中，TemplateMethod使得子类可以不改变一个算法的�l�构卛_��以重定义该算法得某些特定步骤�?/td>
4	创徏�?/td>	Abstract Factory	抽象工厂	提供一个创��Z��p�d��相关或相互依赖对象的接口�Q�而无��L��定它们的具体�c�R�?/td>
4	创徏�?/td>	Factory Method	工厂�Ҏ��	定义一个用于创建对象的接口�Q�让子类军_��实例化哪一个类�Q�Factory Method使一个类的实例化延迟��C��子类�?/td>
4	�l�构�?/td>	Adapter	适配�?/td>	��一�cȝ��接口转换成客户希望的另外一个接口，Adapter模式使得原本�׃��接口不兼容而不能一起工作那些类可以一起工作�?/td>
4	�l�构�?/td>	Decrator	装饰模式	动态地�l�一个对象增加一些额外的职责�Q�就增加的功能来��_��Decorator模式相比生成子类更加灉\|��?/td>
4	行�ؓ�?/td>	Command	指��o模式	��一个请求封装�ؓ一个对象，从而��你可以用不同的请求对客户�q�行参数化，对请求排队和记录��h��日志�Q�以及支持可撤销的操作�?/td>
4	行�ؓ�?/td>	State	状态模�?/td>	允许对象在其内部状态改变时改变他的行�ؓ。对象看��h��g��改变了他的类�?/td>
4	行�ؓ�?/td>	Strategy	�{�略模式	定义一�p�d��的算法，把他们一个个��装��h��Q��ƈ使他们可以互相替换，本模式��得算法可以独立于使用它们的客戗��?/td>
3	创徏�?/td>	Builder	生成�?/td>	��一个复杂对象的构徏与他的表�C�相分离�Q��得同��L��构徏�q�程可以创徏不同的表�C��?/td>
3	�l�构�?/td>	Bridge	桥模�?/td>	��抽象部分与它的实现部分相分��，使他们可以独立的变化�?/td>
3	行�ؓ�?/td>	Chain of Responsibility	职责�?/td>	使多个对象都有机会处理请求，从而避免请求的送发者和接收者之间的耦合关系
2	创徏�?/td>	Prototype	原型	用原型实例指定创建对象的�U�类�Q��ƈ且通过拯��q�些原型来创建新的对象�?/td>
2	�l�构�?/td>	Flyweight	享元
2	行�ؓ�?/td>	Mediator	中介�?/td>	用一个中介对象封装一些列的对象交互�?/td>
2	行�ؓ�?/td>	Visitor	讉K��?/td>	表示一个作用于某对象结构中的各元素的操作，它��你可以在不改变各元素�cȝ��前提下定义作用于�q�个元素的新操作�?/td>
1	行�ؓ�?/td>	Interpreter	解释�?/td>	�l�定一个语�a��Q�定义他的文法的一个表�C�，�q�定义一个解释器�Q�这个解释器使用该表�C�来解释语言中的句子�?/td>
1	行�ؓ�?/td>	Memento	备忘�?/td>	在不破坏对象的前提下�Q�捕获一个对象的内部状态，�q�在该对象之外保存这个状态�?/td>

国产精品美乳一区二区免费,亚洲国产精品ⅴa在线观看,宅男av一区二区三区

设计模式�ȝ���Q�State模式

设计模式�ȝ���Q�Strategy模式

设计模式�ȝ���Q�Visitor模式

设计模式�ȝ��-Composite模式

�q�代器模�?Iterator pattern)

Java设计模式使用率排行榜

Java解读--桥接Bridge

适配器Adapter

Java代理模式及动态代理类

单例模式

设计模式�ȝ��Q�State模式

设计模式�ȝ��Q�Strategy模式

设计模式�ȝ��Q�Visitor模式