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();
}
}
]]>
当被观察的对象特定属性改变时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"));
}
}
]]>
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());
}
}
]]>
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<count;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);
}
}
]]>
避免大量拥有相同内容的小cd销Q如消耗内存）Q大家׃n一个类叫元cR?br />Z么用：
面向对角的原则是一切都是对象，但如果对象数非常庞大Q如果字处理软gQ对数据表的DAO操作。等耗内存的操作Q我们就要求同存异，扑և共同体，设计Z个元cR另外一些特性取决于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());
}
}
]]>
参考例子：
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("方型");
}
}
]]>
]]>
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
}
}
]]>
一个复杂的对象构徏与它的表C分d来，使用L构徏q程可以创徏不同的表C?br />Builder 模式是一步一步创Z个复杂的对象Q它充许用户通过指定复杂对象cd和内容就可以构徏它们。用户不需知道其内部细节。Builder非常cM操象工厂模式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("PartAl装完成...");
}
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();
}
}
]]>
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();
}
}
]]>
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个构造模式在开发中会经常用?
]]>