- 浏览: 127492 次
- 性别:
- 来自: 杭州
文章分类
- 全部博客 (145)
- java (145)
- Java网络编程 (1)
- SWT 文本框Text通过GC重绘改变边框颜色 (1)
- tomcat部署web工程的两种方法 (1)
- JAX-RS 从傻逼到牛叉 1:REST 基础知识 (1)
- FreyjaJdbcTemplate 大致上完工了,想请人重构。。 (1)
- 开始认识自己 (1)
- 设计模式-Abstract Factory 模式 (1)
- 数据库中主键的设计原则 (1)
- JNI中jstring类型与c语言中的字符串的转换 (1)
- mac环境变量 (1)
- STC单片机ADC转换的例子 (1)
- myeclipse 8下安装Ibator . (1)
- OSGI与Android结合 (1)
- CSDN BLOG EXPERT (1)
- Java中网络操作的开源库CommonsNet (1)
- Apache License Version 2.0 英文内容及中文翻译 (1)
- JTest (1)
- GeoCon 用C#编写的开源的地理信息数据转换工具 (1)
- ERP简易教程 (1)
- 提高站点在搜索引擎上的排名 (1)
- Wifi (1)
- 腾讯Q+开放平台,相信又是一次成功的模仿 (1)
- C#坦克大战网络版代码 (1)
- Problem16 (1)
- Ajax 应该变成 Ajaj (关于JSON 与 XML 的比较) (1)
- ava框架数据库连接池比较(c3p0 (1)
- dbcp和proxool)bonecp (1)
- 继续向成熟男人靠拢 (1)
- Qt4.7中 默认的构造函数 (1)
- xml CDATA (1)
- 只针对中英文混合分词的中文分词器 (1)
- 典型相关分析及其适用范围和spss操作(转) (1)
- llvm (1)
- java连接数据库Oracle|DB2|Sql Server|Sybase|Informix|MySQL||PostgreSQL|access (1)
最新评论
-
xm3530:
什么鬼?都没法看,发出来干嘛
Android中利用App实现消息推送机制的代码实例 -
lvtenglongxiaohei:
太经典了!
学习一下!
ERP简易教程 -
lvtenglongxiaohei:
<br> 一天中午,丈 ...
ERP简易教程 -
hzw2312:
加油~~~!!!
开始认识自己 -
123048591:
显示乱码
tomcat部署web工程的两种方法
package lq.test;
import java.io.*;
import java.util.*;
//*********创建型模式***************
//factory method 1
//1具体的构造算法,和2构造出的具体产品由子类实现
interface product {
}
//或者我也提供一个工厂的接口,由这个抽象类来继承它
abstract class factory {
abstract public product fmd();
//我认为这个方方法的存在是,是对factorymethod方法的补充
//例如可以为生成的对象赋值,计算为生成对象应付何值,前后的日值
//且这些都是公用的,生成产品的最主要算法还是在factorymethod中,
//这个方法只是起辅助作用,这也是一种思维方法,将具体的算法实现在一个方法中
//而我不直接调用此方法,而使用另外的一个方法封装它,等到了更灵活的效果,而
//子类需实现的内容是factorymethod
//此方法是一个templatemethod
public product creat() {
product pd = null;
system.out.println("before operation");
pd = fmd();
system.out.println("end operation");
return pd;
}
}
class product1 implements product {
}
class factory1 extends factory {
public product fmd() {
product pd = new product1();
return pd;
}
}
//factroymethod 2
//这种方式简单实用
interface producta {
}
interface factorya {
producta create();
}
class producta1 implements producta {}
class factorya1 implements factorya {
public producta create() {
producta pda = null;
pda = new producta1();
return pda;
}
}
//abstractfactory
//abstractfactory与factorymethod的不同在于abstractfactory创建多个产品
//感觉此模式没有什么大用
//当然可以还有更多的接口
interface apda {}
interface apdb {}
interface afactory {
apda createa();
apdb createb();
}
class apda1 implements apda {}
class apdb1 implements apdb {}
//有几个接口就有几个对应的方法
class afactory1 implements afactory {
public apda createa() {
apda apda = null;
apda = new apda1();
return apda;
}
public apdb createb() {
apdb apdb = null;
apdb = new apdb1();
return apdb;
}
}
//builder
//一个产品的生成分为生成部件和组装部件,不同的产品每个部件生成的方式不同
//而组装的方式相同,部件的生成抽象成接口方法,而组装的方法使用一个templatemethod方法
interface cpda {}
class cpda1 implements cpda {}
interface builderi {
void buildpart1();
void buildpart2();
void initpd();
cpda getpd();
}
abstract class buildera implements builderi {
cpda cpda;
public cpda getpd() {
initpd();
//对对象的内容进行设置
buildpart1();
buildpart2();
return cpda;
}
}
class builder extends buildera {
public void buildpart1() {
system.out.println(cpda);
}
public void buildpart2() {
system.out.println(cpda);
}
public void initpd() {
cpda = new cpda1();
}
}
//一个简单的生成产品的实现
//1
abstract class fy {
public abstract void med1();
static class fy1 extends fy {
public void med1() {
}
}
public static fy getinstance() {
fy fy = new fy1();
return fy;
// fy fy = new fy1() {//这种匿名内部类是静态的!!
// public void med1() {
// }
// };
// return fy
}
}
//2
interface pdd {}
class pdd1 implements pdd {}
abstract class fya {
public static pdd getpd() {
pdd pdd = new pdd1();
return pdd;
}
}
//prototype 在java中就是clone,又包含深拷贝和浅拷贝
class cloneobja {
public cloneobja myclone() {
return new cloneobja();
}
}
class cloneobjb {
public cloneobjb myclone() throws throwable {
cloneobjb cobj = null;
cobj = (cloneobjb) pcl(this);
return cobj;
}
/深度拷贝算法
private object pcl(object obj) throws throwable {
bytearrayoutputstream bao = new bytearrayoutputstream(1000);
objectoutputstream objo = new objectoutputstream(bao);
objo.writeobject(obj);
bytearrayinputstream bai = new bytearrayinputstream(bao.tobytearray());
objectinputstream obji = new objectinputstream(bai);
object objr = obji.readobject();
return objr;
}
}
//singleton
//一个类只有一个对象,例如一个线程池,一个cache
class singleton1 {
public static singleton1 instance = new singleton1();
private singleton1() {
}
public static singleton1 getinstance() {
return instance;
}
}
class singleton2 {
public static singleton2 instance;
private singleton2() {
}
// public static singleton2 getinstance() {
// if (instance == null) {
// instance = new singleton2();
// }
//
// return instance;
// }
public static singleton2 getinstance() {
synchronized(singleton2.class) {
if (instance == null) {
instance = new singleton2();
}
}
return instance;
}
}
落花人独立
关注 - 0
粉丝 - 0
关注博主
0
0
(请您对文章做出评价)
« 上一篇:常用的40个网站制作技巧 (转)
» 下一篇:状态对象:数据库的替代者
feedback
#1楼[楼主] 回复 引用 查看
2008-01-17 10:07 by 落花人独立
//**********结构型模式**********
//adapter
//基本方法有两种,一种是使用引用一种使用继承
//将不符合标准的接口转成符合标准的接口,接口的修改主要是参数的增减,
//返回值类型,当然还有方法名
//感觉这就是封装的另一种表示形式,封装有用方法封装(在方法中调用功能方法),
//用类封装(先传入功能方法所在的类的对象,通过调用此对象的功能方法)
//使用引用的形式
class adapteea {
public void kk() {}
}
interface targeta {
string vv(int i, int k);
}
class adaptera implements targeta{
adapteea ade;
public adaptera(adapteea ade) {
this.ade = ade;
}
public string vv(int i, int k) {
//具体的业务方法实现在adaptee中,这个方法
//只起到了接口转换的作用
//调用此方法是通过引用
ade.kk();
return null;
}
}
//使用继承形式的
class adapteeb {
public void kk() {}
}
interface targetb {
string vv(int i, int k);
}
class adapterb extends adapteeb implements targetb {
public string vv(int i, int k) {
//调用此方法是通过继承
kk();
return null;
}
}
//proxy
interface subject {
void request();
}
class realsubject implements subject {
public void request() {
//do the real business
}
}
class proxy implements subject {
subject subject;
public proxy(subject subject) {
this.subject = subject;
}
public void request() {
system.out.println("do something");
subject.request();
system.out.println("do something");
}
}
//bridge
//感觉就是多态的实现
interface imp {
void operation();
}
class cimp1 implements imp {
public void operation() {
system.out.println("1");
}
}
class cimp2 implements imp {
public void operation() {
system.out.println("2");
}
}
class invoker {
imp imp = new cimp1();
public void invoke() {
imp.operation();
}
}
//composite
interface component {
void operation();
void add(component component);
void remove(component component);
}
class leaf implements component {
public void operation() {
system.out.println("an operation");
}
public void add(component component) {
throw new unsupportedoperationexception();
}
public void remove(component component) {
throw new unsupportedoperationexception();
}
}
class composite implements component {
list components = new arraylist();
public void operation() {
component component = null;
iterator it = components.iterator();
while (it.hasnext()) {
//不知道此component对象是leaf还是composite,
//如果是leaf则直接实现操作,如果是composite则继续递归调用
component = (component) it.next();
component.operation();
}
}
public void add(component component) {
components.add(component);
}
public void remove(component component) {
components.remove(component);
}
}
//decorator
//对一个类的功能进行扩展时,我可以使用继承,但是不够灵活,所以选用了
//另外的一种形式,引用与继承都可活得对对象的一定的使用能力,而使用引用将更灵活
//我们要保证是对原功能的追加而不是修改,否则只能重写方法,或使用新的方法
//注意concrete的可以直接new出来,
//而decorator的则需要用一个另外的decorator对象才能生成对象
//使用对象封装,和公用接口
//decorator链上可以有多个元素
interface componenta {
void operation();
}
class concretecomponent implements componenta {
public void operation() {
system.out.println("do something");
}
}
class decorator implements componenta {
private componenta component;
public decorator(componenta component) {
this.component = component;
}
public void operation() {
//do something before
component.operation();
//do something after
}
}
//facade
//非常实用的一种设计模式,我可以为外部提供感兴趣的接口
class obj1 {
public void ope1() {}
public void ope2() {}
}
class obj2 {
public void ope1() {}
public void ope2() {}
}
class facade {
//我得到了一个简洁清晰的接口
public void fdmethod() {
obj1 obj1 = new obj1();
obj2 obj2 = new obj2();
obj1.ope1();
obj2.ope2();
}
}
//flyweight
//空
#2楼[楼主] 回复 引用 查看
2008-01-17 10:11 by 落花人独立
//**********行为型模式*************
//chain of responsibility
//与decorator的实现形式相类似,
//decorator是在原来的方法之上进行添加功能,而
//chain则是判断信号如果不是当前处理的则转交个下一个节点处理
//我可以使用if分支来实现相同的效果,但是不够灵活,链上的每个节点是可以替换增加的,相对
//比较灵活,我们可以设计接口实现对节点的增删操作,而实现更方便的效果
//这个是一个链状的结构,有没有想过使用环状结构
interface handler {
void handrequest(int signal);
}
class chandler1 implements handler {
private handler handler;
public chandler1(handler handler) {
this.handler = handler;
}
public void handrequest(int signal) {
if (signal == 1) {
system.out.println("handle signal 1");
}
else {
handler.handrequest(signal);
}
}
}
class chandler2 implements handler {
private handler handler;
public chandler2(handler handler) {
this.handler = handler;
}
public void handrequest(int signal) {
if (signal == 2) {
system.out.println("handle signal 2");
}
else {
handler.handrequest(signal);
}
}
}
class chandler3 implements handler {
public void handrequest(int signal) {
if (signal == 3) {
system.out.println("handle signal 3");
}
else {
throw new error("can't handle signal");
}
}
}
class chainclient {
public static void main(string[] args) {
handler h3 = new chandler3();
handler h2 = new chandler2(h3);
handler h1 = new chandler1(h2);
h1.handrequest(2);
}
}
//interpreter
//感觉跟composite很类似,只不过他分文终结符和非终结符
//template method
abstract class templatemethod {
abstract void amd1();
abstract void amd2();
//此方法为一个template method方法
public void tmd() {
amd1();
amd2();
}
}
//state
//标准型
//状态和操作不应该耦合在一起
class contexta {
private state st;
public contexta(int nst) {
changestfromnum(nst);
}
public void changestfromnum(int nst) {
if (nst == 1) {
st = new cstatea1();
}
else if (nst == 2) {
st = new cstatea2();
}
throw new error("bad state");
}
void request() {
st.handle(this);
}
}
interface state {
void handle(contexta context);
}
class cstatea1 implements state {
public void handle(contexta context) {
system.out.println("state 1");
//也许在一个状态的处理过程中要改变状态,例如打开之后立即关闭这种效果
//context.changestfromnum(2);
}
}
class cstatea2 implements state {
public void handle(contexta context) {
system.out.println("state 2");
}
}
//工厂型
//根据状态不通生成不同的state
//class statefactory {
// public static state getstateinstance(int num) {
// state st = null;
//
// if (num == 1) {
// st = new cstatea1();
// }
// else if (num == 2) {
// st = new cstatea2();
// }
//
// return st;
// }
//}
//strategy
//跟bridge相类似,就是一种多态的表示
//visitor
//双向引用,使用另外的一个类调用自己的方法,访问自己的数据结构
interface visitor {
void visitelement(elementd element);
}
class cvisitor implements visitor {
public void visitelement(elementd element) {
element.operation();
}
}
interface elementd {
void accept(visitor visitor);
void operation();
}
class celementd implements elementd {
public void accept(visitor visitor) {
visitor.visitelement(this);
}
public void operation() {
//实际的操作在这里
}
}
class clientd {
public static void main() {
elementd elm = new celementd();
visitor vis = new cvisitor();
vis.visitelement(elm);
}
}
//iteraotr
//使用迭代器对一个类的数据结构进行顺序迭代
interface structure {
interface iteratora {
void first();
boolean haselement();
object next();
}
}
class structure1 implements structure {
object[] objs = new object[100];
//使用内部类是为了对struture1的数据结构有完全的访问权
class iteratora1 implements iteratora {
int index = 0;
public void first() {
index = 0;
}
public boolean haselement() {
return index < 100;
}
public object next() {
object obj = null;
if (haselement()) {
obj = objs[index];
index++;
}
return obj;
}
}
}
//meditor
class a1 {
public void operation1() {}
public void operation2() {}
}
class a2 {
public void operation1() {}
public void operation2() {}
}
class mediator {
a1 a1;
a2 a2;
public mediator(a1 a1, a2 a2) {
this.a1 = a1;
this.a2 = a2;
}
//如果我想实现这个功能我可能会把他放在a1中
//但是这样耦合大,我不想在a1中出现a2对象的引用,
//所以我使用了mediator作为中介
public void mmed1() {
a1.operation1();
a2.operation2();
}
public void mmed2() {
a2.operation1();
a1.operation2();
}
}
//command
//我认为就是将方法转换成了类
class receiver {
public void action1() {}
public void action2() {}
}
interface command {
void execute();
}
class ccommand1 implements command {
private receiver receiver;
public ccommand1(receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.action1();
}
}
class ccommand2 implements command {
private receiver receiver;
public ccommand2(receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.action2();
}
}
//observer
//在这里看似乎这个模式没有什么用
//但是如果我有一个线程监控subject,如果subject的状态
//发生了变化,则更改observer的状态,并出发一些操作,这样就有实际的意义了
//observer与visitor有相似的地方,都存在双向引用
//subject可以注册很多observer
interface subjectb {
void attach(observer observer);
void detach(observer observer);
void mynotify();
int getstate();
void setstate(int state);
}
class subjectb1 implements subjectb {
list observers = new arraylist();
int state;
public void attach(observer observer) {
observers.add(observer);
}
public void detach(observer observer) {
observers.remove(observer);
}
public void mynotify() {
observer observer = null;
iterator it = observers.iterator();
while (it.hasnext()) {
observer = (observer) it.next();
observer.update();
}
}
public int getstate() {
return state;
}
public void setstate(int state) {
this.state = state;
}
}
interface observer {
void update();
}
class observer1 implements observer {
subjectb subject;
int state;
public observer1(subjectb subject) {
this.subject = subject;
}
public void update() {
this.state = subject.getstate();
}
public void operation() {
//一些基于state的操作
}
}
//memento
//感觉此模式没有什么大用
class memento {
int state;
public int getstate() {
return state;
}
public void setstate(int state) {
this.state = state;
}
}
class originator {
int state;
public void setmemento(memento memento) {
state = memento.getstate();
}
public memento creatememento() {
memento memento = new memento();
memento.setstate(1);
return memento;
}
public int getstate() {
return state;
}
public void setstate(int state) {
this.state = state;
}
}
class caretaker {
memento memento;
public void savermemento(memento memento) {
this.memento = memento;
}
public memento retrievememento() {
return memento;
}
}
//程序最终还是顺序执行的,是由不通部分的操作拼接起来的
//将不同类的代码拼接起来是通过引用实现的,有了引用我就
//相当于有了一定访问数据结构和方法的能力,这与写在类内部
//差不多,例如我想将一个类中的一个方法抽离出去,因为这个方法依赖与此类的数据和其他方法
//直接将代码移走是不行的,但如果我们拥有了此类对象的引用,则与写在此类
//内部无异,所以我们拥有了引用就可以将此方法移出
public class tt1 {
public static void main(string[] args) {
}
}
import java.io.*;
import java.util.*;
//*********创建型模式***************
//factory method 1
//1具体的构造算法,和2构造出的具体产品由子类实现
interface product {
}
//或者我也提供一个工厂的接口,由这个抽象类来继承它
abstract class factory {
abstract public product fmd();
//我认为这个方方法的存在是,是对factorymethod方法的补充
//例如可以为生成的对象赋值,计算为生成对象应付何值,前后的日值
//且这些都是公用的,生成产品的最主要算法还是在factorymethod中,
//这个方法只是起辅助作用,这也是一种思维方法,将具体的算法实现在一个方法中
//而我不直接调用此方法,而使用另外的一个方法封装它,等到了更灵活的效果,而
//子类需实现的内容是factorymethod
//此方法是一个templatemethod
public product creat() {
product pd = null;
system.out.println("before operation");
pd = fmd();
system.out.println("end operation");
return pd;
}
}
class product1 implements product {
}
class factory1 extends factory {
public product fmd() {
product pd = new product1();
return pd;
}
}
//factroymethod 2
//这种方式简单实用
interface producta {
}
interface factorya {
producta create();
}
class producta1 implements producta {}
class factorya1 implements factorya {
public producta create() {
producta pda = null;
pda = new producta1();
return pda;
}
}
//abstractfactory
//abstractfactory与factorymethod的不同在于abstractfactory创建多个产品
//感觉此模式没有什么大用
//当然可以还有更多的接口
interface apda {}
interface apdb {}
interface afactory {
apda createa();
apdb createb();
}
class apda1 implements apda {}
class apdb1 implements apdb {}
//有几个接口就有几个对应的方法
class afactory1 implements afactory {
public apda createa() {
apda apda = null;
apda = new apda1();
return apda;
}
public apdb createb() {
apdb apdb = null;
apdb = new apdb1();
return apdb;
}
}
//builder
//一个产品的生成分为生成部件和组装部件,不同的产品每个部件生成的方式不同
//而组装的方式相同,部件的生成抽象成接口方法,而组装的方法使用一个templatemethod方法
interface cpda {}
class cpda1 implements cpda {}
interface builderi {
void buildpart1();
void buildpart2();
void initpd();
cpda getpd();
}
abstract class buildera implements builderi {
cpda cpda;
public cpda getpd() {
initpd();
//对对象的内容进行设置
buildpart1();
buildpart2();
return cpda;
}
}
class builder extends buildera {
public void buildpart1() {
system.out.println(cpda);
}
public void buildpart2() {
system.out.println(cpda);
}
public void initpd() {
cpda = new cpda1();
}
}
//一个简单的生成产品的实现
//1
abstract class fy {
public abstract void med1();
static class fy1 extends fy {
public void med1() {
}
}
public static fy getinstance() {
fy fy = new fy1();
return fy;
// fy fy = new fy1() {//这种匿名内部类是静态的!!
// public void med1() {
// }
// };
// return fy
}
}
//2
interface pdd {}
class pdd1 implements pdd {}
abstract class fya {
public static pdd getpd() {
pdd pdd = new pdd1();
return pdd;
}
}
//prototype 在java中就是clone,又包含深拷贝和浅拷贝
class cloneobja {
public cloneobja myclone() {
return new cloneobja();
}
}
class cloneobjb {
public cloneobjb myclone() throws throwable {
cloneobjb cobj = null;
cobj = (cloneobjb) pcl(this);
return cobj;
}
/深度拷贝算法
private object pcl(object obj) throws throwable {
bytearrayoutputstream bao = new bytearrayoutputstream(1000);
objectoutputstream objo = new objectoutputstream(bao);
objo.writeobject(obj);
bytearrayinputstream bai = new bytearrayinputstream(bao.tobytearray());
objectinputstream obji = new objectinputstream(bai);
object objr = obji.readobject();
return objr;
}
}
//singleton
//一个类只有一个对象,例如一个线程池,一个cache
class singleton1 {
public static singleton1 instance = new singleton1();
private singleton1() {
}
public static singleton1 getinstance() {
return instance;
}
}
class singleton2 {
public static singleton2 instance;
private singleton2() {
}
// public static singleton2 getinstance() {
// if (instance == null) {
// instance = new singleton2();
// }
//
// return instance;
// }
public static singleton2 getinstance() {
synchronized(singleton2.class) {
if (instance == null) {
instance = new singleton2();
}
}
return instance;
}
}
落花人独立
关注 - 0
粉丝 - 0
关注博主
0
0
(请您对文章做出评价)
« 上一篇:常用的40个网站制作技巧 (转)
» 下一篇:状态对象:数据库的替代者
feedback
#1楼[楼主] 回复 引用 查看
2008-01-17 10:07 by 落花人独立
//**********结构型模式**********
//adapter
//基本方法有两种,一种是使用引用一种使用继承
//将不符合标准的接口转成符合标准的接口,接口的修改主要是参数的增减,
//返回值类型,当然还有方法名
//感觉这就是封装的另一种表示形式,封装有用方法封装(在方法中调用功能方法),
//用类封装(先传入功能方法所在的类的对象,通过调用此对象的功能方法)
//使用引用的形式
class adapteea {
public void kk() {}
}
interface targeta {
string vv(int i, int k);
}
class adaptera implements targeta{
adapteea ade;
public adaptera(adapteea ade) {
this.ade = ade;
}
public string vv(int i, int k) {
//具体的业务方法实现在adaptee中,这个方法
//只起到了接口转换的作用
//调用此方法是通过引用
ade.kk();
return null;
}
}
//使用继承形式的
class adapteeb {
public void kk() {}
}
interface targetb {
string vv(int i, int k);
}
class adapterb extends adapteeb implements targetb {
public string vv(int i, int k) {
//调用此方法是通过继承
kk();
return null;
}
}
//proxy
interface subject {
void request();
}
class realsubject implements subject {
public void request() {
//do the real business
}
}
class proxy implements subject {
subject subject;
public proxy(subject subject) {
this.subject = subject;
}
public void request() {
system.out.println("do something");
subject.request();
system.out.println("do something");
}
}
//bridge
//感觉就是多态的实现
interface imp {
void operation();
}
class cimp1 implements imp {
public void operation() {
system.out.println("1");
}
}
class cimp2 implements imp {
public void operation() {
system.out.println("2");
}
}
class invoker {
imp imp = new cimp1();
public void invoke() {
imp.operation();
}
}
//composite
interface component {
void operation();
void add(component component);
void remove(component component);
}
class leaf implements component {
public void operation() {
system.out.println("an operation");
}
public void add(component component) {
throw new unsupportedoperationexception();
}
public void remove(component component) {
throw new unsupportedoperationexception();
}
}
class composite implements component {
list components = new arraylist();
public void operation() {
component component = null;
iterator it = components.iterator();
while (it.hasnext()) {
//不知道此component对象是leaf还是composite,
//如果是leaf则直接实现操作,如果是composite则继续递归调用
component = (component) it.next();
component.operation();
}
}
public void add(component component) {
components.add(component);
}
public void remove(component component) {
components.remove(component);
}
}
//decorator
//对一个类的功能进行扩展时,我可以使用继承,但是不够灵活,所以选用了
//另外的一种形式,引用与继承都可活得对对象的一定的使用能力,而使用引用将更灵活
//我们要保证是对原功能的追加而不是修改,否则只能重写方法,或使用新的方法
//注意concrete的可以直接new出来,
//而decorator的则需要用一个另外的decorator对象才能生成对象
//使用对象封装,和公用接口
//decorator链上可以有多个元素
interface componenta {
void operation();
}
class concretecomponent implements componenta {
public void operation() {
system.out.println("do something");
}
}
class decorator implements componenta {
private componenta component;
public decorator(componenta component) {
this.component = component;
}
public void operation() {
//do something before
component.operation();
//do something after
}
}
//facade
//非常实用的一种设计模式,我可以为外部提供感兴趣的接口
class obj1 {
public void ope1() {}
public void ope2() {}
}
class obj2 {
public void ope1() {}
public void ope2() {}
}
class facade {
//我得到了一个简洁清晰的接口
public void fdmethod() {
obj1 obj1 = new obj1();
obj2 obj2 = new obj2();
obj1.ope1();
obj2.ope2();
}
}
//flyweight
//空
#2楼[楼主] 回复 引用 查看
2008-01-17 10:11 by 落花人独立
//**********行为型模式*************
//chain of responsibility
//与decorator的实现形式相类似,
//decorator是在原来的方法之上进行添加功能,而
//chain则是判断信号如果不是当前处理的则转交个下一个节点处理
//我可以使用if分支来实现相同的效果,但是不够灵活,链上的每个节点是可以替换增加的,相对
//比较灵活,我们可以设计接口实现对节点的增删操作,而实现更方便的效果
//这个是一个链状的结构,有没有想过使用环状结构
interface handler {
void handrequest(int signal);
}
class chandler1 implements handler {
private handler handler;
public chandler1(handler handler) {
this.handler = handler;
}
public void handrequest(int signal) {
if (signal == 1) {
system.out.println("handle signal 1");
}
else {
handler.handrequest(signal);
}
}
}
class chandler2 implements handler {
private handler handler;
public chandler2(handler handler) {
this.handler = handler;
}
public void handrequest(int signal) {
if (signal == 2) {
system.out.println("handle signal 2");
}
else {
handler.handrequest(signal);
}
}
}
class chandler3 implements handler {
public void handrequest(int signal) {
if (signal == 3) {
system.out.println("handle signal 3");
}
else {
throw new error("can't handle signal");
}
}
}
class chainclient {
public static void main(string[] args) {
handler h3 = new chandler3();
handler h2 = new chandler2(h3);
handler h1 = new chandler1(h2);
h1.handrequest(2);
}
}
//interpreter
//感觉跟composite很类似,只不过他分文终结符和非终结符
//template method
abstract class templatemethod {
abstract void amd1();
abstract void amd2();
//此方法为一个template method方法
public void tmd() {
amd1();
amd2();
}
}
//state
//标准型
//状态和操作不应该耦合在一起
class contexta {
private state st;
public contexta(int nst) {
changestfromnum(nst);
}
public void changestfromnum(int nst) {
if (nst == 1) {
st = new cstatea1();
}
else if (nst == 2) {
st = new cstatea2();
}
throw new error("bad state");
}
void request() {
st.handle(this);
}
}
interface state {
void handle(contexta context);
}
class cstatea1 implements state {
public void handle(contexta context) {
system.out.println("state 1");
//也许在一个状态的处理过程中要改变状态,例如打开之后立即关闭这种效果
//context.changestfromnum(2);
}
}
class cstatea2 implements state {
public void handle(contexta context) {
system.out.println("state 2");
}
}
//工厂型
//根据状态不通生成不同的state
//class statefactory {
// public static state getstateinstance(int num) {
// state st = null;
//
// if (num == 1) {
// st = new cstatea1();
// }
// else if (num == 2) {
// st = new cstatea2();
// }
//
// return st;
// }
//}
//strategy
//跟bridge相类似,就是一种多态的表示
//visitor
//双向引用,使用另外的一个类调用自己的方法,访问自己的数据结构
interface visitor {
void visitelement(elementd element);
}
class cvisitor implements visitor {
public void visitelement(elementd element) {
element.operation();
}
}
interface elementd {
void accept(visitor visitor);
void operation();
}
class celementd implements elementd {
public void accept(visitor visitor) {
visitor.visitelement(this);
}
public void operation() {
//实际的操作在这里
}
}
class clientd {
public static void main() {
elementd elm = new celementd();
visitor vis = new cvisitor();
vis.visitelement(elm);
}
}
//iteraotr
//使用迭代器对一个类的数据结构进行顺序迭代
interface structure {
interface iteratora {
void first();
boolean haselement();
object next();
}
}
class structure1 implements structure {
object[] objs = new object[100];
//使用内部类是为了对struture1的数据结构有完全的访问权
class iteratora1 implements iteratora {
int index = 0;
public void first() {
index = 0;
}
public boolean haselement() {
return index < 100;
}
public object next() {
object obj = null;
if (haselement()) {
obj = objs[index];
index++;
}
return obj;
}
}
}
//meditor
class a1 {
public void operation1() {}
public void operation2() {}
}
class a2 {
public void operation1() {}
public void operation2() {}
}
class mediator {
a1 a1;
a2 a2;
public mediator(a1 a1, a2 a2) {
this.a1 = a1;
this.a2 = a2;
}
//如果我想实现这个功能我可能会把他放在a1中
//但是这样耦合大,我不想在a1中出现a2对象的引用,
//所以我使用了mediator作为中介
public void mmed1() {
a1.operation1();
a2.operation2();
}
public void mmed2() {
a2.operation1();
a1.operation2();
}
}
//command
//我认为就是将方法转换成了类
class receiver {
public void action1() {}
public void action2() {}
}
interface command {
void execute();
}
class ccommand1 implements command {
private receiver receiver;
public ccommand1(receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.action1();
}
}
class ccommand2 implements command {
private receiver receiver;
public ccommand2(receiver receiver) {
this.receiver = receiver;
}
public void execute() {
receiver.action2();
}
}
//observer
//在这里看似乎这个模式没有什么用
//但是如果我有一个线程监控subject,如果subject的状态
//发生了变化,则更改observer的状态,并出发一些操作,这样就有实际的意义了
//observer与visitor有相似的地方,都存在双向引用
//subject可以注册很多observer
interface subjectb {
void attach(observer observer);
void detach(observer observer);
void mynotify();
int getstate();
void setstate(int state);
}
class subjectb1 implements subjectb {
list observers = new arraylist();
int state;
public void attach(observer observer) {
observers.add(observer);
}
public void detach(observer observer) {
observers.remove(observer);
}
public void mynotify() {
observer observer = null;
iterator it = observers.iterator();
while (it.hasnext()) {
observer = (observer) it.next();
observer.update();
}
}
public int getstate() {
return state;
}
public void setstate(int state) {
this.state = state;
}
}
interface observer {
void update();
}
class observer1 implements observer {
subjectb subject;
int state;
public observer1(subjectb subject) {
this.subject = subject;
}
public void update() {
this.state = subject.getstate();
}
public void operation() {
//一些基于state的操作
}
}
//memento
//感觉此模式没有什么大用
class memento {
int state;
public int getstate() {
return state;
}
public void setstate(int state) {
this.state = state;
}
}
class originator {
int state;
public void setmemento(memento memento) {
state = memento.getstate();
}
public memento creatememento() {
memento memento = new memento();
memento.setstate(1);
return memento;
}
public int getstate() {
return state;
}
public void setstate(int state) {
this.state = state;
}
}
class caretaker {
memento memento;
public void savermemento(memento memento) {
this.memento = memento;
}
public memento retrievememento() {
return memento;
}
}
//程序最终还是顺序执行的,是由不通部分的操作拼接起来的
//将不同类的代码拼接起来是通过引用实现的,有了引用我就
//相当于有了一定访问数据结构和方法的能力,这与写在类内部
//差不多,例如我想将一个类中的一个方法抽离出去,因为这个方法依赖与此类的数据和其他方法
//直接将代码移走是不行的,但如果我们拥有了此类对象的引用,则与写在此类
//内部无异,所以我们拥有了引用就可以将此方法移出
public class tt1 {
public static void main(string[] args) {
}
}
发表评论
-
java连接数据库Oracle|DB2|Sql Server|Sybase|Informix|MySQL||PostgreSQL|access
2012-02-08 14:17 1058<div>Java数据库连接(JDBC)由 ... -
llvm
2012-02-07 16:29 880llvm ... -
典型相关分析及其适用范围和spss操作(转)
2012-02-07 15:43 1583看文章《科学学研 ... -
只针对中英文混合分词的中文分词器
2012-02-03 10:39 1013该版本说明 1、只针对中英文混合分词 需要一些中文和 ... -
xml CDATA
2012-02-03 08:45 1210<h2 style="font-si ... -
Qt4.7中 默认的构造函数
2012-02-01 09:14 1088<p><span style=&qu ... -
继续向成熟男人靠拢
2012-01-11 17:04 879转自徒儿的人人。 ... -
ava框架数据库连接池比较(c3p0,dbcp和proxool)bonecp
2012-01-11 14:13 1135<h1 style="text ... -
Ajax 应该变成 Ajaj (关于JSON 与 XML 的比较)
2011-12-28 15:23 963<span style="font- ... -
Problem16
2011-12-28 12:53 668package com.shui.mu.yao.io. ... -
C#坦克大战网络版代码
2011-12-20 13:09 983简单C#坦克大战网络版代码 写完单机版 http ... -
腾讯Q+开放平台,相信又是一次成功的模仿
2011-12-20 10:44 861今天看到两则新 ... -
Wifi
2011-12-19 13:14 1086. Confirm if Wifi is On ... -
提高站点在搜索引擎上的排名
2011-12-19 12:04 937对于拥有网站的各位站长来说,都希望自己的站点能够在各种 ... -
ERP简易教程
2011-12-16 16:47 922注明:下面的帖子 ... -
GeoCon 用C#编写的开源的地理信息数据转换工具
2011-12-14 12:29 956<p class="MsoNorma ... -
JTest
2011-12-14 09:00 1029接到parasoft公司一位先生打来的电话,说下个月第 ... -
Apache License Version 2.0 英文内容及中文翻译
2011-12-13 12:59 2338</span> <p class= ... -
Java中网络操作的开源库CommonsNet
2011-12-13 12:39 817<p class="MsoNorma ... -
CSDN BLOG EXPERT
2011-12-13 08:59 1094<img src="http://p. ...
相关推荐
这里我们探讨的“Java之23种设计模式完整代码”是一份宝贵的资源,它包含了所有23种经典设计模式的实现示例。这份资料能够帮助开发者深入理解每种设计模式的概念、应用场景以及它们之间的差异。 设计模式是经过时间...
里面包含了23中设计模式源代码,其中包括工厂模式(Factory)、单例(Singleton)、观察者...这些代码对于初学者看起来稍微复杂一些,我还有一个简易版的代码,标题为(23种设计模式的java源代码----容易理解的源代码)
设计模式示例代码(java)设计模式示例代码(java)v设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)设计模式示例代码(java)...
JAVA版23种设计模式代码示例源码
这篇资料"java23种设计模式及其代码"涵盖了这些模式的详细解释和实际代码实现,对于学习和理解设计模式具有极大的帮助。 1. 创建型模式(5种): - 单例模式:保证一个类只有一个实例,并提供一个全局访问点。 - ...
java23种设计模式+23个实例demo: 关于代码的几点说明: 1. 代码为根据个人对Design Pattern的学习理解写出, 2. 每个Pattern均是一个目录,其目录名即是Pattern的名字, 所有代码用JDeveloper 9i 和JBuilder 6.0编写...
JAVA 设计模式是指在软件设计过程中,为了提高代码的可维护性、灵活性和可扩展性所使用的一些惯用解决方案。JAVA 设计模式可以分为三种:创建模式、结构模式和行为模式。 1. 创建模式 创建模式是指在创建对象时...
在Java编程中,有23种经典的GoF(Gang of Four)设计模式,它们被分为三大类:创建型、结构型和行为型。本资源集合了这些模式的详细解释与源码分析,旨在帮助开发者深入理解和应用设计模式。 1. 创建型模式...
这份资料详细介绍了在Java编程中常用的23种设计模式,旨在提升开发者对于软件设计的理解和应用能力,从而写出更加高效、可维护和可扩展的代码。 首先,我们来看一下23种设计模式的分类:它们可以分为三大类,即创建...
本压缩包包含的是23种经典设计模式的Java实现源代码,下面我们将详细探讨其中的两种主要模式:单例模式和工厂模式。 1. 单例模式(Singleton Pattern): 单例模式是一种确保一个类只有一个实例,并提供全局访问点...
java23种设计模式详解附带所有代码实现,适合初学者,请点个赞,谢谢
本资源包含了23种经典的Java设计模式的源代码实现,每种模式都有详细的注释,是学习和理解设计模式的宝贵资料。 一、创建型模式(Creational Patterns) 1. 单例模式(Singleton):确保一个类只有一个实例,并提供...
此目录里包括了一书中所有23种设计模式的实现(Java 版)源码 关于代码的几点说明: 1. 代码为根据个人对Design Pattern的学习理解写出(>90%原创), 难免有错误的地方,希望大家指出。 2. 每个Pattern均是一个...
这个压缩包“23种设计模式的java实现源代码.rar”包含了Java语言实现的全部23个经典设计模式,下面我们将逐一探讨这些设计模式及其在Java中的实现。 1. **单例模式(Singleton)**:确保一个类只有一个实例,并提供...
Java中的23种设计模式是软件工程中非常重要的概念,它们是解决常见编程问题的成熟解决方案,被广泛应用于各种复杂的软件系统中。这些模式在不同的上下文中提供了可重用的结构和行为,使得代码更加清晰、可维护和扩展...
花了一个礼拜时间,仔细研究了每一种设计模式,参考了一些网上的实例和板桥里人的设计模式(板桥里人的很多代码都不能运行),精心设计的用例,这些用例都是在有理解的基础之上写的,初学者几天可以搞定,好过你去看那些厚厚...
设计模式分为三大类: 创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 ...
这个压缩包文件包含了23种经典的Java设计模式,这些模式通常被分为三大类:创建型、结构型和行为型。 1. 创建型设计模式: - 单例模式:确保一个类只有一个实例,并提供全局访问点。 - 工厂方法模式:定义一个...
本资源“JAVA之23种设计模式的完整实例代码和注释”涵盖了所有GOF(Gang of Four)提出的23种经典设计模式,它们是软件设计的基石。 1. **创建型模式**(Creational Patterns): - **单例模式(Singleton)**:...