alexboy
- 浏览: 13610 次
-
文章分类
最新评论
23设计模式
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;
}
}
分类: 技术随笔, Java
绿色通道：好文要顶关注我收藏该文与我联系
落花人独立
关注 - 0
粉丝 - 4
+加关注
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) {
}
}
分享到：
发表评论
相关推荐
在“23设计模式源代码”这个资源中，包含的就是这23种经典的设计模式的实现，这将有助于开发者更好地理解和应用这些模式。 首先，我们来逐一了解这23种设计模式： 1. **单例模式**：确保一个类只有一个实例，并...
《尚学堂高琪GOF23设计模式代码与资料详解》 设计模式是软件开发中的重要概念，它代表了在特定上下文中解决常见问题的最佳实践。GOF23设计模式，由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四位...
Java 23设计模式是软件开发中一套经过实践验证的可重用代码组织方式，它为解决特定场景下的常见问题提供了标准的解决方案。这23种设计模式是根据GOF（GoF，Gang of Four）的经典著作《设计模式：可复用面向对象软件...
《23设计模式3》这本书聚焦于面向对象编程领域中的设计模式，这些模式代表了软件设计中的精华经验，旨在提供可复用、高效且清晰的解决方案。设计模式是经过实战检验的最佳实践，可以帮助开发者在遇到常见问题时快速...
### 23设计模式简讲 #### 创建型模式 1. **ABSTRACT FACTORY** - **场景解析**：约会场景中，无论是选择麦当劳还是肯德基，只要告诉店员“来一份B套餐”即可。这里，麦当劳和肯德基就像是抽象工厂，它们提供了一...
《C#23设计模式》深入解析 设计模式是软件工程中的一种最佳实践，是对在特定情境下解决常见问题的模板。C#23设计模式涵盖了23种经典的模式，这些模式可以分为三大类别：创建型、结构型和行为型。在这里，我们将详细...
在这个“23设计模式java源码”压缩包中，你将找到所有23种经典设计模式的Java实现。 1. **单例模式**（Singleton）：确保一个类只有一个实例，并提供一个全局访问点。在Java中，通常使用双重检查锁定或静态内部类来...
"23设计模式2"这个主题涵盖了面向对象设计中的23个核心设计模式，这些都是经过时间考验并被广泛接受的解决方案。 1. **单例模式**：保证一个类只有一个实例，并提供全局访问点。在Java中，单例模式常用于配置管理或...
《C# 23设计模式 (带实例源代码)》这本书深入浅出地介绍了软件开发中的23种经典设计模式，这些模式源自于GOF（GoF，Gang of Four）的经典著作《设计模式：可复用面向对象软件的基础》。设计模式是经过实践验证的解决...
设计模式详解 设计模式是软件开发中的一...在本文中，我们对23种常见的设计模式进行了整理和解释，每种模式都有其优点和缺点，开发者可以根据实际情况选择合适的设计模式，以提高代码的可重用性、可维护性和可扩展性。
GOF 23设计模式的Visio版UML图
### GOF23 设计模式与MM：从追MM谈Java的23种设计模式 #### FACTORY（工厂模式） 工厂模式是一种常见的设计模式，它提供了创建对象的最佳方式。在这个模式下，通常会定义一个创建对象的接口，但是让子类决定实例化...
GOF（GoF）23种设计模式，是由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides四位大神在他们的著作《设计模式：可复用面向对象软件的基础》中提出的，这些模式分为创建型、结构型和行为型三大类。...
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统...
### JAVA 23设计模式一点就通 #### 一、创建型模式 ##### FACTORY（工厂模式） 在软件开发过程中，经常会遇到需要根据不同的条件创建不同类型对象的情况。工厂模式提供了一个解决方案，它定义了一个创建对象的...
"Java23设计模式-jms.zip"这个压缩包包含了一份关于Java设计模式的课程资料，特别是与Java消息服务（JMS）相关的应用。以下是针对Java设计模式的一些详细解释和应用实例。 1. **单例模式**：确保一个类只有一个实例...
设计模式分为创建型、结构型和行为型三类，总共包含23种模式。在C++中实现这些模式，不仅可以提升代码的复用性，还能提高软件的质量和可维护性。 创建型模式包括： - Factory模式：定义一个用于创建对象的接口，让...
《GOF23设计模式的Visio版UML图》是一个关于软件设计模式的重要资源，它包含用Visio工具绘制的UML（统一建模语言）图表，详细展现了GOF23中的23种经典设计模式。这些模式是面向对象编程和设计中不可或缺的组成部分，...