状态者模式

最新推荐文章于 2024-05-02 14:03:45 发布

LCGG

最新推荐文章于 2024-05-02 14:03:45 发布

阅读量480

点赞数

分类专栏： C# 文章标签：状态者模式

C# 专栏收录该内容

39 篇文章 1 订阅

订阅专栏

一、引言

在上一篇文章介绍到可以使用状态者模式和观察者模式来解决中介者模式存在的问题，在本文中将首先通过一个银行账户的例子来解释状态者模式，通过这个例子使大家可以对状态者模式有一个清楚的认识，接着，再使用状态者模式来解决上一篇文章中提出的问题。

每个对象都有其对应的状态，而每个状态又对应一些相应的行为，如果某个对象有多个状态时，那么就会对应很多的行为。那么对这些状态的判断和根据状态完成的行为，就会导致多重条件语句，并且如果添加一种新的状态时，需要更改之前现有的代码。这样的设计显然违背了开闭原则。状态模式正是用来解决这样的问题的。状态模式将每种状态对应的行为抽象出来成为单独新的对象，这样状态的变化不再依赖于对象内部的行为。

二、状态者模式的定义和类图

状态模式——允许一个对象在其内部状态改变时自动改变其行为，对象看起来就像是改变了它的类。

既然状态者模式是对已有对象的状态进行抽象，则自然就有抽象状态者类和具体状态者类，而原来已有对象需要保存抽象状态者类的引用，通过调用抽象状态者的行为来改变已有对象的行为。经过上面的分析，状态者模式的结构图也就很容易理解了，具体结构图如下图示。

从上图可知，状态者模式涉及以下三个角色：

Account类：维护一个State类的一个实例，该实例标识着当前对象的状态。

State类：抽象状态类，定义了一个具体状态类需要实现的行为约定。

SilveStater、GoldState和RedState类：具体状态类，实现抽象状态类的每个行为。

三、状态者模式的实现

下面，就以银行账户的状态来实现下状态者模式。银行账户根据余额可分为RedState、SilverState和GoldState。这些状态分别代表透支账号，新开账户和标准账户。账号余额在【-100.0，0.0】范围表示处于RedState状态，账号余额在【0.0 ， 1000.0】范围表示处于SilverState，账号在【1000.0，100000.0】范围表示处于GoldState状态。下面以这样的一个场景实现下状态者模式，具体实现代码如下所示：

using UnityEngine;
using System.Collections;

public class Account
{
	public State State {get;set;}
	public string Owner { get; set; }
	public Account(string owner)
	{
		this.Owner = owner;
		this.State = new SilverState(0.0, this);
	}
	
	public double Balance { get {return State.Balance; }} // 余额
	// 存钱
	public void Deposit(double amount)
	{
		State.Deposit(amount);
		Debug.Log("存款金额为 =" + amount);
		Debug.Log("账户余额为 =" + this.Balance);
		Debug.Log(Owner + " :账户状态为: " + this.State.GetType().Name);
	}
	
	// 取钱
	public void Withdraw(double amount)
	{
		State.Withdraw(amount);
		Debug.Log("取款金额为 =" +amount);
		Debug.Log("账户余额为 =" + this.Balance);
		Debug.Log(Owner + " :账户状态为: " + this.State.GetType().Name);
	}
	
	// 获得利息
	public void PayInterest()
	{
		State.PayInterest();
		Debug.Log("Interest Paid --- ");
		Debug.Log("账户余额为 =" + this.Balance);
		Debug.Log(Owner + " :账户状态为: " + this.State.GetType().Name);
	}
}

// 抽象状态类
public abstract class State
{
	// Properties
	public Account Account { get; set; }
	public double Balance { get; set; } // 余额
	public double Interest { get; set; } // 利率
	public double LowerLimit { get; set; } // 下限
	public double UpperLimit { get; set; } // 上限
	
	public abstract void Deposit(double amount); // 存款
	public abstract void Withdraw(double amount); // 取钱
	public abstract void PayInterest(); // 获得的利息
}

// 透支账户 Red State意味着Account透支了
public class RedState : State
{
	public RedState(State state)
	{
		// Initialize
		this.Balance = state.Balance;
		this.Account = state.Account;
		Interest = 0.00;
		LowerLimit = -100.00;
		UpperLimit = 0.00;
	}
	
	// 存款
	public override void Deposit(double amount)
	{
		Balance += amount;
		StateChangeCheck();
	}
	// 取钱
	public override void Withdraw(double amount)
	{
		Debug.Log("没有钱可以取了！");
	}
	
	public override void PayInterest()
	{
		// 没有利息
	}
	//更改状态
	private void StateChangeCheck()
	{
		if (Balance > UpperLimit && Balance < 1000)
		{
			Account.State = new SilverState(this);
		}
		if (Balance >= 1000)
		{
			Account.State = new GoldState(this);
		}
	}
}

// 新开账户 Silver State意味着没有利息得
public class SilverState :State
{
	//构造函数 调用下一构造函数
	public SilverState(State state)
		: this(state.Balance, state.Account)
	{ 
	}
	//构造函数，初始化账户时直接调用
	public SilverState(double balance, Account account)
	{
		this.Balance = balance;
		this.Account = account;
		Interest = 0.00;
		LowerLimit = 0.00;
		UpperLimit = 1000.00;
	}
	
	public override void Deposit(double amount)
	{
		Balance += amount;
		StateChangeCheck();
	}
	public override void Withdraw(double amount)
	{
		Balance -= amount;
		StateChangeCheck();
	}
	
	public override void PayInterest()
	{
		Balance += Interest * Balance;
		StateChangeCheck();
	}
	//更改状态
	private void StateChangeCheck()
	{
		if (Balance < LowerLimit)
		{
			Account.State = new RedState(this);
		}
		else if (Balance > UpperLimit)
		{
			Account.State = new GoldState(this);
		}
	}     
}

// 标准账户 Gold State意味着有利息状态
public class GoldState : State
{
	public GoldState(State state)
	{
		this.Balance = state.Balance;
		this.Account = state.Account;
		Interest = 0.05;
		LowerLimit = 1000.00;
		UpperLimit = 1000000.00;
	}
	// 存钱
	public override void Deposit(double amount)
	{
		Balance += amount;
		StateChangeCheck();
	}
	// 取钱
	public override void Withdraw(double amount)
	{
		Balance -= amount;
		StateChangeCheck();
	}
	public override void PayInterest()
	{
		Balance += Interest * Balance;
		StateChangeCheck();
	}
	//更改状态
	private void StateChangeCheck()
	{
		if (Balance < 0.0)
		{
			Account.State = new RedState(this);
		}
		else if (Balance < LowerLimit)
		{
			Account.State = new SilverState(this);
		}
	}
}

客户端调用程序：

using UnityEngine;
using System.Collections;

public class StatePatternInstance : MonoBehaviour 
{
	void Start () 
	{
		// 开一个新的账户
		Account account = new Account("Champion_Lee");
		
		// 进行交易

		// 存钱
		account.Deposit(2000.0);
		account.Deposit(200.0);
		account.Deposit(600.0);
		
		// 付利息
		account.PayInterest();
		
		// 取钱
		account.Withdraw(2000.00);
		account.Withdraw(1000.00);

		// 存钱
		account.Deposit(2000.0);
		// 取钱
		account.Withdraw(1000.00);

	}
}

从上图可以发现，进行存取款交易，会影响到Account内部的状态，由于状态的改变，从而影响到Account类行为的改变，而且这些操作都是发生在运行时的。

四、应用状态者模式完善中介者模式方案

在上一篇博文中，我曾介绍到中介者模式存在的问题，详细的问题描述可以参考上一篇博文。下面利用观察者模式和状态者模式来完善中介者模式，具体的实现代码如下所示：

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

// 抽象牌友类
public abstract class AbstractCard_Partner
{
	public int MoneyCount { get; set; }
	
	public AbstractCard_Partner()
	{
		MoneyCount = 0;
	}
	
	public abstract void ChangeCount(int Count, Abstract_Mediator mediator);
}

// 牌友A类
public class Parter_A : AbstractCard_Partner
{
	// 依赖与抽象中介者对象
	public override void ChangeCount(int Count, Abstract_Mediator mediator)
	{
		mediator.ChangeCount(Count);
	}
}

// 牌友B类
public class Parter_B : AbstractCard_Partner
{
	// 依赖与抽象中介者对象
	public override void ChangeCount(int Count, Abstract_Mediator mediator)
	{
		mediator.ChangeCount(Count);
	}
}
// 牌友C类
public class Parter_C : AbstractCard_Partner
{
	// 依赖与抽象中介者对象
	public override void ChangeCount(int Count, Abstract_Mediator mediator)
	{
		mediator.ChangeCount(Count);
	}
}
// 抽象状态类
public abstract class State2
{
	protected Abstract_Mediator meditor;
	public abstract void ChangeCount(int count);
}
// 初始化状态类
public class InitState : State2
{
	public InitState()
	{
		Debug.Log("游戏才刚刚开始,暂时还未有玩家胜出");
	}
	
	public override void ChangeCount(int count)
	{
		return;
	}
}
// A赢状态类
public class AWinState : State2
{
	public AWinState(Abstract_Mediator concretemediator)
	{
		this.meditor = concretemediator;
	}
	
	public override void ChangeCount(int count)
	{
		foreach (AbstractCard_Partner p in meditor.list)
		{
			Parter_A a = p as Parter_A;
			// 如果集合对象中是A对象，则对B的钱添加
			if (a != null)
			{
				for(int i = 0 ;i<meditor.list.Count -1; i++)
					a.MoneyCount += count;
			}
			else
			{
				p.MoneyCount -= count;
			}
		}
	}
}

// B赢状态类
public class BWinState : State2
{
	public BWinState(Abstract_Mediator concretemediator)
	{
		this.meditor = concretemediator;
	}
	
	public override void ChangeCount(int count)
	{
		foreach (AbstractCard_Partner p in meditor.list)
		{
			Parter_B b = p as Parter_B;
			// 如果集合对象中是B对象，则对B的钱添加
			if (b != null)
			{
				for(int i = 0 ;i<meditor.list.Count -1; i++)
					b.MoneyCount += count;
			}
			else
			{
				p.MoneyCount -= count;
			}
		}
	}
}
// C赢状态类
public class CWinState : State2
{
	public CWinState(Abstract_Mediator concretemediator)
	{
		this.meditor = concretemediator;
	}
	
	public override void ChangeCount(int count)
	{
		foreach (AbstractCard_Partner p in meditor.list)
		{
			Parter_C b = p as Parter_C;
			// 如果集合对象中是B对象，则对B的钱添加
			if (b != null)
			{
				for(int i = 0 ;i<meditor.list.Count -1; i++)
					b.MoneyCount += count;
			}
			else
			{
				p.MoneyCount -= count;
			}
		}
	}
}


// 抽象中介者类
public abstract class Abstract_Mediator
{
	public List<AbstractCard_Partner> list = new List<AbstractCard_Partner>();
	
	public State2 State { get; set; }
	
	public Abstract_Mediator(State2 state)
	{
		this.State = state;
	}
	
	public void Enter(AbstractCard_Partner partner)
	{
		list.Add(partner);
	}
	
	public void Exit(AbstractCard_Partner partner)
	{
		list.Remove(partner);
	}
	
	public void ChangeCount(int count)
	{
		State.ChangeCount(count);
	}
}

// 具体中介者类
public class Mediator_Pater : Abstract_Mediator
{
	public Mediator_Pater(State2 initState)
		: base(initState)
	{ }
}

客户端调用程序：

using UnityEngine;
using System.Collections;

public class CompleteMediatorPatternInstance : MonoBehaviour {

	// Use this for initialization
	void Start () 
	{
		AbstractCard_Partner A = new Parter_A();
		AbstractCard_Partner B = new Parter_B();
		AbstractCard_Partner C = new Parter_C();
		// 初始钱
		A.MoneyCount = 20;
		B.MoneyCount = 20;
		C.MoneyCount = 20;
		
		Mediator_Pater mediator = new Mediator_Pater(new InitState());
		
		// A,B玩家进入平台进行游戏
		mediator.Enter(A);
		mediator.Enter(B);
		mediator.Enter(C);
		
		// A赢了
		mediator.State = new AWinState(mediator);
		mediator.ChangeCount(5);
		Debug.Log("A 现在的钱是： " + A.MoneyCount);// 应该是30
		Debug.Log("B 现在的钱是： " + B.MoneyCount); // 应该是15
		Debug.Log("C 现在的钱是： " + C.MoneyCount); // 应该是15
		
		// B 赢了
		mediator.State = new BWinState(mediator);
		mediator.ChangeCount(10);
		Debug.Log("A 现在的钱是： " + A.MoneyCount);// 应该是20
		Debug.Log("B 现在的钱是： " + B.MoneyCount); // 应该是35
		Debug.Log("C 现在的钱是： " + C.MoneyCount); // 应该是5

		// C 赢了
		mediator.State = new CWinState(mediator);
		mediator.ChangeCount(10);
		Debug.Log("A 现在的钱是： " + A.MoneyCount);// 应该是10
		Debug.Log("B 现在的钱是： " + B.MoneyCount); // 应该是25
		Debug.Log("C 现在的钱是： " + C.MoneyCount); // 应该是25
	}
}

五、状态者模式的应用场景

在以下情况下可以考虑使用状态者模式。

当一个对象状态转换的条件表达式过于复杂时可以使用状态者模式。把状态的判断逻辑转移到表示不同状态的一系列类中，可以把复杂的判断逻辑简单化。

当一个对象行为取决于它的状态，并且它需要在运行时刻根据状态改变它的行为时，就可以考虑使用状态者模式。

六、状态者模式的优缺点

状态者模式的主要优点是：

将状态判断逻辑每个状态类里面，可以简化判断的逻辑。

当有新的状态出现时，可以通过添加新的状态类来进行扩展，扩展性好。

状态者模式的主要缺点是：

如果状态过多的话，会导致有非常多的状态类，加大了开销。