基本的几个设计模式

• 简单工厂模式
• 单例模式
• 建造者模式（Builder）
• 原型模式(prototype)—克隆
• 中介者模式(Mediator)
• 代理模式
• 观察者模式（Observe）
• 策略模式（strategy)
• 状态模式
• 享元模式(Flyweight)
• 装饰器模式

简单工厂模式

public interface Car(){    public void run();}public class Audi implements Car(){    @Override    public void run(){        System.out.println("奥迪在跑!");    }}public class Benz implements Car{    @Override    public void run(){        System.out.println("奔驰在跑!");    }}public class CarFactory{    public static Car createCar(String type){    Car c=null;    if("奥迪".equals(type)){        c=new Audi();        }else if("奔驰".equals(type)){            c=new Benz();        }        return c;    }}public class Client{    public static void main(String []){        Car c1 =CarFactory.createCar("奥迪");        Car ce =CarFactory.createCar("奔驰");        c1.run();        c2.run();    }}

思考问题：
1.公司里，办公用品的领取过程？
2.sun公司设计java时，为解决操作系统之间的差异采用什么手段？
3.Spring的ioc容器的作用，跟我们工厂模式的关系？
（BeanFactory,bean class=”” ..可以通过反射来new 对象。可以把每个new 对象放在map里提高效率。）Factory一般用单例来做。
本质：将实现类、创建类对象统一管理控制，从而将客户端程序跟我们的实现类解耦。

单例模式

保证一个类只有一个实现对象。(如serlvet)
思考如下场景：
1.项目中，读取配置文件的类，一般也只有一个对象。有无必要每次使用配置文件数据，每次new一个对象去读取?
懒汉式单例模式代码：

public class singletonDemo{    private static SingletonDemo s;    private SingletonDemo(){}； //私有化构造器    public static synchronized SingletonDemo getInstance(){    if(s==null){        s=new SingletonDemo();        }        return s;    }}public class Client(    public static void main(String[] args){        SingletonDemo s=singletonDemo.getInstance();        SingletonDemo s2=singletongDemo.getInstance();        System.out.println(s==s2);//结果为true

 饿汉式单例模式代码：

 public class SingletonDemo2{        private statice SingletonDemo2 s=new SingletonDemo2();//第一次加载就被创建，不会发生线程冲突        private SingletonDemo2(){} //私有化构造器        public static singletonDemo2 getInstance(){        return s;        }       }    public class Client{    public  statice void main(String [] args){        SingletonDemo s=SingletonDemo.getInstance();        SingletonDemo s1=SingletonDemo.getInstance();        System.out.prinln(s==s2);//结果为true        }    }

    比如sessionfactory servlet都是单例

建造者模式（Builder）

场景：
1.我们要建造一个复杂的产品，比如：神舟飞船。这个复杂的产品的创建。有这样一个问题需要处理：
装配这些子组建是不是有个步骤问题。
2.实际开发中，我们所需要的对象构建时，也非常复杂，有很多步骤需要处理。

    public class Airship{        private String orbitalModule;//轨道舱        private String engine;//发动机        private String escapeTower;//逃逸塔        public String getOrbitalModule(){            return orbitalModule;        }        public void setOrbitalModule(String orbitalModule){            this.orbitalModule=orbitalModule;            }        public String getEngine(){            return engine;            }        public void setEngine(String engine){            this.engine=engine;            }        public String getEscaperTower(){            return escapeTower;            }        public void setEscapeTower(StringescapeTower){            this.escapeTower=escapeTower;        }    }    public interface AirshipBuilder{        public void builderEngine();        public void builderOrbitalModule();        public void buildderEscapeTower();    }    public class ConcreteAirshipBuilder implements AirshipBuilder{        private Airship airship=new Airship();        @Override        public void buildderEscapeTower(){            System.out.println("建筑逃逸塔,over");            airship.setEscapeTower("莫莫牌逃逸塔!");        }        @Override        public void builderEngine(){            System.out.println("建造发动机，over");            airship.setEngine("莫莫牌火箭发动机");            }        @Override        public void builderOrbitalModule(){            System.out.println("建造轨道舱,over!");            airship.setOrbitalModule("莫莫牌轨道舱");        }        public Airship getAirship(){            return ariship;        }        public void setAirship(Airship airship){            this.airship=airship;        }    }    public class Director{//装配顺序指导        public void creteAirship(AirshipBuilder builder){            builder.builderEngine();            builder.builderOrbitalModule();            builder.builderEscaperTower();        }    }       public class Client{        public statice void main(String [] args){            ConcreteAirshipBuilder builder=new ConcreteAirshipBuilder();            Diretor director =new Director();            director.createAirship(builder);            Airship shenzhou1=builder.getAirship();            System.out.println(shenzhou1.getEngine());            }        }

建造者模式反应了构建类的细节，相当于流水线、装配车间。（StringBuidler、xml解析）

原型模式(prototype)—克隆

场景：
1.思考一下:克隆技术是怎么样的过程？
2.javascript语言中，继承怎么实现？那里面也有prototype.
就是java种的克隆技术，以某个对象为原型，复制出新的对象。他的优势有：效率高(直接克隆,并且避免了重新执行构造过程的步骤)、”接口造接口”。
克隆类似于new ,但是不同于new .new 创建新的对象属性采用的是默认值。克隆出的对象属性值和原型对象相同。并且克隆出的新对象改变不会影响原型对象。

    public class Sheep implements Cloneable{        private String name;        @Override        protected Object clone(){            object obj=null;            try{                obj=super.clone();//直接调用父类的clone方法即可！            }catch(CloneNotSupportedException e){                e.printStackTrace();            }            return obj;        }        public String getSname{            return sname;        }        public Sheep(){            }    }    public class Client{        public static void main(String [] args){            Sheep s1=new Sheep("多利");            Sheep s2=(Sheep)s1.clone();            System.out.println(s1+"--"+s1.getSname());            System.out.println(s2+"--"+s2.getSname());        }

可能有深复制、浅复制；
浅克隆：

深克隆：

1.spring管理structs2总,action是否使用了prototype模式？

中介者模式(Mediator)

场景：
1.假如公司没有总经理。下面三个部门:财务部、市场部、研发部。财务部要发工资，会非常复杂。

    public interface Department{        void action();//做本部门的事情        void advice();//像总经理发出申请    }    public class Development implements Department{        private President p;//总经理        @Override        public void action(){            System.out.println("技术部在开发项目!");        }        @Override        public void advice(){            System.out.println("向总经理报告开发进度,需求资金支持!");        }        public Development(President p){            super();            this.p=p;            p.reqesiter(this,2);        }        public Development()        {}    }    public class Finacial implements Department{        private President p;//总经理        @Override        public void action(){            System.out.println("财务部在数钱!");        }        @Override        public void advice(){            System.out.println("发工资了!");        }        public Development(President p){            super();            this.p=p;            p.reqesiter(this,3);        }        public Finacial()        {}    }        public class Market implements Department{        private President p;//总经理        @Override        public void action(){            System.out.println("市场部在接项目!");        }        @Override        public void advice(){            System.out.println("市场部报告项目承接进度，需要资金支持!");            p.receive(3);        }        public Development(President p){            super();            this.p=p;            p.reqesiter(this,1);        }        public Market()        {}    }    public interface Mediator{       void regesiter(Department department,int type);        void command(int type);        void receive(int type);    }    public class President implements Mediator{        Market m;        Developmet d;        Finacial f;        @Override        public void command(int type){            switch(type){                case 1:                    m.action();                    break;                case 2:                    d.action();                    break;                case 3:                    f.action();                    break;                }                   }            @Override    public void regesiter(Department department,int type){                switch(type){                    case 1:                        m=(Market)department;                        break;                    case 2:                        d=(Development) dapartment;                        break;                    case 3:                        f=(Financial)department;                        break;                    }                }        @Override        public void receive(int type){            System.out.println("受到部门消息！");            command(type);        }    }    public class Client{        public static void main(String [] args){            President p=new President();            Market m=new Market(p);            Development d=new Development(p);            Finacial f=new Finacial(p);            m.advice();        }    }

类图：

初级写游戏时，窗口类是中介者。

代理模式

1.数据库连接池的动态代理的实现。2.struct2 Invocation代理类返回一个aciotn3.sprint AOP动态代理是aop重要的手段。思考下列问题：1.结合动态代理模式，研究structs2中的控制流程Invocation 对象和代理原理。2.hibernate中的懒加载时如何使用代理模式的？3.aop的实现(拦截器都是aop的实现).(时序图)

观察者模式（Observe）

场景：
1.聊天室程序的创建。
2.主题的订阅，当有新内容，则发给所有人。
3.大家一起玩cs游戏，服务器需要和、将每个人的方位变化发给所有的客户。

    public interface Observer{        void update(Subject subject);    }    public class ObserverA implements Observer{        private int mystate;//需要让观察者的状态和目标对象状态保持一致！        @Override        public void update(Subject subject){        mystate=((ConcreteSubject)subject).getState();        }        public int getMystate(){            return mystate;        }        public void setMystate(int mystate){            this.mystate=mystate;        }    }    public class Subject{private List<Observer> list=new ArrayList<Observer>();        //注册观察者对象        public void attach(Observer obs){            list.add(obs);        }        //删除观察者        public void delete(Observer obs){            list.remove(obs);        }        //通知所有的观察者更新目标对象的状态        protected void notifyAllObservers(){            for(int i=0;i<list.size();i++){                list.get(i).update(this);            }        }    public class ConcreteSubject extends Subject{        private int state;        public  int getState(){            return state;        }        public void setState(int state){            this.state=state;            this.notifyAllObervers();        }    }    public class Client{        public static void main(String [] args){        ConcreteSubject subject=new ConcreteSubject();        //创建观察者        ObserverA obs1=new ObserverA();        ObserverA obs2=new ObserverA();        //将上面两个观察者添加到subject的观察队伍中        subject.attach(obs1);        subject.attach(obs2);        //改变subject的状态        subject.setState(1);        //我们看看观察者obs2的状态是不是跟subject状态同步        System.out.println(obs2.getMystate());    }

类图:

1.awt和swing中，事件处理是不是观察者模式？
2.自学并说明,java.util.Observale的作为，并使用这个类来实现观察者模式。

策略模式（strategy)

场景：
1.报价策略：
a)普通客户小批量报价
b)普通客户大批量报价
c)老客户小批量报价
d)老客户大批量报价
设计模式中有”开闭原则”,对扩展开放，对修改关闭。

    public interface Strategy{        public double getprice(double standardprice);    }    public class NewCustomerfewStrategy implements Strategy{        @override        public double getPrice(double standardPrice){            return standardPrice;        }    }    public class NewCustomerManyStrategy implements Strategy{        @Override        public double getPrice(double standardPrice){            return standardPrice*0.9;        }    }    public class OldCustomerfewStrategy implements Strategy{        @Override        public double getPrice(double standardPrice){            return standardPrice*0.85;        }    }    public class OldCustomerfewStrategy implements Strategy{        @Override        public double getPrice(double standardPrice){            return standardPrice*0.8;        }    }    //负责与策略类交互     public class Context{        private Strategy strategy;        public Context(Strategy strategy){            super();            this.strategy=strategy;        }        public void printPrice(double s) { //打印出报价  System.out.println("您的报价:"+strategy.getPrice(s));        }    }    public class Client{        public static void main(String[] args){            Strategy s1=new OldCustomerfewStrategy();            Context cxt=new Context(s1);            cxt.printPrice(220);        }    }

某一个流程可以多种算法实现，可以用策略模式。

状态模式

场景：
1.某个对象状态不同,对应处理方式不一样。
2.公文流转过程。状态有提交、审核、审核未通过、审核未通过、归档等状态，对应处理也不同。
网购过程中，下订单，付款。

    public interface State{        void handle(String param);    }    public class BillState implements State{        @Override        public void handle(String param){            System.out.println("下订单："+param);        }    }    public class PayState implements State{        @Override        public void handle(String param){            System.out.println("付账:"+param);        }    }    public class Context{        private State state;        public  void changeState(State s){            state=s;            state.handle("202");    }    public class Client{        public static void main(String [] args){            Context ctx=new Context();            ctx.changeState(new BillState());            ctx.changeStete(new PayState());        }    }

主要在业务逻辑层工作流用到了设计模式。

享元模式(Flyweight)

场景：
1.一般用于缓存的设计。
对于一些对象的属性值变动不平凡，可以放内存中,设计享元

    public interface Font{        public abstract void SetFont(String color,int size);        public abstract void GetFont();    }    public class ConcreteFont implements Font{        private String color;        private int size;        private String str;        public ConcreteFont(String s){            str=s;        }        public void SetFont(String _color,int _size){            color=_color;            size=_size;        }        public void GetFont(){            System.out.println("String :"+ str+"---color---size is:"+size);        }    }    public class FontFactory{        private Hashtable charHashTable=new Hashtable();        public Font GetFlyweight(String s){            if(charHashTable.get(s)!=null){                return (Font)charHashTable.get(s);            }else{                Font tmp=new ConcreteFont(s);                charHashTable.put(s,tmp);                return tmp;            }        }        public Hashtable GetFactory(){            return charHashTable;        }    }    public class Test{        public static void main(String [] args){            FontFactory myFontFactory=new FontFactory();//一般将享元工厂设成单例            Font f1=myFontFactory.GetFlyWeight("aa");            Font f2=myFontFactory.GetFlyWeight("bb");            Font f3=myFontFactory.GetFlyWeight("aa");            System.out.println(f1);            System.out.println(f2);            System.out.println(f3);        }    }   

1.hibernate缓冲也是

装饰器模式

场景:    1.年底了，要发奖金.年终奖如何计算？    a)当月基本奖金    b)当月团队奖金    c)当年个人奖金    d)当年团队奖金    最终拿到手的应该是上面这些计算的总和。

    public abstract class Component{        abstract void operation();    }    public class ConcreteComponent extends Component{        @override        void operation(){        System.out.println("我是被装饰对象的operation方法!");        }    }    public abstract class Decorator extends Component{        protected Component component;        public Decorator(Component component){            this.component=component;        }    }    @Override    void operation(){        System.out.println("我在调用被装饰对象的operation方法之前！");        component.operation();        System.out.println("我在调用被装饰对象的operation方法之后！");        }    }    public class ConcreteDecoratorA extends Decorator{    public ConcreteDecoratorA(Component component){        super(component);    }    public void operation(){        System.out.println("ConcreteDecoratorA中,可以在调用被装饰方法前做某些处理!");        super.operation();        System.out.println("ConcreteDecoratorA中,可以在调用被装饰方法后做某些处理!");        }    }    public class Client{        public static void main(String [] args){            Component c=new ConcreteComponent();            Decorator d=new ConcreteDecoratorA(c);            d.operation();        }    }

inputstream 如：InputStream is=new Fileinputstream("d:/a.txt");InputStream bis=new BufferedReadReader(is);bis.read();structs2中request等对象的封装处理；request(map) 在servlet中为对象,利用装饰器进行了封装。