来说说（AbstractFactory）静态工厂模式

1。什么时候需要静态工厂模式？

    （1）一个系统要独立于它的产品的创建、组合和表示时。
    （2）一个系统要由多个产品系统中的一个来配置时。
    （3）当你要强调一系列相关的产品对象的设计以便进行联合使用时。
    （4）当你提供一个产品类库，而只想显示它们的接口不是实现时。

2。我们来实现一个静态工厂模式

我们来实现一个UI的静态接口

using System;

namespace AbstractFactory
{

	/// <summary>
	/// 定义UI资源的抽象类
	/// </summary>
	public abstract class UIResourceAbstract
	{
		public abstract void LoadConfig(string path);
		public abstract void LoadAsset(string name);
		public abstract void UnLoadResource(bool status);
	}
}

我们在来实现一个Audio的静态接口

using System;

namespace AbstractFactory
{
	/// <summary>
	/// 定义audio 的抽象类
	/// </summary>
	public abstract class AudioResoucesAbstract
	{
		public abstract void LoadConfig(string path);
		public abstract void LoadAsset(string name);
		public abstract void UnLoadResource(bool status);
	}
}

我们在继续实现一个 ResourceAbstractFactory

using System;

/// <summary>
/// 静态工厂模式
/// </summary>
namespace AbstractFactory
{
	public  abstract class ResourceAbstractFactory
	{
		public abstract UIResourceAbstract CreateUIManager();
		public abstract AudioResoucesAbstract CreateAudioManager();
	}
}

我们在继续实现一个 PrimaryUIManager

using System;
using UnityEngine;

namespace AbstractFactory
{
	public class PrimaryUIManager : UIResourceAbstract
	{
		public override void LoadConfig(string path)
		{
			Debug.Log("PrimaryUIManager: "+path);
		}
		public override void LoadAsset(string name)
		{
			Debug.Log("PrimaryUIManager: "+name);
		}
		public override void UnLoadResource(bool status)
		{
			Debug.Log("PrimaryUIManager: "+status);
		}
	}
}

PrimaryAudioManager实现

using System;
using UnityEngine;

namespace AbstractFactory
{
	public class PrimaryAudioManager :AudioResoucesAbstract
	{
		public override void LoadConfig(string path)
		{
			Debug.Log("PrimaryAudioManager: "+path);
		}
		public override void LoadAsset(string name)
		{
			Debug.Log("PrimaryAudioManager: "+name);
		}
		public override void UnLoadResource(bool status)
		{
			Debug.Log("PrimaryAudioManager: "+status);
		}
	}
}

在实现一个 PrimaryManagerFactory

using System;

namespace AbstractFactory
{
	public class PrimaryManagerFactory : ResourceAbstractFactory
	{
		public  override UIResourceAbstract CreateUIManager()
		{
			return new PrimaryUIManager ();
		}
		public override AudioResoucesAbstract CreateAudioManager()
		{
			return new PrimaryAudioManager();
		}

	}
}

我们继续来实现 Assistant系类的工厂及其创建

using System;
using UnityEngine;

namespace AbstractFactory
{
	public class AssistantUIManager : UIResourceAbstract
	{
		public override void LoadConfig(string path)
		{
			Debug.Log("AssistantUIManager: "+path);
		}
		public override void LoadAsset(string name)
		{
			Debug.Log("AssistantUIManager: "+name);
		}
		public override void UnLoadResource(bool status)
		{
			Debug.Log("AssistantUIManager: "+status);
		}
	}
}

using System;
using UnityEngine;

namespace AbstractFactory
{
	public class AssistantAudioManager : AudioResoucesAbstract
	{
		public override void LoadConfig(string path)
		{
			Debug.Log("AssistantAudioManager: "+path);
		}
		public override void LoadAsset(string name)
		{
			Debug.Log("AssistantAudioManager: "+name);
		}
		public override void UnLoadResource(bool status)
		{
			Debug.Log("AssistantAudioManager: "+status);
		}
	}
}

using UnityEngine;
using System.Collections;

namespace AbstractFactory
{
	/// <summary>
	///定义抽象工厂的具体工厂AssistantManagerFactory
	/// </summary>
	public class AssistantManagerFactory : ResourceAbstractFactory
	{
		public override UIResourceAbstract CreateUIManager()
		{
			return new AssistantUIManager();
		}

		public override AudioResoucesAbstract CreateAudioManager()
		{
			return new AssistantAudioManager();
		}
	}

}

好了，我们已经实现完毕了，我们来进行测试。

using System;
using UnityEngine;
using AbstractFactory;

public class ResourceAbstractFactoryClient : MonoBehaviour
{
	ResourceAbstractFactory rfPrimary;
	AudioResoucesAbstract audioPrimry;
	UIResourceAbstract uiPrimary;

	ResourceAbstractFactory rfAssistant;
	AudioResoucesAbstract audioAssistant;
	UIResourceAbstract uiAssistant;

	void Start()
	{
		rfPrimary = new PrimaryManagerFactory();
		rfAssistant = new AssistantManagerFactory();
	}


	void OnGUI()
	{
		if (GUILayout.Button("主城产品族"))
		{
			audioPrimry = rfPrimary.CreateAudioManager();
			audioPrimry.LoadConfig("http:...");
			audioPrimry.LoadAsset("蛮牛");
			audioPrimry.UnLoadResource(false);

			uiPrimary = rfPrimary.CreateUIManager();
			uiPrimary.LoadConfig("http:...");
			uiPrimary.LoadAsset("蛮牛");
			uiPrimary.UnLoadResource(false);
		}

		if (GUILayout.Button("副城产品族"))
		{
			audioAssistant = rfAssistant.CreateAudioManager();
			audioAssistant.LoadConfig("http:...");
			audioAssistant.LoadAsset("蛮牛");
			audioAssistant.UnLoadResource(false);

			uiAssistant = rfAssistant.CreateUIManager();
			uiAssistant.LoadConfig("http:...");
			uiAssistant.LoadAsset("蛮牛");
			uiAssistant.UnLoadResource(false);
		}
	}
}

好，我们已经大功告成。在什么时候比较适合这种模式呢？我们更是需要注意下面几点。

     如果不存在”多系列对象创建“的需求变化，则没必要应用Abstract Factory模式，静态工厂方法足矣。
    "系列对象"指的是这些对象之间有相互依赖、或作用的关系。例如游戏开发场景中的"道路"与"房屋"依赖，“道路”与“地道”的依赖。
Abstract Factory模式主要在于应对"新系列"的需求变动。其缺点在于难以应对”新对象“的需求变动。
Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化