基本的几个设计模式
- 简单工厂模式
- 单例模式
- 建造者模式（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代理类返回一个aciotn
3.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 list=new ArrayList();
//注册观察者对象
public void attach(Observer obs){
list.add(obs);
}
//删除观察者
public void delete(Observer obs){
list.remove(obs);
}
//通知所有的观察者更新目标对象的状态
protected void notifyAllObservers(){
for(int i=0;ithis);
}
}
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中为对象,利用装饰器进行了封装。