亚洲AV无码一区二三区,亚洲国产一区在线,亚洲尹人香蕉网在线视颅

Mon, 24 Sep 2007 15:36:00 GMT

�c�L��没有行�ؓ的，只有对象才可能有行�ؓ�Q�但对象的行��定是��q��来定义的�?br /> 今天讲要10个行��计模式，��C��它们的思想�Q?br /> 1�?span lang="EN-US">Template�Q�模版）
      定义一个操作中��法的骨�?��一些步骤的执行延迟到其子类�? 如Struts中的execute()�Ҏ��Q�通俗的说法是在父�cȝ��Ҏ��中，调用操象的方法。而操象的�Ҏ��是由实现�c�L��实现�?br />
2�?span lang="EN-US">Memento�Q�备忘录模式�Q?br />       备忘录模录实际上是对象内部状态的拯��Q�运行到某个时候可以恢复它原有的状态，在实际开发中我们�l�常会用到该模式�Q�但写法可能不一栗��?br /> 3�?span lang="EN-US">Observer�Q��听模式）
     别�h说是观察者，我喜�Ƣ说�q�是监听模式�Q�就是设�|�一个对象的监听对象�Q�当被监听对象的状态改变时触发一个事�Ӟ��JDK已经提供实现了。需要用到时GOOGLE一样就OK�?br /> 4�?span lang="EN-US">Chain of Responsibility�Q�职责链�Q?br />     ��是一个对象当作一个参��C��递给不同的对�q�行职责处理�?br /> 5�?span lang="EN-US">Command�Q�命令模式）
    ��q��具体��装了，实际开发中用一得也挺多�?br /> 6�?span lang="EN-US">State�Q�状态模式）

7�?span lang="EN-US">Strategy(�{�略)
    是对��法的一�U�封�?br /> 8�?span lang="EN-US">Mediator(中介�?
   各个对象之间的交互操作非常多;每个对象的行为操作都依赖彼此�Ҏ��,修改一个对象的行�ؓ,同时会涉及到修改很多其他对象的行�?如果使用Mediator模式,可以使各个对象间的耦合松散,只需兛_��?Mediator的关�p?使多对多的关�p�d��成了一对多的关�p?可以降低�pȝ��的复杂�?提高可修�Ҏ��展�?

9�?span lang="EN-US">Interpreter(解释�?
10�?strong>Visitor�Q�参观者模式）
��是遍历�c�集中的对象�?/span>

有猫�怼�的日�?/a> 2007-09-24 23:36 发表评论

Sat, 22 Sep 2007 06:58:00 GMT

�l�构模式�?个小模式�Q�下面分别说一下它们的思想�Q?br /> 1、门面模�?Facade)也称外观模式
      为子�pȝ��提供�l�一的接口，�q�个接口��叫门在了，客户只需与门面来的交道，内部调用那个功能模块对客��L��来说是隐藏的。现实生�z�M��d��院看病捡药的例子是一��L��?br /> 2、代理模�?Proxy)
     有两�U�方式一�U�是静态代理，另一�U�是动态代理。代理模式就是�ؓ其它对象提供代理以控制对�q�个对象的访问�?br /> 3、适配器模式（Adapter�Q?br />      ��两个不兼容的类�U�合在一起��?使用�q�个模式�Ӟ��最好以面向接口的方式实一�Q�而不用��ѝ��这是一个比较好理解的模块，不需要看例程��应该能回忆起它的结构�?br /> 4、组合模式（Composite�Q?br />      ��对象以树的形式�l�合��h��Q�以达成整体与部份的�l�构。�ƈ在类中提供添加，删除�Q�遍历这三个�Ҏ��。通常以操象类为父�c�L��实现�?br /> 5、��a漆工模式�Q?span lang="EN-US">Decorator�Q?br /> 说白了就是给一个类再添加些功能�Q�通常可以在设计中可以使用�l�承�Q�再实现个接口。该模式可以避免�q�样做，实一�Ҏ��是在实现接口的类�Ҏ��中，��M��一些额外功能函数�?br /> 6、桥接模式（Bridge�Q?o:p>
    ��操象与行�ؓ分离�?br /> 7、��n元模�?Flyweight)
    说白了就是一个Map 用来存储对象�Ӟ��先判断Map中是否有该对象，如果有就不需再存�q�。或者要从别的地方联一个对象时�Q�先在Map里找�Q�如果找到就不用��d��的地方了。有点类��g��一个池。具体实现就不说�?br />

有猫�怼�的日�?/a> 2007-09-22 14:58 发表评论

Wed, 19 Sep 2007 15:26:00 GMT

设计模式分三大类�Q�创建、结构、行�?
设计模式是对软�g建立的一个方法，也可以说是一�U�行��范！在面向对象的软�g开发思想里，最为关键的我想是OOA/OOD�Q�这是面向对象程序设计的基础�Q�而设计模式分的这三大�c�，是OOD中所必须的元素。设计模式分�c�M��对象三大特征��d��?br /> 1、对象创建：��M��一个对象都有一个徏立过�E�，��是从类生成对象�?br /> 2、对象结构：更准��来讲是�cȝ��l�构�Q�我们要创徏一个类�Q�对象）��必��d��定它的�l�构�?br /> 3、对象行为：对象�Q�类�Q�由构造函数、属性、方法构成，而方法通常��是指对象的行�ؓ�?br />
设计模式分类可以说是以类到对象创��E�来划分的�?br />
设计模式有些书是长篇大论�Q�让我不知所措，俺文化水�q�低只能从个人的见解上做��单的分析�Q��ƈ反简单的思想用到实际开发中�?br /> 创徏模式�?个子模式�Q?br /> �q?个模式都是创建对象的�Q�只不是创徏的方式不一��P��有的对象只能创徏一个；有的对象是通过工厂来生产；有的对象由很多小对象�l�成�Q�有整体与部份关�p�）��通过Builder(构�?,下面做介�l?br />
1�?span lang="EN-US">Factory �Q�工厂模式）:分�ؓ工厂�Ҏ��Q�操象工�?。单一个接口有多个实现旉��常可以用工厂方法来实现�Q�如果要创徏多个接口的实现类�Q��ƈ现对构徏比较复杂时我们就用操象工厂�?br /> 2�?span lang="EN-US">Prototype�Q�原型模式）�Q�基本不用，实际上是父类实现了一个Cloneable接口。我不喜�Ƣ用�q�种方式�Q�也扑ֈ�更好的方法来实现Cloneable�?br /> 3�?span lang="EN-US">Builder�Q�构造模式）�Q�是��Z��构建复杂对象的�q�程和它�?strong>部�g解�?注意: 是解�?strong>�q�程�?strong>部�g ,通常先定义构造类的接口，实现不同的部件构造，然后有一个装配的�q�程�?br /> 4、Singleton�Q�单态模式）�Q�太常用�Q�不用介�l�，通常有三�U�创建单态类的方法�?br />
学习设计模式不是要牢记它是怎么实现的，不要��C��列子�Q�只要记住思想��可以了�Q�当你在现实中做设计的时候，让这些思想��现在你脑�v里，选择最适用你的实现�Ҏ��?br />

有猫�怼�的日�?/a> 2007-09-19 23:26 发表评论

设计模式--command(命��o模式)

Thu, 13 Jul 2006 15:00:00 GMT

Command有很多种实现方式�Q�可以随便的按便�q�个规律来自由发挥�?br />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();
}

}

有猫�怼�的日�?/a> 2006-07-13 23:00 发表评论

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

Mon, 10 Jul 2006 15:05:00 GMT

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

import java.util.*;

class Product extends Observable{//被观察者必�l�承于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{ //观察者必��d��现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("产品��h��?>"+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("�W�记本电�?);
  p.setPrice(Float.valueOf("9635.5"));
}

}

有猫�怼�的日�?/a> 2006-07-10 23:05 发表评论

设计模式---Memento(备忘�?

Mon, 10 Jul 2006 14:58:00 GMT

Memento的定义：
Memento是一个保存另外一个对象的内部状态拷贝的对象�Q�这样就可以把对象恢复到原先状态�?br />
��的没必要用�q�个东西�Q�耗内存，�ȝ��。我惛_��份对象�ؓ什么不用对象的深度拯��呢。这样不是很省事吗？谁能告诉我一个理由呢�Q?br />
下面是一个Memento模式例子�Q�很��单：
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);
}
//恢复到原始�?br /> 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();//建备一个备份对�?br />  o.setNumber(50); //改变对象属�?br />  o.setMemento(m); //�q�原
  System.out.println(o.getNumber());
}

}

有猫�怼�的日�?/a> 2006-07-10 22:58 发表评论

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

Sun, 09 Jul 2006 14:58:00 GMT

定义�Q?br /> 定义一个算法中的骨�Ӟ��一些步骤的执行延期到子�c�，其实JAVA中的操象�c�d��是一个Template模式�Q�因些��用得很普遍，很容易理解。如�Q?br />package com.pdw.pattern;

abstract class Benchmark{
public abstract void benchmark();

/**
* 重复执行的次�?br /> * @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);
}

}

有猫�怼�的日�?/a> 2006-07-09 22:58 发表评论

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

Sun, 09 Jul 2006 14:50:00 GMT

Flyweight的定义：
避免大量拥有相同内容的小�c�d��销�Q�如消耗内存）�Q��大家�׃�n一个类叫元�c�R�?br />��Z��么��用：
面向对角的原则是一切都是对象，但如果对象数非常庞大�Q�如果字处理软�g�Q�对数据表的DAO操作。等耗内存的操作�Q�我们就要求同存异，扑և�共同体，设计��Z��个元�c�R��另外一些特性取决于context是不可共享的�?br />
使用例子如：
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());
}

}

有猫�怼�的日�?/a> 2006-07-09 22:50 发表评论

设计模式---Adapter(适配�?

Mon, 03 Jul 2006 15:03:00 GMT

1 定义�Q?br /> ��两个不兼容的类�U�合在一起��用，属于�l�构型模式，需要有被适配者（Adaptee�Q�和适配�?Adapor)两个�w�䆾�?br />2 ��Z��使用�Q?br /> 我们�l�常需要将两上没有关系的类�l�合在一起��用，�W�一解决�Ҏ��是修改各自类的接口，便如没有源代码，或者我们不愿意��Z��个应用而修�Ҏ��口怎么办，��q��Adapter创徏淯��的组合体�?br />至于怎么用可以参考《think in java》的“类再生”这一节所提到的两个方式：�l�合(Composition)和��?inheritance)

参考例子：
package com.pdw.pattern;
/**
* 两个不兼容的�cȝ��合在一起��用，属于�l�构模型�Q�需有被适配器（Adaptee)和适配�?Adaptor)两个�w�䆾
*
* @author Administrator
*
*/

//打方�?br />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("方型");
}

}

有猫�怼�的日�?/a> 2006-07-03 23:03 发表评论

设计模式�?---Facade(外观)

Sun, 02 Jul 2006 15:21:00 GMT

实现上就是把各种复的实现的类�Q�操象出一个统一的接口。没扑ֈ�好的例子�Q�！�Q?img src ="http://m.tkk7.com/pdw2009/aggbug/56214.html" width = "1" height = "1" />

有猫�怼�的日�?/a> 2006-07-02 23:21 发表评论

设计模式---Singleton

Thu, 29 Jun 2006 15:01:00 GMT

单态的作用��׃��用说了，�l�常用过�Q�就是一个类只��生一个对象�?br />它有两个�U�实现方法。实现在大同��异�Q�可以根据需要改�q��?br />例程如下�Q?br />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

}

有猫�怼�的日�?/a> 2006-06-29 23:01 发表评论

设计模式----builder

Thu, 29 Jun 2006 14:52:00 GMT

构徏模式的定义：
��一个复杂的对象构徏与它的表�C�分��d��来，使用��L��构徏�q�程可以创徏不同的表�C��?br />Builder 模式是一步一步创��Z��个复杂的对象�Q�它充许用户通过指定复杂对象�c�d��和内容就可以构徏它们。用户不需知道其内部细节。Builder非常�c�M��操象工厂模式�Q�只有在使用中才能区别开来。一个��用例子：
package com.pdw.pattern;

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

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

/*
* 构徏部�g
*/
class Director{
private Builder builder;

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

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

}
/*
* 部�g实现�c?br /> */
class PartAImpl implements PartA{

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

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("�q�里输入了��品信息，当然产品�q�有很多功能�Ҏ��没写�?);
}

}
class Cbuilder implements Builder{
PartA pa;
PartB pb;
public void buildPartA() {
  pa=new PartAImpl(); //具体子部件实��C��?br />
}

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();
}

}

有猫�怼�的日�?/a> 2006-06-29 22:52 发表评论

设计模式�?-Prototype

Wed, 28 Jun 2006 15:26:00 GMT

用原型实例指定创建对象的�U�类�Q��ƈ且都�q�拷贝这些原型徏建新的对象�?br />prototype模式充许一个对象再创徏另一个可定制的对象，�Ҏ��无需知道创徏的细节�?br />java中提供了clone()来实现对象克隆。所以prototype模式变得了很��单。请参考以下例�E�：
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();
}

}

有猫�怼�的日�?/a> 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;
  }
}
}
/**
* 操象工厂的实现�?br /> * @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();
}
}

以上�q�个例程�Q�说明了一般工厂以及操象工厂的实现�?br />工厂�q�个构造模式在开发中会经常用�?

有猫�怼�的日�?/a> 2006-06-28 22:54 发表评论