设计模式

最新推荐文章于 2024-09-07 16:16:02 发布

mmhhj

最新推荐文章于 2024-09-07 16:16:02 发布

阅读量1.4k

点赞数

分类专栏：软件工程文章标签：设计模式面向对象设计

本文链接：https://blog.youkuaiyun.com/mmhhj/article/details/52562795

版权

软件工程专栏收录该内容

5 篇文章

订阅专栏

设计模式介绍

设计模式是面向对象设计中产生的概念,是在面向对象设计过程中总结出来的比较优秀的代码组织方式或者说模板,通过这些模板有助于提高代码的质量和实现的效率.
设计模式是对如何组合代码的一种总结,介于架构和编程之间的一种设计方法.

设计的原则:

设计原则是人们在面向对象的实践中总结出来的一些原则,通过实践这些原则有助于提高代码设计质量,灵活性.
开闭原则:对修改关闭,扩展开放,这里反对的是对抽象(或者说是接口)的修改,欢迎的是对扩充的修改.
替换原则:抽象出现的地方,具体也应该能够替代;
迪米特原则(最少知识原则):对象暴露出来的接口应该最少;
接口隔离原则:接口之间是不相关的.可以说此原则与迪米特原则是一致的;
依赖倒置原则:应当依赖接口,而不是依赖具体;通过对接口的编程,实现了灵活性和扩展性;
组合/聚合原则:尽量使用组合/聚合关系,而不是继承关系;

设计模式分类:

按照模式中的对象形态来分可分为类模式和对象模式,类模式就是在编译的时候,关系就已经确定的模式,而对象模式则是在运行时候关系才确定.
按照设计模式的行为来分,可分为创建模式,结构模式,行为模式.

创建模式:

用于创建用户需要的产品,核心角色是创建者。简单工厂模式是类模式，其余是对象模式。

工厂模式（factory）:

目的是将创建对象的细节对用户屏蔽.
工厂模式中主要角色包括:用户,工厂(抽象工厂,具体工厂),产品(抽象产品,具体产品)

创建者模式（builder）:

工厂模式是直接创建一个产品,但如果产品中是由多个组件组成,而且组件组合成产品的过程是稳定的,这时可以通过加入一个指导者的角色来指导产品的组件,这就是建设者模式;
建设者模式中主要角色包括:用户,建造者,指导者,产品.可见建设者模式在工厂模式的基础上添加了一个指导者的角色.

单例模式（single）:

如果需要一个全局的对象,又不想用全局变量来实现(全局变量会带来风险),这时可用一个只有一个实例的对象来实现;
单例模式包括的角色:用户,单例;

原型模式（prototype）:

如果需要多个形态差不多的对象(对象之间完全相同或者仅有细微的差别),又想避免每次都构造这个对象所带来的开销,这时可以用创建一个实例,而其他使用它的用户仅仅是拷贝它来实现.拷贝有浅拷贝和深拷贝之分,浅拷贝仅仅是返回原型的地址,深拷贝对象与原型具有不同的地址.
原型模式中的角色:用户,原型(抽象原型,具体原型)

结构模式:

反映两个(多个)角色之间结构上的关系。除了适配器模式，其余是对象模式。

适配器模式（adapter）:

如果ab对象之间的接口不合适,可以通过引入一个中间者,对a来说接口不变,但实际上调用的是b的新接口.
比如:a,b之间原来有接口,a调用b提供的接口(b.fun)来调用的某一功能,如果b现在接口变了(b.fun2),显然a不能再调用b.fun接口了,但是如果所有用到该接口的程序都需要改成b.fun2不太现实,
这时可以产生一个适配器类,用户对适配器类的接口进行编程,这样,当实际的实现功能的类发生改变时,仅仅是适配器类改变,而作为用户可以不做改变.(这里说的好像意思是需要提前知道有哪些接口可能会变,提前就要设计好适配器类,用户对适配器接口进行编程.)
适配器模式可以通过类适配(适配器派生于被适配对象并实现目标接口)和聚合对象方式(适配器聚合了被适配对象并实现目标接口)来实现.
适配器模式改变了接口(对用户来说没变,但是实际上变了).
适配器模式中的角色包括:用户,目标接口,被适配的对象,适配器.

桥接模式（bridge）:

将抽象与实现之间的继承关系,改成聚合关系,从而使得抽象与实现解耦,实现部分可以独立的变化.
继承关系是一种强关联关系使得实现局限于抽象,但是通过弱的聚合关联关系,可以使得这种关联关系弱化.比如作图过程中的笔有粗细,颜色,形状属性,如果从抽象的笔出发,派生出各种笔,每种笔不同在于形状,颜色和粗细的不同,这种关系就是一种强关联关系.但是,如果将形状,颜色和粗细属性独立出去,然后作为抽象笔的一个成员,抽象笔所完成的工作是基于这些实现上的抽象工作比如draw,这样就能够大大减少派生类的个数,同时保持抽象接口的稳定.桥接模式反映的是抽象和实现类之间结构上的关系,是组合/聚合原则的体现.
需要注意的是不是什么情况都用桥接模式,比如蜡笔其颜色和粗细就不可分,这时只能派生出许多类了.
桥接模式中的角色包括:用户,抽象类(抽象抽象类,具体抽象类),实现类(抽象实现类,具体实现类)

组合模式（composite）:

如果一个对象是由一些简单对象和复杂对象组成，简单对象可以认为是原子，复杂对象是由这些原子所组成的分子，以及由这些分子所组成的细胞，细胞所组成的器官….。
所有这些对象通过一个链条联系起来，对于用户来说，简单对象和复杂对象是不同的，但是它们之间又是有联系的，如何能够通过递归的方式来访问这些对象，并保持接口的稳定。
组合模式的典型应用是树状的文件结构以及菜单。
组合模式中的角色包括：用户，对象（抽象对象，具体对象），抽象对象中定义了对对象的操作接口，具体对象实现了简单对象操作接口和复杂对象的接口。
组合模式又称为“整体-部分模式”。

享元模式（flyweight）:

将多个状态类似的对象共享.与原型模式和单例模式类似,但是前二者只有一个对象,而享元模式包括多个对象,核心是享元工厂.
享元工厂聚合了多个对象.
享元模式中的角色包括:用户,享元工厂,对象(抽象对象,具体对象).

代理模式（proxy）:

如果不能(不想)直接访问对象的接口,可以通过代理的方式来访问.比如市场上的xx代理公司,可以通过他们与你想要的组织建立关系,但不是直接建立关系.
代理者所实现的接口与你想要建立关系的组织具有相同的接口,最终所获得的效果与你直接与组织建立关系所获得的效果是一样的.
代理角色中组合了目标.
代理模式中包括的角色:用户,目标(抽象目标,具体目标),代理.

装饰模式（decorator）:

为了给原来的类添加属性或者功能,又想维持原来的接口(即利用原来的接口,添加更多的功能,迪米特原则?).装饰模式是采用”组合”的方式,
通过引入装饰者角色,将原来的对象动态的组合进来(注意是组合,不是聚合),然后调用原来的接口,同时也可以添加新的功能.避免了通过继承的方法产生大量的子类.
装饰模式中的角色包括:用户,目标类(抽象目标,具体目标),装饰类(抽象装饰,具体装饰)

迭代器模式（iterator）：

为了访问一组对象，不想在对象中实现访问的方法，将访问的方法独立出来，可以使用不同的访问方法访问这些对象。
迭代器中组合了对象组合。迭代器在用户与对象组合间加入迭代器角色，将用户与对象组合访问分离，符合单一职责原则，添加新的数据组合和迭代器只需扩展抽象类，符合开闭原则。
缺点是添加数据组合时需要添加新的迭代器，导致类的成倍增加。
迭代器模式中包括的角色：用户，迭代器（抽象迭代器，具体迭代器），对象组合（抽象组合，具体组合）

外观模式(facade):

假如我们到银行办事，可能有存款，取款，开户等多种业务，是不是每个业务都要到相关的窗口去排队办理，这样也太麻烦了。如果我们到一个窗口就可以办理所有这些业务，
具体这些业务如何在银行内部交互我们并不关心，这个窗口实际上就代表了用户对银行的所有期望。外观模式（或门面模式）就是提供了这样一个系统对外的统一接口，就如同市长热线的接线员一样。
外观模式中的角色包括:用户,内部子系统(抽象内部子系统,具体内部子系统),外观(抽象外观,具体外观)

行为模式:

反映三个(多个)角色之间任务(职责)分配的关系.

职责链模式（chain of reposibility）:

如果一个任务可以由多个对象处理,如何避免用户与对象的直接耦合.可以通过一条链条将对象链接起来,作为用户可以向任意个对象提出请求,该请求
在这条链条中自动传递,直到处理完毕或者返回无法处理的结果.
职责链模式中包括的角色:用户,处理对象(抽象对象,具体对象)

命令模式（command）:

通过将命令封装成类的方式,将命令的调用者和执行者分开.通过这种解耦可以将命令形成一个队列支持undo,redo功能,支持宏命令功能,支持延迟执行功能.
比如遥控器和电视机的关系,遥控器相当于调用者,其发出打开,关闭,调台等命令,电视机是这些命令的执行者.将打开,关闭这些命令分别形成命令的子类,子类中组合了电视机这个执行者,
这样就将调用者和执行者分开,调用者只管发送命令,并不关心谁去执行.
命令中组合了执行者。命令模式有时又称为”事务模式”。
命令模式中的角色包括:用户,调用者,命令(抽象命令,具体命令),执行者.

状态模式（state）:

将对象的状态封装,比如将电梯的启停,开门关门状态封装成各个类,在类中实现电梯的运行函数,运行函数是针对这个具体状态类的,最终的效果是可以减少if/else语句.
具体状态类实现具体状态下的动作,容器类负责调用具体状态类的动作.容器类具有抽象状态类相同的接口.
状态模式优点是封装了状态转换的规则,将所有与状态相关的行为封装到一个类中,可以共享状态类,但是也会导致类的数量增多,维护困难.当状态增多,需要修改状态时,要修改基类,不满足开闭原则.
状态模式中包括的角色:用户,状态(抽象状态,具体状态),容器类;

策略模式（strategy）：

比如去旅游，可以采用汽车方式，轮船方式，飞机方式，就完成旅游这个功能，可以有不同的策略（算法），我们可以把这些策略独立出来，将目标与策略解耦。用户组合了策略。
策略模式中包括的角色：用户，策略（抽象策略，具体策略）
模板模式（template）：
如果业务流程是固定的，可变的是业务流程中某个具体的环节。比如到银行办理业务，流程一般是取号，办理业务，评价。其中的取号和评价动作都是一样的，但是办理业务可能不同，比如取款和存款。
通过模板方式将可以确定的动作抽象出来，比如取号，评价以及业务流程，变动的部分比如办理的具体业务放到派生出来的具体类中去实现。模板模式符合开闭原则，好莱坞原则（父类去找子类
而不是子类去找父类，反向控制）。模板模式对于每个变动都需要扩展一个子类，可能会导致子类过多，但是也符合单一职责原则。
模板模式中的角色包括：用户，业务类（抽象业务，具体业务）。

中介者模式（mediator）:

为了解决类之间的复杂调用关系,将这种调用关系通过引入中介者角色并用类封装起来,实现了调用关系的解耦.
中介者模式中包括的角色:用户,同事类(抽象同事,具体同事),中介者(抽象中介,具体中介).

观察者模式（observer）:

对于同一对象,可能有多个类关心,当这个对象的状态发生改变时,需要通知所有关心它的类.
对象与观察者之间是一种弱关联(观察者通过向对象注册来达到关联的关系,对象提供attach(observer)函数)
观察者模式中包括的角色:用户,对象(抽象对象,具体对象),观察者(抽象观察者,具体观察者)

访问者模式（visitor）:

对于同一组相对固定的对象,有不同的访问者,而且这种访问方式不是固定的.
对象与观察者之间是一种弱关联(对象接受访问者来实现,对象提供accept(visitor)函数);
访问者模式将数据与数据的访问方式分开.
访问者模式要求被访问的对象相对固定,如果对象经常变动会带来较大的改动.
访问者模式中包括的角色:用户,访问者(抽象访问者,具体访问者),对象(抽象对象,具体对象),以及一个对象组合.

工厂模式

/*
 * 以建造宝马汽车为例,介绍工厂模式
 * 
 * */
import java.util.HashMap;
import java.util.Map;
public class factory_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("hello world");
        user user=new user();
        user.createbm();

        user.getbm(640);
        user.getbm2(320);   
        user.getbm3(320);
        user.getbm4(320);

    }

}
class bm{
    String name;
}
class bm320 extends bm{
    bm320(){this.name="320";}
}
class bm640 extends bm{
    bm640(){this.name="640";}
}
class air{
    String name;
}
class bm320_air extends air{
    bm320_air(){this.name="air 320";}
}
class bm640_air extends air{
    bm640_air(){this.name="air 640";}
}
class user{
    bm car;
    air air;
    abs_bmfactory factory;
    abs_factory factory2;
    void createbm(){//用户直接创建对象,不好
    System.out.println("create bm") ;
    }

    void getbm(int id){
    /*简单工厂模式,用户不需要知道创建对象细节,只要将id号交给工厂就可以了*/ 
        factory factory=new factory();
        this.car=factory.createbm(id);
        System.out.println("car is "+car.name);
    }

    void getbm2(int id){
    //工厂方法模式,对于同一类产品的不同品种采用不同工厂类来实现
        if(id==320)
        factory=new bm320factory();
        else if(id==640)
        factory=new bm640factory();
        this.car=factory.createbm();
        System.out.println("car is "+car.name);
    }
    void getbm3(int id){
    //工厂方法模式,采用反射的方法,减小用户复杂度
        Class<?> factoryclass=null;
        Map map=new HashMap();
        //虽然用反射方法,避免了if,else,但是这里用映射的办法,
        实际上是变相的if,else
        map.put(320, "bm320factory");
        map.put(640,"bm640factory");
        try{
        factoryclass = Class.forName((String)map.get(id));
        }
        catch(Exception e){

        }
        try{
        factory=(abs_bmfactory)factoryclass.newInstance();
        }
        catch(Exception e){
        }
        this.car=factory.createbm();
        System.out.println("car is "+car.name);
    }
    void getbm4(int id){
    //抽象工厂方法模式,采用反射的方法,减小用户复杂度
        Class<?> factoryclass=null;
        Map map=new HashMap();
        //虽然用反射方法,避免了if,else,但是这里用映射的办法,
        实际上是变相的if,else
        map.put(320, "bm320_factory");
        map.put(640,"bm640_factory");
        try{
        factoryclass = Class.forName((String)map.get(id));
        }
        catch(Exception e){

        }
        try{
        factory2=(abs_factory)factoryclass.newInstance();
        }
        catch(Exception e){
        }
        this.car=factory2.createcar();
        System.out.println("car is "+car.name);
        this.air=factory2.createair();
        System.out.println("air is "+air.name);
    }
}
//简单工厂模式,虽然对用户隐藏了细节,但是工厂必须是全能的,所有细节都在createbm方法中,
如果增加种类,则需要修改工厂类中的方法.
class factory{
    bm createbm(int id){
        System.out.println("create bm:"+id);
        if(id==320)return new bm320();
        else if(id==640)return new bm640(); 
        else return null;
    }
}
//工厂方法模式,通过对每种产品对应一种工厂,避免了简单工厂模式,增加种类需要修改
工厂方法的弊端,虽然简化了工厂,
//但是对于用户来说增加了复杂度,需要知道哪种产品对应哪个工厂.
interface abs_bmfactory{
     public bm createbm();
}
class bm320factory implements abs_bmfactory{
    public bm createbm(){
        System.out.println("create bm320");
        return new bm320();}
}
class bm640factory implements abs_bmfactory{
    public bm createbm(){
        System.out.println("create bm640");
        return new bm640();}
}
//抽象工厂模式,抽象工厂模式是在工厂方法模式的基础上,添加创建的方法,工厂方法只有一个创建方法,
//而抽象工厂可以有多个创建方法,可以创建该类产品中多个组成,但是对每类产品还是要有一个具体工厂对应.
interface abs_factory{
     public bm createcar();
     public air createair();
}
class bm320_factory implements abs_factory{
    public bm createcar(){
        System.out.println("create bm320");
        return new bm320();}
    public air createair(){
        System.out.println("create bm320_air");
        return new bm320_air();}
}
class bm640_factory implements abs_factory{
    public bm createcar(){
        System.out.println("create bm640");
        return new bm640();}
    public air createair(){
        System.out.println("create bm640_air");
        return new bm640_air();}
}

hello world
create bm
create bm:640
car is 640
create bm320
car is 320
create bm320
car is 320
create bm320
car is 320
create bm320_air
air is air 320

建设者模式

/*
 * 以肯德基套餐为例,将建造者与指导者分开.建造者负责创建复杂对象,指导者指导完成产品的步骤.
 * 
 * */

import java.util.*;
class builder_model{
    public static void main(String args[]){
        director director=new director();
        director.build_food(1);
        director.build_food(2);

    }
}
class product{
    HashMap <String,String> name;
    public product(){
        name=new HashMap<String,String>();
    }
    public void add(String a,String number){
        name.put(a, number);
    }
    public void show(){
         //采用Iterator遍历HashMap  
        Iterator<String> it = name.keySet().iterator();  
        while(it.hasNext()) {  
            String key = (String)it.next();  
            System.out.println(key+",数量:" + name.get(key));  
        }       

    }
}
abstract class abs_builder{
    public abstract void build_1();
    public abstract void build_2();
    public abstract void build_3(); 
    public abstract void build_4(); 
    public abstract void get_product();
}
class builder1 extends abs_builder{
    product product;
    public builder1(){product =new product();
    }
    public void build_1(){
        product .add("汉堡","1");
    }
    public void build_2(){
        product .add("可口可乐","1");
    }
    public void build_3(){
        product .add("芬达","1");
    }
    public void build_4(){
        product .add("薯条","1");
    }   
    public void get_product(){
        product.show();
    }

}
class builder2 extends abs_builder{
    product product;
    public builder2(){product =new product();
    }
    public void build_1(){
        product .add("老北京","1");
    }
    public void build_2(){
        product .add("雪碧","1");
    }
    public void build_3(){

    }
    public void build_4(){

    }   
    public void get_product(){
        product.show();
    }

}

class director{
    abs_builder builder1,builder2;
    director(){
        builder1=new builder1();
        builder2=new builder2();
    }
    void build_food(int id){

        if(id==1){
            System.out.println("1号套餐");
            builder1.build_1();
            builder1.build_2();
            builder1.get_product();         
        }
        else if(id==2){
            System.out.println("2号套餐");
            builder2.build_1();
            builder2.build_2();
            builder1.build_3();
            builder1.build_4();
            builder2.get_product();     
            builder1.get_product();
        }

    }
}
1号套餐
汉堡,数量:1
可口可乐,数量:1
2号套餐
雪碧,数量:1
老北京,数量:1
汉堡,数量:1
芬达,数量:1
薯条,数量:1
可口可乐,数量:1

适配器模式

/*
 * 对于用户来说没有改变接口,但是实际上是通过适配器调用了对象另外的接口
 * 
 * */
class adapter_model{
    public static void main(String args[]){
        adaptee adaptee=new adaptee();
        adapter adapter=new adapter();
        adapter.hello();
        adapter.world();
        adapter2 adapter2=new adapter2(adaptee);
        adapter2.hello();
        adapter2.world();
    }
}

interface target{//目标对象,有两个接口
    public void hello();
    public void world();
}

class adaptee{//被适配对象,其中修改了world接口
    public void hello(){
        System.out.println("hello");
    }
    public void great(){//
        System.out.println("great");
    }
}
//采用类适配方法实现适配器模式
class adapter extends adaptee implements target{
//适配器对象,将被适配对象中修改的world接口实现
    public void world(){
        great();
    }
}
//采用聚合方式实现适配器模式
class adapter2  implements target{
    adaptee adaptee;
    public void world(){
        adaptee.great();
    }
    public void hello(){
        adaptee.hello();
    }
    public adapter2(adaptee a){
        this.adaptee=a;
    }
}

hello
great
hello
great

桥接模式

/*
 * 以画笔为例,将画笔的特性独立出去并以聚合的方式与画笔建立关系.使得二者可以独立变化,减小耦合度.
 * 
 * */
public class bridge_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        pen pen;
        pen=new pen();
        pen.draw();
    }

}
abstract class shape{
    public String para;
    public String get(){return para;
    }
}
class circle extends shape{
    public circle(){para="circle";

    }
}
class retangle extends shape{
    public retangle(){para="retangle";

    }
}
abstract class color{
    String para;
    public String get(){return para;
    }
}
class red extends color{
    public red(){para="red";

    }
}
class blue extends color{
    public blue(){para="blue";

    }
}

class pen{
    color color;
    shape shape;
    public void draw(){
        color=new red();
        shape=new circle();
        System.out.println("color is :"+color.para+", shape is :"+shape.para);
    }
}
hello world
color is :red, shape is :circle

装饰模式

/*
 * 装饰者中组合了原来的对象,并添加新功能,并保持原来接口不变
 * */

public class decorator_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("hello world");
        abs_decorator decorator=new imp_decorator("add some behavior",
        new imp_component());
        decorator.paint();
    }

}
abstract class component{
    public void paint(){
        this.show();
    }
    abstract void show();
}
class imp_component extends component{
    void show(){
        System.out.println("show in imp_componet ");
    }
}
class abs_decorator {
    component component;
    public abs_decorator(component a){
        this.component=a;
    }
    public void paint(){
        component.paint();
    }

}
class imp_decorator extends abs_decorator{
    String prop;
    public imp_decorator(String name,component obj){
        super(obj);
        prop=name;
    }
    public void paint(){
        component.paint();
        System.out.println("in imp_decorator:"+prop);
    }
}

hello world
show in imp_componet 
in imp_decorator:add some behavior

外观模式

/*
 * 以银行为例,将银行内部的多个接口统一成一个接口,对用户来说只要到一个窗口就可以办理所有业务
 * 
 * */

import java.util.*;
public class facade_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("hello world");
        facade facade=new facade();
        String str[]={"save_money","get_money"};
        String str2[]={"save_money","get_money","create_card"};
        try{
        facade.execute(str);
        facade.execute(str2);
        }
        catch(Exception e){

        }
    }

}

abstract class  bank{

    abstract public void work();
}
class get_id extends bank{

    public void work(){
        System.out.println("get id");
    }
}
class pay_reponse extends bank{

    public void work(){
        System.out.println("pay reponse");
    }
}
class save_money extends bank{

    public void work(){
        System.out.println("save money");
    }
}
class get_money extends bank{
    public void work(){
        System.out.println("get money");
    }

}
class create_card extends bank{
    public void work(){
        System.out.println("create card");
    }

}

class facade{
    HashMap<String,String> name;
    bank bank=null;
    Class<?> tmp=null;
    public facade(){
        name=new HashMap<String,String>();
        name.put("save_money","1");
        name.put("get_money","1");
        name.put("create_card","1");

    }
    public void execute(String[] cmd) throws ClassNotFoundException, 
    InstantiationException, IllegalAccessException   {
    //这里抛出异常,在函数中就可以不处理,交给上层,所以上层必须catch它
        int size=cmd.length;
        int i=0;
        //try{
        tmp=Class.forName("get_id");
        bank=(bank)tmp.newInstance();       
        bank.work();
        //}
        //catch(Exception e){

        //}
        for (i=0 ;i<size;i++){
        String str=cmd[i];
            Iterator<String> it = name.keySet().iterator();  
            while(it.hasNext()) {  
                String key = (String)it.next();  
                if(key==str){
                    try{//可以去掉try
                    tmp=Class.forName(str);
                    bank=(bank)tmp.newInstance();
                    }
                    catch(Exception e){

                    }
                    bank.work();
                }


            }           
        }
        try{//可以去掉try
        tmp=Class.forName("pay_reponse");
        bank=(bank)tmp.newInstance();       
        bank.work();
        }
        catch(Exception e){

        }

}

hello world
get id
save money
get money
pay reponse
get id
save money
get money
create card
pay reponse

命令模式command

/*
 * 以电视机遥控器和电视机为例,遥控器作为命令的发出者,电视机作为命令的执行者,将二者分开来.
 * 将电视机控制命令封装成类,并组织起来.
 * */
import java.util.*;
public class command_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("hello world");
        invoker invoker=new invoker();
        receiver rec=new receiver();
        invoker.add(new open_command(rec));
        invoker.add(new close_command(rec));
        invoker.run();
    }

}
class receiver{
    void open(){
        System.out.println("open tv...");
    }
    void close(){
        System.out.println("close tv");
    }
}
abstract class command {
    receiver receiver;
    command(receiver rec){
    //采用组合方式更灵活,如果在command构造函数中new receiver执行者和命令构成聚合关系,不太灵活.
        receiver=rec;
    }
    public abstract void work();
}
class open_command extends command{
    open_command(receiver rec){
        super(rec);
    }
    public void work(){
    receiver.open();
    }
}
class close_command extends command{
    close_command(receiver rec){
        super(rec);
    }   
    public void work(){
        receiver.close();
    }
}
class invoker{
    List<command> list;
    invoker(){
        list=new LinkedList<command>();
    }
    public void add(command cmd){
        list.add(cmd);
    }
    public void run(){
        Iterator<command> it=list.iterator();
        while(it.hasNext()){
            command command=it.next();
            command.work();
        }
    }
}

hello world
open tv...
close tv

中介者模式

/*
 * 通过中介者将同事之间的调用关系封装起来
 * 
 * */

import java.util.*;
//import java.lang.reflect.*;
public class mediator_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        mediator mid;
        colleague zs,ls,wm;
        mid=new concrete_mediator();
        zs=new zhangsan(mid);
        ls=new lisi(mid);
        wm=new wangerma(mid);
        zs.send("hello");
        ls.send("lllll");
        wm.send("wwwww");

    }

}
abstract class mediator{
    abstract void operation(colleague col,String str);
    abstract void attach(colleague col);
}
class concrete_mediator extends mediator{
    HashMap<String,String> map;
    List<colleague> list=null;
    concrete_mediator(){
        map=new HashMap<String,String>();
        map.put("zhangsan","lisi");
        map.put("lisi", "wangerma");
        map.put("wangerma", "zhangsan");
        list=new LinkedList<colleague>();
    }
    protected void attach(colleague col){
        list.add(col);
    }
    protected void operation(colleague col,String str) {
        String from=col.getClass().getName();
        String to=map.get(from);
        colleague to_obj;
        int i;
        for(i=0;i<list.size();i++){
            to_obj=list.get(i);
            if(to_obj.getClass().getName()==to){
                System.out.println(from+" send  to "+to);
                to_obj.notify(str);
                return;
            }
        }
        System.out.println("not find caller");
    }
}
abstract class colleague{
    mediator media;
    colleague(mediator m){
        media=m;
        media.attach(this);
    }
    public abstract void send(String str);
    protected abstract void notify(String str);
}
class zhangsan extends colleague{
    zhangsan(mediator m){
        super(m);
    }
    public void send(String str){
        media.operation(this,str);
    }
    protected void notify(String str){
        System.out.println("zhangsan receive message:"+str);
    }
}

class lisi extends colleague{
    lisi(mediator m){
        super(m);
    }
    public void send(String str){
        media.operation(this,str);
    }
    protected void notify(String str){
        System.out.println("lisi  receive message:"+str);
    }
}

class wangerma extends colleague{
    wangerma(mediator m){
        super(m);
    }
    public void send(String str){
        media.operation(this,str);
    }
    protected void notify(String str){
        System.out.println("wangerma  receive message:"+str);
    }
}
zhangsan send  to lisi
lisi  receive message:hello
lisi send  to wangerma
wangerma  receive message:lllll
wangerma send  to zhangsan
zhangsan receive message:wwwww

观察者模式

/*
 * 以数据为中心,当数据发生变化时,自动通知所有关心此数据的观察者
 * 
 * */

import java.util.*;
public class observer_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        abs_observer obs1=new observer1();
        abs_observer obs2=new observer2();
        abs_subject sub=new real_subject();
        sub.attach(obs1);
        sub.attach(obs2);
        sub.set_state(2);
        sub.set_state(100);
        sub.detach(obs1);
        sub.set_state(300);
    }

}
interface abs_observer{
    public void update(abs_subject subject);
}
class observer1 implements abs_observer{
    public void update(abs_subject subject){
        System.out.println("observer1 receive notify: "+
        subject.getClass().getName()+
        " state is changed ,state is: "+subject.get_state());
    }
}
class observer2 implements abs_observer{
    public void update(abs_subject subject){
        System.out.println("observer2 receive notify: "+
        subject.getClass().getName()+
        " state is changed ,state is: "+subject.get_state());
    }
}
abstract class abs_subject{
    List<abs_observer> list;
    int state;
    abs_subject(){
        list=new LinkedList<abs_observer>();
    }
    void notify_observer(){
        int i;
        for(i=0;i<list.size();i++){
            abs_observer observer=list.get(i);
            observer.update(this);
        }
    }
    void attach(abs_observer observer){
        list.add(observer);
    }
    void detach(abs_observer observer){
        int i;
        for(i=0;i<list.size();i++){
            if(observer==list.get(i)){
                list.remove(i);
            }
        }
    }
    abstract void set_state(int st);
    abstract int get_state();
}

class real_subject extends abs_subject{
    void set_state(int st){
        state=st;
        notify_observer();
    }
    int get_state(){
        return state;
    }
}
observer1 receive notify: real_subject state is changed ,state is: 2
observer2 receive notify: real_subject state is changed ,state is: 2
observer1 receive notify: real_subject state is changed ,state is: 100
observer2 receive notify: real_subject state is changed ,state is: 100
observer2 receive notify: real_subject state is changed ,state is: 300

状态模式

/*
 *以电梯运行为例:
 *电梯运行包括以下状态:开门,关门,运行,停止 
 * */
import java.util.*;
public class state_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Context context=new Context();
        context.set_state("run");
        context.close();
        context.run();
        context.open();
        context.stop();
    }

}
abstract class state{
    Context context;
    abstract void open();
    abstract void close();
    abstract void run();
    abstract void stop();
    void set_context(Context ct){
        context=ct;
    }
}
class open_state extends state{
    void open(){
        System.out.println("do open");
    }
    void close(){
        System.out.println("in open state,can close");
        context.set_state("close");
        context.close();
    }
    void run(){
        System.out.println("in open state,can't run");
    }
    void stop(){
        System.out.println("in open state,can stop");
        context.set_state("stop");
        context.stop();
    }
}
class close_state extends state{
    void open(){
        System.out.println("in close state,can open");
        context.set_state("open");
        context.open();
    }
    void close(){
        System.out.println("do close");
    }
    void run(){
        System.out.println("in close state,can run");
        context.set_state("run");
        context.run();
    }
    void stop(){
        System.out.println("in close state,can stop");
        context.set_state("stop");
        context.stop();
    }
}
class run_state extends state{
    void open(){
        System.out.println("in run state,can't open");
    }
    void close(){
        System.out.println("in run state,not need close");
    }
    void run(){
        System.out.println("do running");
    }
    void stop(){
        System.out.println("in run state,can stop");
        context.set_state("stop");
        context.stop();
    }
}
class stop_state extends state{
    void open(){
        System.out.println("in stop state,can open");
        context.set_state("open");
        context.open();
    }
    void close(){
        System.out.println("in stop state,can close");
        context.set_state("close");
        context.close();        
    }
    void run(){
        System.out.println("in stop state, can running");
        context.set_state("run");
        context.run();
    }
    void stop(){
        System.out.println("do stop");
    }
}
class Context{
    state state=null;
    HashMap<String,state> map;
    state open_state=null;
    state close_state=null;
    state run_state=null;
    state stop_state=null;
    Context(){
        open_state=new open_state();
        close_state=new close_state();
        run_state=new run_state();
        stop_state=new stop_state();
        map=new HashMap<String,state>();
        map.put("open", open_state);
        map.put("close", close_state);
        map.put("run",run_state);
        map.put("stop", stop_state);
    }
    void open(){
        state.open();
    }
    void close(){
        state.close();
    }
    void run(){
        state.run();
    }
    void stop(){
        state.stop();
    }
    void set_state(String str){
        state=map.get(str);
        state.set_context(this);
    }
    state get_state(){
        return state;
    }
}
in run state,not need close
do running
in run state,can't open
in run state,can stop
do stop

策略模式

/*
 * 以旅游出行方式为例,可能有飞机,汽车等方式
 * */
public class strategy_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        strategy strategy1=new strategy1();
        strategy strategy2=new strategy2();
        TravelContext con=new TravelContext(strategy1);
        con.travel();
        con.setStrategy(strategy2);
        con.travel();
    }

}

interface strategy{
    public void travel_strategy();
}
class strategy1 implements strategy{
    public void travel_strategy(){
        System.out.println("use car");
    }
}
class strategy2 implements strategy{
    public void travel_strategy(){
        System.out.println("use plane");
    }
}
class TravelContext{
    strategy strategy;
    TravelContext(strategy sy){
        strategy=sy;
    }
    void setStrategy(strategy sy){
        strategy=sy;
    }
    void travel(){
        System.out.println("travel");
        strategy.travel_strategy();
    }
}
travel
use car
travel
use plane

模板模式

/*
 * 以旅游出行为例,可以有汽车,飞机方式,与策略方式不同,采用继承方式
 * 
 * */
public class template_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        travel travel;

        travel=new travel1();
        travel.do_travel_tmplate();

        travel=new travel2();
        travel.do_travel_tmplate();

        travel=new travel3();
        travel.set_hook(true);
        travel.do_travel_tmplate();
    }

}

abstract class travel{
    boolean hook;
    void sign(){
        System.out.println("sign");
    }
    void bak_home(){
        System.out.println("bak home");
    }
    void do_travel(){}
    boolean is_hook(){
        return hook;
    }
    void set_hook(boolean hk){
        hook=hk;
    }
    void do_hook(){}
    final void do_travel_tmplate(){
        sign();
        do_travel();
        if(is_hook()){
            do_hook();
        }
        bak_home();

    }
}
class travel1 extends travel{
    void do_travel(){
        System.out.println("use car");
    }
}
class travel2 extends travel{
    void do_travel(){
        System.out.println("use plane");
    }
}
class travel3 extends travel{
    void do_travel(){
        System.out.println("use car");
    }
    void do_hook(){
        System.out.println("swim");
    }
}
sign
use car
bak home
sign
use plane
bak home
sign
use car
swim
bak home

访问者模式

/*
 * 以超市购物为例,购物者与收银员对于物品的关注点不同
 * 
 * */
import java.util.*;
public class visitor_model {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        collection collection;
        collection=new collection();
        abs_element e;
        e=new element1();
        collection.add_element(e);
        e=new element1();
        collection.add_element(e);
        e=new element2();
        collection.add_element(e);

        abs_visitor v1,v2;
        v1=new visitor1();
        v2=new visitor2();
        collection.visite(v1);      
        collection.visite(v2);
    }

}
class collection{
    List<abs_element> list;
    collection(){
        list=new LinkedList<abs_element>();
    }
    void add_element(abs_element e){
        list.add(e);
    }
    void visite(abs_visitor v){
        int i;
        for(i=0;i<list.size();i++){
            abs_element e=list.get(i);
            e.accept(v);
        }
    }
}
abstract class abs_visitor{
    abstract void visite_element_1(abs_element e);
    abstract void visite_element_2(abs_element e);
}
abstract class abs_element{
    String id;
    String quality;
    String weight;
    String price;

    abstract void accept(abs_visitor v);
}
class element1 extends abs_element{
    element1(){
        id="1";
        quality="good";
        weight="1kg";
        price="100rmb";
    }
    void accept(abs_visitor v){
        v.visite_element_1(this);
    }
}
class element2 extends abs_element{
    element2(){
        id="2";
        quality="media";
        weight="0.1kg";
        price="10rmb";
    }
    void accept(abs_visitor v){
        v.visite_element_2(this);
    }
}
class visitor1 extends abs_visitor{
    void visite_element_1(abs_element e){
        System.out.println(this.getClass().getName()+
        " pay attention "+e.getClass().getName()+
        " quality: "+e.quality+", price: "+e.price);
    }
    void visite_element_2(abs_element e){
        System.out.println(this.getClass().getName()+
        " pay attention "+e.getClass().getName()+
        " weight: "+e.weight);
    }
}

class visitor2 extends abs_visitor{
    void visite_element_1(abs_element e){
        System.out.println(this.getClass().getName()+
        " pay attention "+e.getClass().getName()+" id: "+
        e.id+", price: "+e.price);
    }
    void visite_element_2(abs_element e){
        System.out.println(this.getClass().getName()+
        " pay attention "+e.getClass().getName()+" id: "+
        e.id+", price: "+e.price);
    }
}
visitor1 pay attention element1 quality: good, price: 100rmb
visitor1 pay attention element1 quality: good, price: 100rmb
visitor1 pay attention element2 weight: 0.1kg
visitor2 pay attention element1 id: 1, price: 100rmb
visitor2 pay attention element1 id: 1, price: 100rmb
visitor2 pay attention element2 id: 2, price: 10rmb