一個程序員對設計模式的理解:
“不懂”爲什麼要把很簡單的東西搞得那麼複雜。後來隨着軟件開發經驗的增加纔開始明白我所看到的“複雜”恰恰就是設計模式的精髓所在,我所理解的“簡單”就是一把鑰匙開一把鎖的模式,目的僅僅是着眼於解決現在的問題,而設計模式的“複雜”就在於它是要構造一個“萬能鑰匙”,目的是提出一種對所有鎖的開鎖方案。在真正理解設計模式之前我一直在編寫“簡單”的代碼.
這個“簡單”不是功能的簡單,而是設計的簡單。簡單的設計意味着缺少靈活性,代碼很鋼硬,只在這個項目裏有用,拿到其它的項目中就是垃圾,我將其稱之爲“一次性代碼”。
設計原則:(重要)
1.
邏輯代碼獨立到單獨的方法中,注重封裝性--易讀,易複用。
不要在一個方法中,寫下上百行的邏輯代碼。把各小邏輯代碼獨立出來,寫於其它方法中,易讀其可重複調用。
2.
寫類,寫方法,寫功能時,應考慮其移植性,複用性:防止一次性代碼!
是否可以拿到其它同類事物中應該?是否可以拿到其它系統中應該?
3.
熟練運用繼承的思想:
找出應用中相同之處,且不容易發生變化的東西,把它們抽取到抽象類中,讓子類去繼承它們;
繼承的思想,也方便將自己的邏輯建立於別人的成果之上。如ImageField extends JTextField;
熟練運用接口的思想:
找出應用中可能需要變化之處,把它們獨立出來,不要和那些不需要變化的代碼混在一起。
把很簡單的東西搞得那麼複雜,一次性代碼,設計模式優勢的實例說明:(策略模式)
說明:
模擬鴨子游戲的應用程序,要求:遊戲中會出現各種顏色外形的鴨子,一邊游泳戲水,一邊呱呱叫。
直接編寫出各種鴨子的類:MallardDuck//野鴨,RedheadDuck//紅頭鴨,各類有三個方法:
quack():叫的方法
swim():游水的方法
display():外形的方法
即:設計一個鴨子的超類(Superclass),並讓各種鴨子繼承這個超類。
public class Duck{
public void quack(){ //呱呱叫
System.out.println("呱呱叫");
}
public void swim(){ //游泳
System.out.println(" 游泳");
}
public abstratact void display(); /*因爲外觀不一樣,讓子類自己去決定了。*/
}
//野鴨
public class MallardDuck extends Duck{
public void display(){
System.out.println("野鴨的顏色...");
}
}
//紅頭鴨
public class RedheadDuck extends Duck{
public void display(){
System.out.println("紅頭鴨的顏色...");
}
}
public class Duck{
public void quack(){ //呱呱叫
System.out.println("呱呱叫");
}
public void swim(){ //游泳
System.out.println(" 游泳");
}
public abstract void display(); /*因爲外觀不一樣,讓子類自己去決定了。*/
public void fly(){
System.out.println("飛吧!鴨子");
}
}
對於不能飛的鴨子,在子類中只需簡單的覆蓋。
//殘廢鴨
public class DisabledDuck extends Duck{
public void display(){
System.out.println("殘廢鴨的顏色...");
}
public void fly(){
//覆蓋,變成什麼事都不做。
}
}
其它會飛的鴨子不用覆蓋。
對於上面的設計,你可能發現一些弊端,如果超類有新的特性,子類都必須變動,這是我們開發最不喜歡看到的,一個類變讓另一個類也跟着變,這有點不符合OO設計了。這樣很顯然的耦合了一起。利用繼承-->耦合度太高了.
用接口改進.
我們把容易引起變化的部分提取出來並封裝之,來應付以後的變法。雖然代碼量加大了,但可用性提高了,耦合度也降低了。
public interface Flyable{
public void fly();
}
public interface Quackable{
public void quack();
}
最後Duck的設計成爲:
public class Duck{
public void swim(){ //游泳
System.out.println(" 游泳");
}
public abstract void display(); /*因爲外觀不一樣,讓子類自 己去決定了。*/
}
而MallardDuck,RedheadDuck,DisabledDuck 就可以寫成爲:
//野鴨
public class MallardDuck extends Duck implements Flyable,Quackable{
public void display(){
System.out.println("野鴨的顏色...");
}
public void fly(){
//實現該方法
}
public void quack(){
//實現該方法
}
}
//紅頭鴨
public class RedheadDuck extends Duck implements Flyable,Quackable{
public void display(){
System.out.println("紅頭鴨的顏色...");
}
public void fly(){
//實現該方法
}
public void quack(){
//實現該方法
}
}
//殘廢鴨 只實現Quackable(能叫不能飛)
public class DisabledDuck extends Duck implements Quackable{
public void display(){
System.out.println("殘廢鴨的顏色...");
}
public void quack(){
//實現該方法
}
}
好處:
這樣已設計,我們的程序就降低了它們之間的耦合。
不足:
Flyable和 Quackable接口一開始似乎還挺不錯的,解決了問題(只有會飛到鴨子才實現 Flyable),但是Java接口不具有實現代碼,所以實現接口無法達到代碼的複用。
繼承的好處:讓共同部分,可以複用.避免重複編程.
我們有一個設計原則:
找出應用中相同之處,且不容易發生變化的東西,把它們抽取到抽象類中,讓子類去繼承它們;
找出應用中可能需要變化之處,把它們獨立出來,不要和那些不需要變化的代碼混在一起。 -->important.
public interface FlyBehavior{
public void fly();
}
public interface QuackBehavior{
public void quack();
}
我們在定義一些針對FlyBehavior的具體實現。
public class FlyWithWings implements FlyBehavior{
public void fly(){
//實現了所有有翅膀的鴨子飛行行爲。
}
}
public void fly(){
//什麼都不做,不會飛
}
}
針對QuackBehavior的幾種具體實現。
public class Quack implements QuackBehavior{
public void quack(){
//實現呱呱叫的鴨子
}
}
public class Squeak implements QuackBehavior{
public void quack(){
//實現吱吱叫的鴨子
}
}
public class MuteQuack implements QuackBehavior{
public void quack(){
//什麼都不做,不會叫
}
}
這樣的設計,可以讓飛行和呱呱叫的動作被其他的對象複用,因爲這些行爲已經與鴨子類無關了。而我們增加一些新
public class Duck{ --------->在抽象類中,聲明各接口,定義各接口對應的方法.
FlyBehavior flyBehavior;//接口
QuackBehavior quackBehavior;//接口
public Duck(){}
public abstract void display();
public void swim(){
//實現游泳的行爲
}
public void performFly(){
flyBehavior.fly(); -->由於是接口,會根據繼承類實現的方式,而調用相應的方法.
}
public void performQuack(){
quackBehavior.quack();();
}
}
----->通過構造方法,生成'飛','叫'具體實現類的實例,從而指定'飛','叫'的具體屬性
public class MallardDuck extends Duck{
public MallardDuck {
flyBehavior = new FlyWithWings ();
quackBehavior = new Quack();
//因爲MallardDuck 繼承了Duck,所有具有flyBehavior 與quackBehavior 實例變量}
public void display(){
//實現
}
}
這樣就滿足了即可以飛,又可以叫,同時展現自己的顏色了。
我們只需在Duck中加上兩個方法。
public class Duck{
FlyBehavior flyBehavior;//接口
QuackBehavior quackBehavior;//接口
public void setFlyBehavior(FlyBehavior flyBehavior){
this.flyBehavior = flyBehavior;
}
public void setQuackBehavior(QuackBehavior quackBehavior {
this.quackBehavior= quackBehavior;
}
}
------------------------- static Factory Method(靜態工廠) -------------------------
(1)
在設計模式中,Factory Method也是比較簡單的一個,但應用非常廣泛,EJB,RMI,COM,CORBA,Swing中都可以看到此模式
基本概念:
FactoryMethod是一種創建性模式,它定義了一個創建對象的接口,但是卻讓子類來決定具體實例化哪一個類.
通常我們將Factory Method作爲一種標準的創建對象的方法。
當一個類無法預料要創建哪種類的對象或是一個類需要由子類來指定創建的對象時我們就需要用到Factory Method 模
基本概念:
Singleton 是一種創建性模型,它用來確保只產生一個實例,並提供一個訪問它的全局訪問點.對一些類來說,保證只有一個實例是很重要的,比如有的時候,數據庫連接或 Socket 連接要受到一定的限制,必須保持同一時間只能有一個連接的存在.
在於使用static變量;
創建類對象,一般是在構造方法中,或用一個方法來創建類對象。在這裏方法中,加對相應的判斷即可。
實例一:
public class Singleton {
private static Singleton s;
public static Singleton getInstance() {
if (s == null)
s = new Singleton();
return s;
}
}
// 測試類
class singletonTest {
public static void main(String[] args) {
Singleton s1 = Singleton.getInstance();
Singleton s2 = Singleton.getInstance();
if (s1==s2)
System.out.println("s1 is the same instance with s2");
else
System.out.println("s1 is not the same instance with s2");
}
}
s1 is the same instance with s2
實例二:
class Singleton {
static boolean instance_flag = false; // true if 1 instance
public Singleton() {
if (instance_flag)
throw new SingletonException("Only one instance allowed");
else
instance_flag = true; // set flag for 1 instance
}
}
(1)
基本概念:
觀察者模式屬於行爲型模式,其意圖是定義對象間的一種一對多的依賴關係,當一個對象的狀態發生改變時,所有依賴於它的對象都得到通知並被自動更新。
思想:
(一)
建立目標(subject)與觀察者(observer)接口:
目標(subject)接口:
建立一個註冊觀察者對象的接口; public void attach(Observer o);
建立一個刪除觀察者對象的接口; public void detach(Observer o);
建立一個當目標狀態發生改變時,發佈通知給觀察者對象的接口; public void notice();
建立一個當收到目標通知後的更新接口: public void update();
實例:
老師又電話號碼,學生需要知道老師的電話號碼以便於在合時的時候撥打,在這樣的組合中,老師就是一個被觀察者
Subject代碼:
public interface Subject{
public void attach(Observer o);
public void detach(Observer o);
public void notice();
}
public interface Observer{
public void update();
}
import java.util.Vector;
public class Teacher implements Subject{
private String phone;
private Vector students;
public Teacher(){
phone = "";
students = new Vector();
}
public void attach(Observer o){
students.add(o);
}
public void detach(Observer o){
students.remove(o);
}
public void notice(){
for(int i=0;i<students.size();i++)
((Observer)students.get(i)).update();
}
public void setPhone(String phone){
this.phone = phone;
notice(); --關鍵
}
public String getPhone(){
return phone;
}
}
public class Student implements Observer{
private String name;
private String phone;
private Teacher teacher;
public Student(String name,Teacher t){
this.name = name;
teacher = t;
}
public void show(){
System.out.println("Name:"+name+"\nTeacher'sphone:"+phone);
}
public void update(){
phone = teacher.getPhone();
}
}
Client代碼:
package observer;
import java.util.Vector;
public class Client{ -->可以只定義目標者,觀察者,另外的vector,只爲了輸入結果.
public static void main(String[] args){
Vector students = new Vector();
Teacher t = new Teacher();
for(int i= 0 ;i<10;i++){
Student st = new Student("lili"+i,t);
students.add(st);
t.attach(st);
}
t.setPhone("88803807");
for(int i=0;i<10;i++)
((Student)students.get(i)).show();
t.setPhone("88808880");
for(int i=0;i<10;i++)
((Student)students.get(i)).show();
}
}
------------------------------ 迭代器模式(Iterator) -------------------------------
(1)
基本概念:
迭代器模式屬於行爲型模式,其意圖是提供一種方法順序訪問一個聚合對象中得各個元素,而又不需要暴露該對象的
至少可以歷遍first,next,previous,last,isOver,或是歷遍選擇符合某種條件的子元素.
(2)
結構:
由一個接口與一個實現類組成.
接口:
主要是定義各歷遍的方法.
實現類:
需要一個計算點private int current=0 ; 以及一個容器Vector,來存在原來的進行歷遍的一團東西;再對接口方法進
實例:
Iterator接口:
package iterator;
public interface Iterator{
/*
Item:即是集合中的各對象的類型.若爲String,即把所有的ITEM改爲String,若爲其它自定義的類,則改爲各自定義的類
*/
public Item first();
public Item next();
public boolean isDone();
public Item currentItem();
}
package iterator;
import java.util.Vector;
public class Controller implements Iterator{
private int current =0;
Vector channel;
public Controller(Vector v){
channel = v;
}
public Item first(){
current = 0;
return (Item)channel.get(current);
}
public Item next(){
current ++;
return (Item)channel.get(current);
}
public Item currentItem(){
return (Item)channel.get(current);
}
public boolean isDone(){
return current>= channel.size()-1;
}
}
package iterator;
import java.util.Vector;
public interface Television{
public Iterator createIterator();
}
HaierTV類實現了Television接口。
package iterator;
import java.util.Vector;
public class HaierTV implements Television{ ---對象
private Vector channel;
public HaierTV(){
channel = new Vector();
channel.addElement(new Item("channel 1")); --各元素,用VECTOR存放
channel.addElement(new Item("channel 2"));
channel.addElement(new Item("channel 3"));
channel.addElement(new Item("channel 4"));
channel.addElement(new Item("channel 5"));
channel.addElement(new Item("channel 6"));
channel.addElement(new Item("channel 7"));
}
public Iterator createIterator(){
return new Controller(channel); --把這個VECTOR放到迭代器中構造方法中去
}
}
Client客戶端:
package iterator;
public class Client{
public static void main(String[] args){
Television tv = new HaierTV();
Iterator it =tv.createIterator();
System.out.println(it.first().getName());
while(!it.isDone()){
System.out.println(it.next().getName());
}
}
}
Item類的接口:
package iterator;
public class Item{
private String name;
public Item(String aName){
name = aName;
}
public String getName(){
return name;
}
}
(1)
外觀模式屬於結構型模式,Facade模式定義了一個高層接口,這個接口使得這一子系統更加容易使用。
外觀模式的主要用途就是爲子系統的複雜處理過程提供方便的調用方法,使得子系統更加容易被使用。
-->將複雜的過程包含在裏面,提供一個簡單的應用接口即可.
例如在一個泡茶的過程中,需要作如下的工作:燒開水,準備茶葉,把茶葉放在被子裏,把燒開的水放到茶杯中,只
private boolean TeaBagIsSteeped;
public FacadeCuppaMaker(){
System.out.println("FacadeCuppaMaker 準備好沖茶了");
}
public TeaCup makeACuppa(){
TeaCup cup = new TeaCup();
TeaBag teaBag= new TeaBag();
Water water = new Water();
cup.addFacadeTeaBag(teaBag);
water.boilFacadeWater();
cup.addFacadeWater(water);
cup.steepTeaBag();
return cup;
}
}
(1)
適配器模式的意圖是將一個已存在的類/接口進行復用,將其轉換/具體化成客戶希望的另外的一個類/接口。
(2)
如何實例複用:
將要進行復用的類,放到目標類的構造方法中,進行實例化,然後在目標類的相應方法中,進行調用,修改原來方法
public class Adaptee{
public long getPower(long base,long exp){
long result=1;
for(int i=0;i<exp;i++)
result*=base;
return result;
}
}
public interface Target{
public long get2Power(long exp);
}
private Adaptee pt;
public Adapter(){
pt = new Adaptee();
}
public long get2Power(long exp){
return pt.getPower(2,exp); ---修改原來方法中的參數,
}
}
又如:
在SCM中添加的方法:
已有接口:
public boolean updateRecordStates(Double recordId,Double tableNameMapping,int state,boolean
已有實現類:
public boolean updateRecordStates(Double recordId,Double tableNameMapping,int state,boolean
{
return moveTable.updateRecordStates(recordId,tableNameMapping,state,subRecordUpdate);
}
接口:
public boolean updateStatesAdapterForSelfPanel(Double recordId,Double tableNameMapping,int state)
實現類:
public boolean updateStatesAdapterForSelfPanel(Double recordId,Double tableNameMapping,int state)
{
return this.updateRecordStates(recordId,tableNameMapping,state,false);
}
(1)
代理的好處:
--->是可以在間接訪問對象的同時,要其前或後,添加其它的邏輯代碼.
--->對原來邏輯進行添加其它邏輯,最終生成新的邏輯.即:對類的方法添加一些額外的邏輯,生成新的方法邏輯.
靜態代理:
-->一個原類與一個代理類要一一對應。
-->兩者都實現共同的接口或繼承相同的抽象類;
-->只是在代理類中,實例化原類,在原類方法的前後添加新的邏輯。
如下:
抽象角色:
abstract public class Subject
{
abstract public void request();
}
public class RealSubject extends Subject
{
public void request()
{
System.out.println("From real subject.");
}
}
public class ProxySubject extends Subject
private RealSubject realSubject; //以真實角色作爲代理角色的屬性
{ realSubject=new RealSubject(); }
{
preRequest();
}
{
//something you want to do before requesting
}
private void postRequest()
{
//something you want to do after requesting
}
}
Subject sub=new ProxySubject();
Sub.request();
動態代理類
Java動態代理類位於Java.lang.reflect包下,一般主要涉及到以下兩個類:
1)
Interface InvocationHandler:該接口中僅定義了一個方法:invoke(Object obj,Method method, Object[] args)
2)
Proxy:該類即爲動態代理類,其中主要包含以下內容:
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h):返回代理類
所謂Dynamic Proxy是這樣一種class:它是在運行時生成的class,在生成它時你必須提供一組interface給它,然後
3)
在使用動態代理類時,我們必須實現InvocationHandler接口,
public interface Subject
{
public void request();
}
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;
public class DynamicSubject implements InvocationHandler {
private Object sub;
public DynamicSubject(Object obj) {
sub = obj;
}
System.out.println("before calling " + method);
return null;
}
==>
method.invoke(sub,args);
其實就是調用被代理對象的將要被執行的方法,方法參數sub是實際的被代理對象,args爲執行被代理對象相應操作所
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
{
static public void main(String[] args) throws Throwable
{
RealSubject rs = new RealSubject(); //在這裏指定被代理類
InvocationHandler ds = new DynamicSubject(rs); //初始化代理類
Subject subject = (Subject) Proxy.newProxyInstance(rs.getClass().getClassLoader(),rs.getClass
subject.request();
}
實例二:
package dynamicProxy;
public interface Work {
public void startWork();
}
public class JasonWork implements Work {
public void startWork() {
System.out.println("jason start to work...");
}
}
public void startPlay();
}
public void startPlay() {
System.out.println("jason start to play...");
}
}
public static void main(String[] args)
{
JasonWork work=new JasonWork();
InvocationHandler dynamicProxy=new DynamicProxy(work);
Work jasonproxy=(Work)Proxy.newProxyInstance(work.getClass().getClassLoader(),
jasonproxy.startWork();
InvocationHandler dynamicProxy=new DynamicProxy(play);
Play jasonproxy=(Play)Proxy.newProxyInstance(play.getClass().getClassLoader(),
jasonproxy.startPlay();
}
}
===>動態代理類,可以與任何類型的真實類(work/play),進行結合,進行動態的代理.
(1)
State模式定義:
不同的狀態,不同的行爲; 或者說,每個狀態有着相應的行爲.
適用場合:
State模式在實際使用中比較多,適合"狀態的切換".因爲我們經常會使用If elseif else 進行狀態切換, 如果針對狀態的這樣判斷切換反覆出現,我們就要聯想到是否可以採取State模式了.
一個state,包括兩部分: 對象 + 對象內部的屬性(屬性接口+具體屬性)
一個對象,要有其屬性,以及其setter,getter.且設置好其初始狀態+一個調用顯示狀態的方法(裏面就是狀態調用自身的顯示方法).
一個屬性接口,應該有一個執行的方法.
一個具體屬性,須包含對象進去,實現方法中,須設置對象下一個要顯示的屬性-->從而在對象下次調用方法時,其屬性值會變化.
代碼:
public interface Color {
public void show();
{
Color color;
public Color getColor() {
return color;
}
public void setColor(Color color) {
this.color = color;
}
public Light()
{
color=new RedColor(this);
}
public void showColor()
{
color.show();
}
}
{
Light light;
public RedColor(Light light)
{
this.light=light;
}
public void show()
{
System.out.println("the color is red,the car must stop !");
System.out.println("write down all logic shoud do this in this state.....");
light.setColor(new GreenColor(light));
}
}
{
Light light;
public GreenColor(Light light)
{
this.light=light;
}
public void show()
{
System.out.println("the color is green,the car can run !");
System.out.println("write down all logic shoud do this in this state.....");
light.setColor(new YellowColor(light));
}
}
{
Light light;
public YellowColor(Light light)
{
this.light=light;
}
public void show()
{
System.out.println("the color is yellow,the car shoud stop !");
System.out.println("write down all logic shoud do this in this state.....");
light.setColor(new RedColor(light));
}
}
public static void main(String[] args) {
Light light=new Light();
//初始調用爲紅燈
light.showColor();
//再調用爲綠燈
light.showColor();
//再調用爲黃燈
light.showColor();
//不斷調用,不斷循環.
}
}
(1)
主要用於創建對象時,運用共享技術,減少對象對內存的佔用.一個提高程序效率和性能的模式,會大大加快程序的運
就是說在一個系統中如果有多個相同的對象,那麼只共享一份就可以了,不必每個都去實例化一個對象。
新建對象時:
先到hashtable中進行獲取-->判斷取得對象是否爲空-->若是,則新建此對象,且放回hashtable -->若存在,則共享原來
實例: (與靜態工廠模式進行對比)
public interface Car {
public void showCarName();
{
public void showCarName()
{
System.out.println("this is the BMWCar .");
}
}
{
public void showCarName()
{
System.out.println("this is the FordCar .");
}
}
{
public static Car car;
public static Car getCar(String name)
{
if("BMW".equals(name))
{
car = new BMWCar();
}
if("Ford".equals(name))
{
car = new FordCar();
}
return car;
}
}
{
public Car car;
private Hashtable<String,Car> carPool=new Hashtable<String,Car>();
public Car getCar(String name)
{
if("BMW".equals(name))
{
car=carPool.get(name);
if(car==null)
{
car=new BMWCar();
carPool.put(name, car);
}
}
if("Ford".equals(name))
{
car=carPool.get(name);
if(car==null)
{
car=new FordCar();
carPool.put(name, car);
}
}
return car;
}
public int getNumber(){ return carPool.getSize(); }
}
public class Test {
CarFlyWeightFactory carFlyWeightFactory=new CarFlyWeightFactory();
Car carf1=carFlyWeightFactory.getCar("Ford");
carf1.showCarName();
Car carf2=carFlyWeightFactory.getCar("Ford");
carf2.showCarName();
if(carf1==carf2)
{
System.out.println("同一部車來的");
}
else
{
System.out.println("不同一部車來的");
}
System.out.println("車的數量是:"+carFlyWeightFactory.getNumber());
}
}
this is the FordCar .
this is the FordCar .
同一部車來的
(1)
Chain of Responsibility職責鏈模式:
爲了避免請求的發送者和接收者之間的耦合關係,使多個接受對象都有機會處理請求。將這些對象連成一條鏈,並沿着這條鏈傳遞該請求,直到有一個對象處理它爲止。
-->
要沿着鏈轉發請求,並保證接受者爲隱式的,每個鏈上的對象都有一致的處理請求和訪問鏈上後繼者的接口(即如下實例中,在自己方法中再調用一次相同的方法)。
public class Boy {
private boolean hasCar; // 是否有車
private boolean hasHouse; // 是否有房
private boolean hasResponsibility; // 是否有責任心
}
this.hasCar = hasCar;
this.hasHouse = hasHouse;
this.hasResponsibility = hasResponsibility;
}
return hasCar;
}
this.hasCar = hasCar;
}
return hasHouse;
}
this.hasHouse = hasHouse;
}
return hasResponsibility;
}
this.hasResponsibility = hasResponsibility;
}
}
public void handleRequest(Boy boy);
}
private Handler handler;
}
return handler;
}
this.handler = handler;
}
if (boy.isHasHouse()) {
System.out.println("沒想到吧,我還有房子");
} else {
System.out.println("我也沒有房");
handler.handleRequest(boy);
}
}
}
this.handler = handler;
}
return handler;
}
this.handler = handler;
}
if (boy.isHasCar()) {
System.out.println("呵呵,我有輛車");
} else {
System.out.println("我沒有車");
handler.handleRequest(boy);
}
}
}
this.handler = handler;
}
return handler;
}
this.handler = handler;
}
if (boy.isHasResponsibility()) {
System.out.println("我只有一顆帶Responsibility的心");
} else {
System.out.println("更沒有責任心");
handler.handleRequest(boy);
}
}
}
public static void main(String[] args) {
// 這個boy沒有車,也沒有房,不過很有責任心
Boy boy = new Boy(false, false, true);
// 也可以使用setHanlder方法
Handler handler = new CarHandler(new HouseHandler(
new ResponsibilityHandler(null)));
handler.handleRequest(boy);
}
}
如何實例使請求沿着鏈在各接受對象中傳遞,當沒被第一個接受對象接受時,會傳遞給第二個對象,若被第一個對象接受了,則不傳遞下去:
1.各具體的接受對象採用這樣的構造方法:
public CarHandler(Handler handler) { this.handler = handler; }
2.各具體的接受對象實現接口的方法handleRequest()中.在調用時,若被接受,則執行true的內容,若不被接受,則執行false的內容,並繼續調用再調用handleRequest()方法.
3.在最後的測試類中,生成具體的handler時,用多層包含的形式.這樣,在調用了上一層car的方法後,會調用house的相應方法,最後再調用ResponsibilityHandler的方法.
------------------------------ 備忘錄模式(Memento) -------------------------------
(1)
備忘錄模式屬於行爲型模式,其意圖是在不破壞封裝性的前提下,捕獲一個對象的內部狀態,並在該對象之外保存這
實例如下:
有一個對象Employee.除了屬性外,還需要一個保存,還原狀態的方法.
有一個對象Memento,用來記錄Employee每一個時刻的狀態,
CareTaker,用來保存,拿回Memento.需要一個保存,還原狀態的方法.->需要一個指針,一個容器.
public class Memento{
String name;
int age;
public Memento(String name,int age){
this.name = name;
this.age = age;
}
}
Employee模式:
package memento;
public class Employee{
private String name;
private int age;
public Employee(String aName,int aAge){
name = aName;
age = aAge;
}
public void setName(String aName){
name = aName;
}
public void setAge(int aAge){
age = aAge;
}
public Memento saveMemento(){
return new Memento(name,age);
}
public void restoreMemento(Memento memento){
age = memento.age;
name = memento.name;
}
public int getAge(){
return age;
}
public String getName(){
return name;
}
}
CareTaker代碼:
package memento;
import java.util.Vector;
public class CareTaker{
private Vector v;
private int current;
public CareTaker(){
current = -1;
v = new Vector();
}
public void setMemento(Memento mem){
current ++;
v.add(mem);
}
public Memento getMemento(){
if(current>0){
current --;
return(Memento) v.get(current);
}
return null;
}
}
Client代碼:
package memento;
public class Client{
public static void show(Employee e){
System.out.println("-----------------------------------");
System.out.println("Name:"+e.getName());
System.out.println("Age:" + e.getAge());
System.out.println("-----------------------------------");
}
public static void main(String[] args){
Employee e = new Employee("lili",25);
CareTaker ct = new CareTaker();
show(e);
ct.setMemento(e.saveMemento());
e.setName("litianli");
show(e);
ct.setMemento(e.saveMemento());
e.setAge(45);
show(e);
ct.setMemento(e.saveMemento());
//restore
e.restoreMemento(ct.getMemento());
show(e);
e.restoreMemento(ct.getMemento());
show(e);
}
}
本文出自 “Changes we need ! ” 博客,請務必保留此出處http://shenzhenchufa.blog.51cto.com/730213/161581