2. 程式人生 > >Android中設計模式--狀態模式（將動作委託到當前狀態，狀態之間可以互相轉換）

Android中設計模式--狀態模式（將動作委託到當前狀態，狀態之間可以互相轉換）

阿新 • • 發佈：2019-01-08

   狀態模式：將狀態封裝成為獨立類，並將動作委託到當前狀態；狀態之間可以相互轉換，因為實現了相同的介面；狀態改變，則動作會跟著改變。

 理解：

1.定義狀態介面，所有的狀態均實現該介面，這樣對於客戶（呼叫者）來說，狀態是可以替換的，客戶不關心具體的狀態是什麼，只是呼叫介面中的方法即可。

 2.狀態之間可以互相轉換，如：去自動售貨機買飲料，先投入硬幣，那麼這時，售貨機會將狀態從“請投幣”，轉換為“請選擇飲料”，這就是狀態的轉換。

 總結：

 找出程式碼中整體邏輯相同，執行動作略有差異的地方，考慮用狀態模式來實現。定義統一的介面，不同的狀態實現相同的介面，介面方法中每種狀態有自己的特色，狀態之間可以相互影響和轉換。

 狀態模式圖如下：


例子：

1.先定義介面，用於所有的狀態來實現該介面

public interface State {
	void doOK(); // 處理確定鍵
	void doBack(); // 處理返回鍵
	void doLeft(); // 處理左鍵
	void doRight(); // 處理右鍵
	MAbsoluteLayout getLayout(); //獲取佈局
	boolean showLeftIcon(); // 左側icon是否顯示
	boolean showRightIcon(); // 右側icon是否顯示
	void animationEndCallBack(); // 動畫結束回撥（用於光纖、耳機口、亮點動畫效果顯示）
	boolean dispatchKeyEvent(KeyEvent event);  // 按鍵處理

}

2.根據需要，定義不同的狀態類，但都要實現統一的介面 
/**
 * 選擇頁，實現State介面
 *
 */
public class SelectView implements State {
	private MAbsoluteLayout mLayout;
	private Context mContext;
	private SelectAdapter mAdapter;
	private MListView mViewList;
	private changeViewCallBack mCallBack; // view切換回調

	@Override
	public void doOK() {
		return;
	}

	@Override
	public void doBack() {
		StaticFunction.getPageHelper().finishPage(KEY_PAGEID.PAGE_HOME);
		
	}

	@Override
	public void doLeft() {
		return;
	}

	@Override
	public void doRight() {
		return;
	}

	
	public SelectView(changeViewCallBack cb, Context context){
		mCallBack = cb;
		mContext = context;		
		initView();		
	}
	
	void initView(){
		View rootView = LayoutInflater.from(mContext).inflate(R.layout.view_select, null);
		mViewList = (MListView)rootView.findViewById(R.id.activity_home_list);
        mAdapter = new SelectAdapter(mCallBack, mContext);
		
		mViewList.setAdapter(mAdapter);
		mViewList.setFocusView(new FocusView(mContext));
		mViewList.setMFocus(true);
		if(null != mViewList.getTopCover()){
			mViewList.getTopCover().setVisibility(View.GONE);
		}
		mLayout = (MAbsoluteLayout)rootView.findViewById(R.id.view_select);
	}
	
	@Override
	public boolean dispatchKeyEvent(KeyEvent event){
		if(KeyEvent.ACTION_DOWN == event.getAction() && KeyCode.BACK == KeyCode.getKeyCode(event)){
			this.doBack();
			return true;
		}
		if (null != mViewList ) {
			mViewList.dispatchKeyEvent(event);
			return true;
		}
		return false;

	}

	@Override
	public MAbsoluteLayout getLayout() {
		return mLayout;
	}

	@Override
	public boolean showLeftIcon() {
		return false;
	}

	@Override
	public boolean showRightIcon() {
		return true;
	}

	@Override
	public void animationEndCallBack() {
		// TODO Auto-generated method stub
		
	}

}
3. 狀態之間可以相互替換，因為都實現了介面，所以不需要關心具體狀態，直接呼叫方法。這點和策略模式非常類似。策略模式請參考我的上一篇文章：http://blog.csdn.net/adayabetter/article/details/45580841

與策略模式不同之處在於，狀態模式執行了相應動作後，可以改變當前狀態。

舉個例子，進行狀態動作呼叫和狀態切換的應該由Activity負責，而具體狀態實現應該是View實現，程式碼如下：

public class GuideHomeActivity extends BaseActivity implements changeViewCallBack{
	private static final String TAG = "GuideHomeActivity";
	private State mNowState;
	private State mBeforeState;
	private MAbsoluteLayout mLayout;
	private MImageView mLeftIcon;
	private MImageView mRightIcon;
	private boolean canTranslate = true; // 是否可以移動
	
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		
		LogHelper.releaseLog(TAG, "onCreate");
		setContentView(R.layout.activity_home);				
		mLayout   = getViewById(R.id.container);
		mLeftIcon = getViewById(R.id.left_icon);
		mRightIcon = getViewById(R.id.right_icon);
		SelectView mView = new SelectView(this, getApplicationContext());
		addPage(mView);
		
	}
	
	@Override
	public boolean dispatchKeyEvent(KeyEvent event) {
		if(canTranslate == true){
			super.dispatchKeyEvent(event);			
			if (KeyEvent.ACTION_DOWN == event.getAction()) {
				if(null != mNowState && mNowState.dispatchKeyEvent(event)){
					return true;
				}
				switch (KeyCode.getKeyCode(event)) {
				case KeyCode.BACK:
					LogHelper.releaseLog(TAG, "dispatchKeyEvent--"+mNowState.getClass().getSimpleName()+"--"+"doBack()");
					mNowState.doBack();
					
					break;
				case KeyCode.LEFT:
					LogHelper.releaseLog(TAG, "dispatchKeyEvent--"+mNowState.getClass().getSimpleName()+"--"+"doLeft()");
					mNowState.doLeft();
					break;
				case KeyCode.RIGHT:
					LogHelper.releaseLog(TAG, "dispatchKeyEvent--"+mNowState.getClass().getSimpleName()+"--"+"doRight()");
					mNowState.doRight();
					break;
				case KeyCode.OK:
					LogHelper.releaseLog(TAG, "dispatchKeyEvent--"+mNowState.getClass().getSimpleName()+"--"+"doOK()");
					mNowState.doOK();
					break;
				default:
					return false;
					
				}
				return true;
			}
			return false;
		}
		return true;
	}
	
	
	
	/**
	 * 設定左右箭頭顯示隱藏
	 * @param showleft true: 顯示，false:隱藏
	 * @param showright
	 */
	public void setLeftRightIcon(boolean showleft, boolean showright){
		if(null != mLeftIcon){ // 左icon
			if(showleft){
				mLeftIcon.setVisibility(View.VISIBLE);
			}
			else{
				mLeftIcon.setVisibility(View.INVISIBLE);
			}
		}
		if(null != mRightIcon){ // 右icon
			if(showright){
				mRightIcon.setVisibility(View.VISIBLE);
			}
			else{
				mRightIcon.setVisibility(View.INVISIBLE);
			}
		}
	}
	
	public void addPage(State state){
		if(null != mPageList && null != state ){   
			if(mPageList.size() > 0){
				mBeforeState = mPageList.get(mPageList.size() - 1);
			}
			mPageList.add(state);
			mNowState = state;
			if(null != mBeforeState){
				animationEnter(mBeforeState.getLayout(), mNowState.getLayout());
			}else{
				mLayout.addView(mNowState.getLayout());
			}
			setLeftRightIcon(mNowState.showLeftIcon(), mNowState.showRightIcon());
		}
	}
	
	public void finishPage(){
		if(null != mPageList && mPageList.size() > 0){
			if(mPageList.size() >1){
				mBeforeState = mPageList.remove(mPageList.size() - 1);
			}
			mNowState = mPageList.get(mPageList.size() - 1);
			if(null != mBeforeState){
				animationBack(mBeforeState.getLayout(), mNowState.getLayout());
			}
			setLeftRightIcon(mNowState.showLeftIcon(), mNowState.showRightIcon());
		}
	}
	
	private List<State> mPageList = new ArrayList<State>(); 
	/**
	 * 進入動畫,左移
	 * @param layoutNow 當前layout
	 * @param layoutRight 右方layout 
	 * 視窗不變，移動mLayout
	 */
	public void animationEnter(MAbsoluteLayout layoutNow,MAbsoluteLayout layoutRight){
		int transDistance = 0;
		if(null != mLayout){
			clearView(layoutNow, layoutRight);
			AbsoluteLayout.LayoutParams nowParams  = (LayoutParams) layoutNow.getMLayoutParams();
			nowParams.x += 1920;
			transDistance = - nowParams.x;
			if(null == layoutRight.getParent() || mLayout != layoutRight.getParent()){
				mLayout.addIView(layoutRight,nowParams);
			}
		}
		ViewPropertyAnimator.animate(mLayout).translationX(transDistance).setListener(new AnimatorListener() {
			
			@Override
			public void onAnimationStart(Animator arg0) {
				canTranslate = false;
			}
			
			@Override
			public void onAnimationRepeat(Animator arg0) {
				
			}
			
			@Override
			public void onAnimationEnd(Animator arg0) {
				canTranslate = true;
				if(null != mNowState){
					mNowState.animationEndCallBack();
				}
			}
			
			@Override
			public void onAnimationCancel(Animator arg0) {
				canTranslate = true;
				
			}
		}).setDuration(500).start();
		
	}
	/**
	 * 退出動畫，右移
	 * @param layoutNow 當前layout
	 * @param layoutRight 左方layout
	 * 視窗不變，移動mLayout
	 */
	public void animationBack(MAbsoluteLayout layoutNow, MAbsoluteLayout layoutLeft){
		int transDistance = 0;
		if(null != mLayout){
			clearView(layoutNow,layoutLeft);
			AbsoluteLayout.LayoutParams nowParams  = (LayoutParams) layoutNow.getMLayoutParams();
			nowParams.x -= 1920;
			transDistance = - nowParams.x;
			
			if(null == layoutLeft.getParent() || mLayout != layoutLeft.getParent()){
				mLayout.addIView(layoutLeft,nowParams);
			}
		}
		ViewPropertyAnimator.animate(mLayout).translationX(transDistance).setListener(new AnimatorListener() {
			
			@Override
			public void onAnimationStart(Animator arg0) {
				canTranslate = false;
			}
			
			@Override
			public void onAnimationRepeat(Animator arg0) {
				
			}
			
			@Override
			public void onAnimationEnd(Animator arg0) {
				canTranslate = true;
			}
			
			@Override
			public void onAnimationCancel(Animator arg0) {
				canTranslate = true;
			}
		}).setDuration(500).start();
	}
	

	/**
	 * 
	 * @param id 頁面標識 
	 * @param duration  0:left,1:right
	 */
	@Override
	public void changeState(StateID id, int direction, KEY_MODE mode) {
		State tmpState = null;
		switch (id) {
		case SELECT_PAGE_BLUETOOTH:
			tmpState = new LightView(this, getApplicationContext(), KEY_MODE.MODE_BLUETOOTH);
			this.addPage(tmpState);	
			break;
		case SELECT_PAGE_OPTICALFIBER:
			tmpState = new SocketView(this, getApplicationContext(), KEY_MODE.MODE_OPTICALFIBER);
			this.addPage(tmpState);	
			break;
		case SELECT_PAGE_HEADSET:
			tmpState = new SocketView(this, getApplicationContext(), KEY_MODE.MODE_HEADSET);
			this.addPage(tmpState);	
			break;
		case SOCKECT_PAGE:
			if(DIRECTION.DIRECTION_RIGHT == direction){
				tmpState = new LightView(this, getApplicationContext(), mode);
				this.addPage(tmpState);
			}
			else if(DIRECTION.DIRECTION_LEFT == direction){
				this.finishPage();
			}
			
			break;
		case LIGHT_PAGE:
			if(DIRECTION.DIRECTION_RIGHT == direction){
				tmpState = new SuccessView(this, getApplicationContext(), mode);
				this.addPage(tmpState);
			}
			else if(DIRECTION.DIRECTION_LEFT == direction){
				this.finishPage();
			}
			
			break;
		case SUCCESS_PAGE:
			this.finishPage();
			break;

		default:
			break;
		}
		
	}
}

從Activity程式碼中可以看到，引用了State全域性變數，執行動作時，直接呼叫State的相應方法，而State狀態值是在Activity中通過changeState方法變化的，通過回撥設定到不同的狀態View中，View是知道何時做出改變，但具體的改變要通過回撥在Activity中實現。關於回撥的理解，請參考我的另一篇文章：http://blog.csdn.net/adayabetter/article/details/44116993


 學習一種模式，一定要自己認真的想一遍，再根據自己的想法，通過程式碼驗證一下，當測試結果和自己想的一致時，再把那種感覺記錄下來，以便日後其他專案用作參考。 謝謝閱讀~

相關推薦

Android中設計模式--狀態模式（將動作委託到當前狀態，狀態之間可以互相轉換）

   狀態模式：將狀態封裝成為獨立類，並將動作委託到當前狀態；狀態之間可以相互轉換，因為實現了相同的介面；狀態改變，則動作會跟著改變。  理解： 1.定義狀態介面，所有的狀態均實現該介面，這樣對於客戶（呼叫者）來說，狀態是可以替換的，客戶不關心具體的狀態是什麼，只是呼叫介

android開發學習 ------- 【轉】 android中的單例模式 （詳解）

lan post tail -- and 使用 href details android開發 https://blog.csdn.net/u011418943/article/details/60139644 這篇文章 前因後果 都說出來了 ，值得學習。 htt

Android中Activity的啟動模式（LaunchMode）和使用場景

一、為什麼需要啟動模式 在Android開發中，我們都知道，在預設的情況下，如果我們啟動的是同一個Activity的話，系統會建立多個例項並把它們一一放入任務棧中。當我們點選返回（back）鍵，這些Activity例項又將從任務棧中一一移除，遵循的原則是“

Android中設計模式-Builder模式

遇到多個構造器引數時要考慮使用構建器 引入：當我們建立物件傳遞引數的時候，往往通過構造方法來傳，如下程式碼： public class Person { private String name; private String id;

對Android中設計模式MVC，MVP，MVVM的簡單理解

設計模式VS框架框架是程式碼的重用，可擴充套件。舉幾個簡單的例子。Spring架構，Struts架構。設計模式是設計的重用，是一種抽象的設計方法。例如MVC，MVP，MVVM。下面，我們以android開發為例，簡單比較一下三種不同的設計模式。MVCMVC是指Modle，Vi

Android中設計模式之單例模式的種類

Android開發設計模式中的單例模式       單例模式是設計模式中最常見也最簡單的一種設計模式，保證了在程式中只有一個例項存在並且能全域性的訪問到。比如在android實際APP 開發中用到的 賬號資訊物件管理， 資料庫物件（SQLiteOpenHelp

ANDROID 中設計模式的採用--結構型模式

       在GOF所著的設計模式經典著作中對橋接模式與介面卡模式的區別描述為：B r i d g e模式的結構與物件介面卡類似，兩個模式的不同之處主要在於它們各自的用途和出發點：B r i d g e目的是將介面部分和實現部分分離和橋接，從而對它們可以較為容易也相對獨立的加以改變和演化，B r i d

Android中的Context類簇（裝飾模式）及Context用法詳解，Application用法詳解

一，Context類簇中的類概述 Context的API文件 類關係： Context類 Context是一個抽象類，原始碼位於android.content包中。描述的是一個應用程式環境的資訊，即上下文。通過它我們可以獲取應用程式的資源和類

Android中的代理(Proxy)模式

ner try 都是 switch語句 困難 .cn turn 重新 交互 一. Proxy模式定義 Proxy模式，也稱代理模式，是經典設計模式中的一種結構型模式，其定義是為其他對象提供一種代理以控制對這個對象的訪問，簡單的說就是在訪問和被訪問對象中間加上的一個間接層

Android中的單例模式(包含Java、Kotlin)

  在Android開發工程中，單例模式可以說是我們使用得非常頻繁的設計模式了。常見的寫法有5種: 餓漢式 懶漢式 同步鎖 雙重校驗 內部類 下面我們對這5種寫法的Java、Kotlin各自舉例。呼叫統一由Kotlin呼叫(其實差別並不大) 一、餓漢式 java

Android中的觀察者模式

最簡單的Android觀察者模式的實現Demo，通過這個例子wome我們可以學習到觀察者模式的基本yong用法，在後續的開發工作中我們可以根據這個思想設計出更好的產品。 觀察者模式是：當一個物件的狀態傳送改變時，所有依賴於它的物件都能得到通知並被自動更新。 下面介紹一種簡單的使用方法，（下面

Android中的單例模式使用場景

1.設計模式例項-單例模式 單例模式，故名思議，是指在一個類中通過設定靜態使得其僅創造一個唯一的例項。這樣設定的目的是滿足開發者的希望??這個類只需要被例項化建立一次，同時因為其為靜態的緣故，載入的速度也應該快於正常例項化一個類的速度（理論上）。 在Android開發中，當

Android中的多程序模式

1.開啟多程序模式 正常情況下，在Android中多程序是指一個應用中存在多個程序的情況。 通過給四大元件指定 android:process屬性，就可以開啟多程序模式。 下面一個例項，描述如何在Activity中建立多程序： <activi

Android中的享元模式

大家對Java中的String物件的特性應該比較熟悉：String型別的物件一旦建立之後就不可修改，當兩個String物件所包含的內容相同時，JVM物件只建立一個String物件對應兩個不同的引用。 public class Test { public

Android中View的測量模式

       Android系統給我們提供了一個設計短小精悍卻功能強大的類——MeasureSpec類，通過它來幫助我們測量View。MeasureSpec是一個32位的int值，其中高2位測量的模式，低30位為測量的大小，在計算中使用位運算的原因是為了提高並優

Android中使用動態代理模式

在最近的專案開發中，在封裝業務層對外介面時，需要對所有的方法操作，例如捕獲自定義的異常訊息等，之後想到使用動態代理的方式進行處理，具體的Demo如下： 1、業務介面類和介面具體實現類 IGlobalService.java public int

android 中activity的啟動模式是singleTask時清除activity的棧頂activity的生命週期小計

安卓開發中經常會涉及到activity啟動模式，當一個activity第singleTASK時 ，清除棧頂的activity的時候，位於棧頂的activity的生命週期是如何走完的呢？這裡做一個小計： BaseActivity的 啟動模式是singleTask模式   

Android中的單例模式

單例模式在設計模式中是最方便人們理解的。雖然容易理解，但裡面坑挺多的，所以在面試題中經常哪來做考題。簡單來說，單例模式，就是為了保證類物件只有並且只能建立一個。規模比較大的類，或者需要反覆使用的類，才

Android中Application單例模式的正確寫法

在Android開發中，經常要在別的類去拿Application的單例，我看過很多單例模式的寫法如下： public class MyApplication extends Application { private static MyApplication my

Android中關於JNI 的學習（一）對於JNIEnv的一些認識

else size 初步 jint 使用 包括 pri jnienv 就會 一個簡單的樣例讓我們初步地了解JNI的作用，可是關於JNI中的一些概念還是須要了解清楚，才可以更好的去利用它來實現我們想要做的事情。 那麽C++和Java之間的是怎樣通過JNI來進行互相調用的呢