设计模式是什么？

设计模式是什么？

设计模式主要更好地解决几个问题：开发时的耦合性、可维护性、可扩展性、可移植性。

1、开发时的耦合性：由于一个大型项目不可能由一个人完全开发，这里为了能够很好的并行开发，不会出现等待别人开发完毕才能够开发的情况，良好的设计模式可以起到很好的作用。

2、可维护性：在一个项目后面更新迭代中可能会出现很多需求的更改，那么良好的设计模式将帮助你更快速的维护。

3、可扩展性：同上，一个项目只要还在使用，就会不断地扩展新功能，好的设计模式可以不用在对原来的结构大动干戈的情况下添加新的功能。

4、可移植性：良好的架构和设计模式让程序可读性更好，在移植到一个新平台上或者使用新的技术移植时将减少错误率。

那么设计模式究竟是什么？

假如你在大街上走着路，很拥挤，这个时候前面的人说你踩到他了，你说并没有，最终吵了一顿或者打了一架才解决，各自散去。

如果这是一个程序，那么这个设计就难以解决这样的问题，我们可以为它添加一个见证人来解决此事。

假设你一天要干100件事情，会让你非常忙碌而且极易犯错，这个时候如果为你设计了多层架构，多层的人员为你服务，你就可以很轻松的达成这100件事并且每一件事情可以做的很细致，不会那么容易犯错。

所以，如何设计使得程序运作时和编码时更易于控制就是设计模式要解决的问题。

我常用的设计模式：

1、整个项目的管理类似公司的管理，有不同的部门不同的负责人，有部门上下级关系，有人员上下级关系。

2、每个人员尽可能小范围的打交道，如果是自己私有的功能仅封装到自己内部。

3、不要越级管理，不要越管理者操作。

4、同级别的人员或部门相互协调完成一件事的时候可以设立专门的监管者来负责此事情。

5、层级依赖，中层依赖底层的实现，高层依赖中层的实现。

6、降低耦合性，多利用接口和抽象类，分工开发。

7、整体处理可以参考树形结构，一个类仅与同级或上下级打交道。

-- 例如当你要和它打交道但是权限不够的话可以通过你的上级，当你和它打交道它处于更底层时，应该分派人员去做这件事。

我认为管理项目就像是管理公司，合理的管理和规划可以引导至一个良好的路线上，

同时也像是开启了上帝模式，你可以操纵一切，你是你，你也不是你，你是这个程序，你也是程序中的每一个成员。

至于协同开发管理一个大型软件，就像你是这个世界的管理员，而别人是别的世界管理员，你们之间需要打交道。

关于23种设计模式

    这些都是单位设计模式，一个软件中会运用到里面的多种组合而成的，视情况使用，根据需求和要解决的问题，衡量后使用，对于它的使用只是为了更好地解决问题，当你开发了足够多的项目时，每次必然会有些总结，可能在事后明白如果当初这么设计可以更好的解决问题，不会很容易出现那么多BUG，或者在重构的时候使用更好的方式来解决同样的问题，这绝不是一朝一夕能够学成的，所以初学程序的人员可以不必要纠结这些更不需要背诵这些东西，因为它会在日后无形中存在于你的设计中，时不时的再看看，对照自己的设计，弥补缺陷或完善设计。

当你足够多的编码的时候，你可以先放一放编码，在设计一个东西前，尽可能的花费更多的时间在架构图上面，或者编写一些接口或抽象类来不断的磨合这个设计，让他更加完美更加易于控制、维护、扩展。

23种设计模式示例：以下以 Flash AS3代码示例：

简单工厂模式：利用接口来引用以及操作实际创建的实例，而实际创建出来的实例可以用一个方法或多个方法来创建

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		/**
		 * 构造函数
		 *
		 */
		public function Main()
		{
			// 创建一个MailSender实例，它同时也是Sender类型
			var m:Sender = createSender("mail");
			m.send();
			// 创建一个SmsSender实例，它同时也是sms类型
			var s:Sender = createSender("sms");
			s.send();
		}
		/**
		 * 普通模式：利用字符串创建实例
		 * 创建一个Sender，具体会创建哪个类的实例取决于参数type
		 * @param type 类别
		 * @return 接口Sender的实现类
		 *
		 */
		public function createSender(type:String):Sender{
		   switch(type){
		     case "mail":
				 return new MailSender();
			 case "sms":
				 return new SmsSender();
		   }
		   return null;
		}

		/**
		 * 多方法模式：利用多个方法创建实例，避免传递的字符串出错导致为null
		 * @return
		 *
		 */
		public function createMailSender():Sender{
			return new MailSender();
		}
		public function createSmsSender():Sender{
			return new SmsSender();
		}

		/**
		 * 多静态方法模式：利用多个静态方法创建实例，避免传递的字符串出错导致为null
		 * @return
		 *
		 */
		public static function createMailSender():Sender{
			return new MailSender();
		}
		public static function createSmsSender():Sender{
			return new SmsSender();
		}

	}
}
package
{
	public interface Sender
	{
		/**
		 * 发送
		 *
		 */
		function send():void;
	}
}
package
{
	public class MailSender implements Sender
	{
		public function MailSender()
		{
		}
		/**
		 * Mail方式发送
		 *
		 */
		public function send():void
		{
			trace("MailSender");
		}
	}
}
package
{
	public class SmsSender implements Sender
	{
		public function SmsSender()
		{
		}
		/**
		 * Sms方式发送
		 *
		 */
		public function send():void
		{
			trace("SmsSender");
		}
	}
}

工厂方法模式：利用工厂接口来引用和操作和具体的工厂，然后利用产品接口引用和操作这个工厂产生的具体的产品实例

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var p:Provider = new SendMailFactory();
			var s:Sender = p.produce();
			s.send();
		}
	}
}
package
{
	public interface Provider
	{
		function produce():Sender;
	}
}
package
{
	public class SendMailFactory implements Provider
	{
		public function SendMailFactory()
		{
		}

		public function produce():Sender
		{
			return new MailSender();
		}
	}
}
package
{
	public class SendSmsFactory implements Provider
	{
		public function SendSmsFactory()
		{
		}

		public function produce():Sender
		{
			return new SendSmsFactory();
		}
	}
}
package
{
	public interface Sender
	{
		function send():void;
	}
}
package
{
	public class MailSender implements Sender
	{
		public function MailSender()
		{
		}
		public function send():void
		{
			trace("MailSender");
		}
	}
}
package
{
	public class SmsSender implements Sender
	{
		public function SmsSender()
		{
		}
		public function send():void
		{
			trace("SmsSender");
		}
	}
}

抽象工厂模式：接口工厂操作具体的工厂，工厂生产多个具体的产品，不同的工厂生产的同种产品也有相同的接口，如XX工厂牌肥皂和YY工程牌肥皂，肥皂是接口，XX工厂牌肥皂和YY工厂牌肥皂是具体的实现类

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var f1:Factory = new darkFactory();
			var keyboard:Keyboard = f1.createKeyboard();
			keyboard.keyDown(0);
			var mouse:Mouse = f1.createMouse();
			mouse.mouseUp(0);

			var f2:Factory = new kdsFactory();
			var keyboard2:Keyboard = f2.createKeyboard();
			keyboard2.keyDown(0);
			var mouse2:Mouse = f2.createMouse();
			mouse2.mouseUp(0);

		}
	}
}
package
{
	public interface Factory
	{
		function createKeyboard():Keyboard;
		function createMouse():Mouse;
	}
}
package
{
	public interface Keyboard
	{
		function keyDown(key:uint):void;
	}
}
package
{
	public interface Mouse
	{
		function mouseUp(key:uint):void;
	}
}
package
{
	public class darkFactory implements Factory
	{
		public function darkFactory()
		{
		}
		public function createKeyboard():Keyboard{
			return new darkKeyboard();
		}
		public function createMouse():Mouse{
			return new darkMouse();
		}
	}
}
package
{
	public class kdsFactory implements Factory
	{
		public function kdsFactory()
		{
		}
		public function createKeyboard():Keyboard{
		      return new kdsKeyboard();
		}
		public function createMouse():Mouse{
			  return new kdsMouse();
		}
	}
}
package
{
	public class darkKeyboard implements Keyboard
	{
		public function darkKeyboard()
		{
		}

		public function keyDown(key:uint):void
		{
			trace("darkKeyboard!!!");
		}
	}
}
package
{
	public class darkMouse implements Mouse
	{
		public function darkMouse()
		{
		}

		public function mouseUp(key:uint):void
		{
			trace("darkMouse!!!");
		}
	}
}
package
{
	public class kdsMouse implements Mouse
	{
		public function kdsMouse()
		{
		}

		public function mouseUp(key:uint):void
		{
			trace("kdsMouse...");
		}
	}
}
package
{
	public class kdsKeyboard implements Keyboard
	{
		public function kdsKeyboard()
		{
		}

		public function keyDown(key:uint):void
		{
			trace("kdsKeyboard...");
		}
	}
}

单例模式：保证整个内存里只存在一份该类的实例

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var m:Mouse = Mouse.getMouse();

			var m2:Mouse = Mouse.getMouse();

			trace(m==m2); // true

		}
	}
}
package
{
	public class Mouse
	{
		public static var self:Mouse;
		public function Mouse()
		{

		}

		public static function getMouse():Mouse{
		   return self?self:self=new Mouse();
		}

	}
}

建造者模式：流程顺序用接口控制，保证流程是相同的，具体不同的施工实现该流程不同，生产出来的产品细节上就不一样

package
{
	import Interface.Builder;
	import Interface.product;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var builder1:Builder = new darkBuilder();
			var director:Director = new Director(builder1);
			director.construct();
			var product1:product = builder1.getResult();
			trace(product1.name);

			var builder2:Builder = new kdsBuilder();
			var director2:Director = new Director(builder2);
			director2.construct();
			var product2:product = builder2.getResult();
			trace(product2.name);

		}
	}
}
package Interface
{
	public interface Builder
	{
		function buildPartA():void;
		function buildPartB():void;
		function buildPartC():void;
		function getResult():product;
	}
}
package Interface
{
	public interface product
	{
		function get name():String;
	}
}
package
{
	import Interface.Builder;
	import Interface.product;

	public class darkBuilder implements Builder
	{
		private var darkStr:String = "";
		public function darkBuilder()
		{
		}

		public function buildPartA():void
		{
			darkStr+="AAA";
		}

		public function buildPartB():void
		{
			darkStr+="BBB";
		}

		public function buildPartC():void
		{
			darkStr+="CCC";
		}

		public function getResult():product
		{
			return new kdsProduct(darkStr);
		}
	}
}
package
{
	import Interface.product;

	public class darkProduct implements product
	{
		private var _name:String;
		public function darkProduct(name:String)
		{
			_name = name + "[is Dark]";
		}

		public function get name():String
		{
			return _name;
		}
	}
}
package
{
	import Interface.Builder;

	public class Director
	{
		private var _builder:Builder;
		public function Director(builder:Builder)
		{
			_builder = builder;
		}

		public function construct():void{
			_builder.buildPartA();
			_builder.buildPartB();
			_builder.buildPartC();
		}
	}
}
package
{
	import Interface.Builder;
	import Interface.product;

	public class kdsBuilder implements Builder
	{
		private var str:String="";
		public function kdsBuilder()
		{
		}

		public function buildPartA():void
		{
			str+="kdsA ";
		}

		public function buildPartB():void
		{
			str+="kdsB ";
		}

		public function buildPartC():void
		{
			str+="kdsC ";
		}

		public function getResult():product
		{
			return new kdsProduct(str);
		}
	}
}
package
{
	import Interface.product;

	public class kdsProduct implements product
	{
		private var _name:String;
		public function kdsProduct(name:String)
		{
		   _name = name;
		}

		public function get name():String
		{
			return _name;
		}
	}
}

原型模式：利用接口或抽象类，要有一个clone的方法，方便克隆这个实例

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var p:Product = new kdsProduct("yes");
			var pClone:Object = p.clone();
			trace(p,pClone,p==pClone,p.name,pClone.name);
		}
	}
}
package
{
	import flash.utils.ByteArray;

	public class kdsProduct extends Product
	{

		public function kdsProduct(name:String)
		{
			this.name = name;
		}
		public override function clone():Object{
		   var by:ByteArray = new ByteArray();
		   by.writeObject(this);
		   by.position = 0;
		   var obj:Object = by.readObject();
		   return obj;
		}
	}
}
package
{
	public class Product
	{
		public var name:String;
		public function Product()
		{
		}

		public function clone():Object
		{
			return null;
		}
	}
}

类的适配器模式：父类有接口中的A方法，子类有接口中的B方法，子类接上该接口，父类不接

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var p:IPeople = new Son();
			p.func1();
			p.func2();
		}
	}
}
package
{
	public interface IPeople
	{
		function func1():void;
		function func2():void;
	}
}
package
{
	public class Father
	{
		public function Father()
		{
		}

		public function func1():void{
		   trace("this is function 1!!");
		}

	}
}
package
{
	public class Son extends Father implements IPeople
	{
		public function Son()
		{
			super();
		}

		public function func2():void
		{
			trace("this is function 2!");
		}
	}
}

对象的适配器模式：某个实例中存在另外一个实例，调用这个实例中的某方法时实际上是用另一个实例执行了该方法，而这某个实例接入与某接口

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var f:Father = new Father();
			var s:IPeople = new Son(f);
			s.func1();
			s.func2();
		}
	}
}
package
{
	public interface IPeople
	{
		function func1():void;
		function func2():void;
	}
}
package
{
	public class Father
	{
		public function Father()
		{
		}

		public function func1():void{
		   trace("this is function 1!!");
		}

	}
}
package
{
	public class Son implements IPeople
	{
		private var father:Father;
		public function Son(father:Father)
		{
			this.father = father;
			super();
		}

		public function func2():void
		{
			trace("this is function 2!");
		}

		public function func1():void
		{
			father.func1();
		}

	}
}

接口的适配器模式：主要是接口方法太多但我只用到少数几个，这个时候要有一个父类来空实现该接口，子类继承于父类，重写关键的方法即可

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var p:IPeople = new Son();
			p.func1();
			p.func2();

		}
	}
}
package
{
	public interface IPeople
	{
		function func1():void;
		function func2():void;
		function func3():void;
		function func4():void;
		function func5():void;
	}
}
package
{
	public class Father implements IPeople
	{
		public function Father()
		{
		}

		public function func1():void{

		}
		public function func2():void{

		}
		public function func3():void{

		}
		public function func4():void{

		}
		public function func5():void{

		}

	}
}
package
{
	public class Son extends Father
	{
		public function Son()
		{

		}

		public override function func2():void
		{
			trace("this is function 2!");
		}

		public override function func1():void{
			trace("this is function 1!");
		}

	}
}

装饰模式：未包装的类和包装的类都接入于同一个接口，但包装的实例中含有未包装的实例对象，所以调用同一方法可以在未包装的基础上再包装一些东西

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var np:NormalPeople = new NormalPeople();
			var ap:AdvancePeople = new AdvancePeople(np);
			ap.say();
		}
	}
}
package Interface
{
	public interface IPeople
	{
		function say():void;
	}
}
package
{
	import Interface.IPeople;

	public class NormalPeople implements IPeople
	{
		public function NormalPeople()
		{
		}

		public function say():void{
		   trace("I am a normal people!");
		}

	}
}
package
{
	import Interface.IPeople;

	public class AdvancePeople implements IPeople
	{
		private var norPeople:NormalPeople;
		public function AdvancePeople(norPeople:NormalPeople)
		{
			this.norPeople = norPeople;
		}

		public function say():void
		{
			trace("My name is kds");
			norPeople.say();
			trace("And I like games!");
		}
	}
}

代理模式：有些类似装饰模式但你不用控制被包装和包装者，只要创建一个代理者，它会自动创建相关人员来进行工作

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var pr:Proxy = new Proxy();
			pr.say();
		}
	}
}
package Interface
{
	public interface IPeople
	{
		function say():void;
	}
}
package
{
	import Interface.IPeople;

	public class NormalPeople implements IPeople
	{
		public function NormalPeople()
		{
		}

		public function say():void{
		   trace("I am a normal people!");
		}

	}
}
package
{
	import Interface.IPeople;

	public class Proxy implements IPeople
	{
		private var norPeople:NormalPeople;
		public function Proxy()
		{
			this.norPeople = new NormalPeople();
		}

		public function say():void
		{
			trace("My name is kds");
			norPeople.say();
			trace("And I like games!");
		}
	}
}

外观模式：一个产品包含不同的组件，实现产品的某个功能的时候实际上是调用不同组件的功能组合而成，对于此类设计方式，个人觉得编程语言应该提供便捷的方式申明该类仅供哪个或哪几个类调用，不会被其他的外部访问

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var p:People = new People();
			p.dance();
		}
	}
}
package
{
	public class People
	{
		private var foot:Foot;
		private var face:Face;
		private var hand:Hand;
		public function People()
		{
			foot = new Foot();
			face = new Face();
			hand = new Hand();
		}

		public function dance():void{
			trace("开始跳舞了！");
			foot.dance();
			face.dance();
			hand.dance();
			trace("跳舞结束");
		}

	}
}
package
{
	public class Face
	{
		public function Face()
		{
		}
		public function dance():void{
			trace("保持微笑！");
		}
	}
}
package
{
	public class Foot
	{
		public function Foot()
		{
		}

		public function dance():void{
		   trace("脚步舞动！");
		}

	}
}
package
{
	public class Hand
	{

		public function Hand()
		{

		}

		public function dance():void{
			trace("比划有节奏！");
		}
	}
}

组合模式：树形结构很适用，比如容器和子容器的关系

package
{

	import flash.display.Sprite;

	import kds.Sprite;

	public class Main extends flash.display.Sprite
	{
		public function Main()
		{
			var sp:kds.Sprite = new kds.Sprite("father");
			var spSon1:kds.Sprite = new kds.Sprite("son1");
			var spSon2:kds.Sprite = new kds.Sprite("son2");
			var spGrandson:kds.Sprite = new kds.Sprite("grandson1");

			sp.addChild(spSon1);
			sp.addChild(spSon2);
			spSon1.addChild(spGrandson);

			trace(sp.name,sp.numChildren); // father 2

			trace(sp.getChildAt(0).name,sp.getChildAt(0).numChildren); // son1 1

			trace(sp.getChildAt(1).name,sp.getChildAt(1).numChildren); // son2 0

			trace(spGrandson.parent==sp.getChildAt(0)); // true

		}
	}
}
package kds
{
	public class Sprite
	{
		private var _name:String;
		private var _parent:Sprite;
		private var _childs:Vector.<Sprite> = new Vector.<Sprite>();
		public function Sprite(name:String)
		{
			_name=name;
		}

		public function get name():String{
		   return _name;
		}

		public function setParent(sp:Sprite):void{
			_parent = sp;
		}

		public function get parent():Sprite{
		    return _parent;
		}

		public function addChild(sp:Sprite):void{
			_childs.push(sp);
			sp.setParent(this);
		}

		public function removeChild(sp:Sprite):void{
			_childs.splice(_childs.indexOf(sp),1);
			sp.setParent(null);
		}

		public function get numChildren():uint{
			return _childs.length;
		}

		public function getChildAt(index:int):Sprite{
		    return _childs[index];
		}

	}
}

享元模式：就是打造一个对象池，不用的对象扔回来，不过为了下次复用的时候不会夹杂着上次使用它时的设置，你可以在扔回来的时候clear或者重设它数据的时候覆盖全部属性

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var obj1:Object = objPool.getObject();
			var obj2:Object = objPool.getObject();
			var obj3:Object = objPool.getObject();

			objPool.disposeObject(obj1);
			objPool.disposeObject(obj2);

			var obj4:Object = objPool.getObject();
			var obj5:Object = objPool.getObject();

			trace(obj4==obj1,obj5==obj2); // true true

		}
	}
}
package
{
	public class objPool
	{
		private static var objs:Array = [];

		public static function getObject():Object{
		   if(objs.length==0){
		      var obj:Object = new Object();
			  return obj;
		   }
		   return objs.shift();
		}

		public static function disposeObject(obj:Object):void{
			// clear 如果每次用的obj的key不一样就删除掉全部，如果都是统一的后面使用时候覆盖了就没事不用做清理
			for (var key:String in obj){
			   delete obj[key];
			}
			objs.push(obj);
		}
	}
}

策略模式：实现提供多个方法给用户来决定选择使用哪一个，更新的话只需要更新新的方法即可

package
{
	import Interface.ISplit;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var split:ISplit = new SplitMinus();
			trace(split.split("1+1-3=5")); // 1+1,3=5
		}
	}
}
package Interface
{
	public interface ISplit
	{
		function split(str:String):Array;
	}
}
package
{
	import Interface.ISplit;

	public class SplitMinus implements ISplit
	{
		public function SplitMinus()
		{
		}

		public function split(str:String):Array
		{
			return str.split("-");
		}
	}
}
package
{
	import Interface.ISplit;

	public class SplitPlus implements ISplit
	{
		public function SplitPlus()
		{
		}

		public function split(str:String):Array{
		   return str.split("+");
		}

	}
}

模板方法模式：打造一个抽象类，可以放置抽象方法或实现方法，子类继承后重写抽象方法或实现方法

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var c:CalcSon = new CalcSon();
			trace(c.plus(3,3));
			trace(c.minus(3,3));
		}
	}
}
package
{
	public class Calc
	{
		public function Calc()
		{
		}

		public function plus(a:int,b:int):int{
		   return 0;
		}

		public function minus(a:int,b:int):int{
		   return a-b;
		}

	}
}
package
{
	public class CalcSon extends Calc
	{
		public function CalcSon()
		{
		}
		public override function plus(a:int, b:int):int{
		   return a+b;
		}
	}
}

观察者模式：一个管理员管理着多个观察者，当某个状态被改变的时候要通知给所有观察者，这样每个观察者才能是观察到最新的信息

package
{
	import Interface.IPeople;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{

			var peo1:IPeople = new People();
			var peo2:IPeople = new People();
			PeopleManager.reg(peo1);
			PeopleManager.reg(peo2);
			PeopleManager.sendMessage("hello!");

		}
	}
}
package Interface
{
	public interface IPeople
	{
	  function receiveMessage(msg:String):void;
	}

}
package
{
	import Interface.IPeople;

	public class PeopleManager
	{
		private static var peoples:Vector.<IPeople> = new Vector.<IPeople>();

		public static function reg(peo:IPeople):void{
			peoples.push(peo);
		}

		public static function sendMessage(str:String):void{
		    for each (var peo:IPeople in peoples){
			   peo.receiveMessage(str);
			}
		}

	}
}
package
{
	import Interface.IPeople;

	public class People implements IPeople
	{
		private var id:int=idCount++;
		private static var idCount:int;
		public function People()
		{
		}

		public function receiveMessage(msg:String):void
		{
			trace(id,msg);
		}
	}
}

迭代子模式：一个产品内部的集合利用另外一个迭代器来遍历查询操作

package
{
	import Interface.IItems;
	import Interface.IIterator;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var items:IItems = new Items();
			var it:IIterator = items.iterator;
			while(it.haseNext)
				trace("next",it.next());

			var obj:Object
			while(obj=it.previous())
			    trace("last",obj);

		}
	}
}
package Interface
{
	public interface IItems
	{
		function get iterator():IIterator;
		function getObject(i:int):Object;
		function get size():int;
	}
}
package Interface
{
	public interface IIterator
	{
		function previous():Object;
		function next():Object;
		function get haseNext():Boolean;
		function first():Object;
	}
}
package
{
	import Interface.IItems;
	import Interface.IIterator;

	public class Items implements IItems
	{
		public var datas:Array = [1,2,3,4,5,6,7];
		public function Items()
		{
		}

		public function get iterator():IIterator
		{
			return new Iterator(this);
		}

		public function getObject(i:int):Object
		{
			return datas[i];
		}

		public function get size():int
		{
			return datas.length;
		}
	}
}
package
{
	import Interface.IIterator;

	public class Iterator implements IIterator
	{
		private var items:Items;
	    private var index:int = -1;
		public function Iterator(items:Items)
		{
			this.items = items;
		}

		public function previous():Object
		{
			return index==-1?null:index==0?items.getObject(--index):items.getObject(--index);
		}

		public function next():Object
		{
			return index==items.size-1?items.getObject(index):items.getObject(++index);
		}

		public function get haseNext():Boolean
		{
			return index==items.size-1?false:true;
		}

		public function first():Object
		{
			return items.getObject(0);
		}
	}
}

责任链模式：创建一个链表，比如你可以让它自动推进

package
{
	import Interface.IList;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var firstList:IList = new List("No.First");
			var nowList:IList = firstList;
			for(var i:int = 0;i<Math.random()*10+5;i++){
				var list:IList = new List("No."+int(Math.random()*10000).toString());
				nowList.setNext(list);
				nowList = list;
			}
			firstList.say();

		}
	}
}
package Interface
{
	public interface IList
	{
		function say():void;
		function setNext(next:IList):void;
	}
}
package
{
	import Interface.IList;

	public class List implements IList
	{
		private var next:IList;
		private var name:String;
		public function List(name:String)
		{
			this.name = name;
		}

		public function setNext(next:IList):void{
		    this.next = next;
		}

		public function say():void{
		    trace(name);
			if(next)next.say();
		}

	}
}

命令模式：发出命令，让别人执行，或者执行完毕后通知我，可以不用关注别人怎么去做的，只要求得到结果

package
{
	import Interface.ICommander;
	import Interface.IMan;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			// 我让指挥官命令跑步，指挥官只是命令其下面的人跑步，至于具体怎么跑，每个人不一样
			var commander:ICommander = new Commander();
			var cook:IMan = new Cook();
			var soldier:IMan = new Soldier();
			commander.addMan(cook);
			commander.addMan(soldier);
			commander.commandRun();
			commander.commandWalk();
		}
	}
}
package Interface
{
	public interface ICommander
	{
		function commandRun():void;
		function commandWalk():void;
		function addMan(man:IMan):void;
	}
}
package Interface
{
	public interface IMan
	{
		function run():void;
		function walk():void;
	}
}
package
{
	import Interface.ICommander;
	import Interface.IMan;

	public class Commander implements ICommander
	{
		private var mans:Vector.<IMan> = new Vector.<IMan>();
		private var soldier:Array = [];
		public function Commander()
		{
		}

		public function commandRun():void
		{
			mans.forEach(function(prt:IMan,i:int,arr:Vector.<IMan>):void{
				prt.run();
			},this);
		}

		public function commandWalk():void
		{
			mans.forEach(function(prt:IMan,i:int,arr:Vector.<IMan>):void{
				prt.walk();
			},this);
		}

		public function addMan(man:IMan):void{
			mans.push(man);
		}

	}
}
package
{
	import Interface.IMan;

	public class Cook implements IMan
	{
		public function Cook()
		{
		}

		public function run():void
		{
			trace("我是厨子，跑不动，只能跑500米！");
		}

		public function walk():void
		{
			trace("我是厨子，我可以走2000米！");
		}
	}
}
package
{
	import Interface.IMan;

	public class Soldier implements IMan
	{
		public function Soldier()
		{
		}

		public function run():void
		{
			trace("我是士兵，但我受伤了，我只能跑50米！");
		}

		public function walk():void
		{
			trace("我是士兵，跟你说过我受伤了，不过走的话可以走500米！");
		}
	}
}

备忘录模式：利用第三方记录某个人当前的状态，这样如果有需要可以还原它当时的状态。

package
{
	import Interface.ICommander;
	import Interface.IMan;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			// 我让指挥官命令跑步，指挥官只是命令其下面的人跑步，至于具体怎么跑，每个人不一样
			var commander:ICommander = new Commander();
			var cook:IMan = new Cook();
			var soldier:IMan = new Soldier();
			commander.addMan(cook);
			commander.addMan(soldier);
			commander.commandRun();
			commander.commandWalk();
		}
	}
}
package Interface
{
	public interface ICommander
	{
		function commandRun():void;
		function commandWalk():void;
		function addMan(man:IMan):void;
	}
}
package Interface
{
	public interface IMan
	{
		function run():void;
		function walk():void;
	}
}
package
{
	import Interface.ICommander;
	import Interface.IMan;

	public class Commander implements ICommander
	{
		private var mans:Vector.<IMan> = new Vector.<IMan>();
		private var soldier:Array = [];
		public function Commander()
		{
		}

		public function commandRun():void
		{
			mans.forEach(function(prt:IMan,i:int,arr:Vector.<IMan>):void{
				prt.run();
			},this);
		}

		public function commandWalk():void
		{
			mans.forEach(function(prt:IMan,i:int,arr:Vector.<IMan>):void{
				prt.walk();
			},this);
		}

		public function addMan(man:IMan):void{
			mans.push(man);
		}

	}
}
package
{
	import Interface.IMan;

	public class Cook implements IMan
	{
		public function Cook()
		{
		}

		public function run():void
		{
			trace("我是厨子，跑不动，只能跑500米！");
		}

		public function walk():void
		{
			trace("我是厨子，我可以走2000米！");
		}
	}
}
package
{
	import Interface.IMan;

	public class Soldier implements IMan
	{
		public function Soldier()
		{
		}

		public function run():void
		{
			trace("我是士兵，但我受伤了，我只能跑50米！");
		}

		public function walk():void
		{
			trace("我是士兵，跟你说过我受伤了，不过走的话可以走500米！");
		}
	}
}

状态模式：根据这个人的状态改变，它自己所执行的相同的方法结果可能就不一样，同时你也可以根据它的状态做出不同的事

package
{
	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var p:People = new People();
			p.run();
			p.state = State.HURT;
			p.run();
		}
	}
}
package
{
	public class People
	{
		public var state:uint = State.NORMAL;
		public function People()
		{

		}
		public function run():void{
		    switch(state)
			{
				case State.NORMAL:
					trace("正常的跑步");
					break;
				case State.HURT:
					trace("装作正常的跑步");
					break;
			}
		}
	}
}
package
{
	public class State
	{
		public static const NORMAL:uint = 0;
		public static const HURT:uint = 1;
	}
}

访问者模式：调用我的方法实际上是让另一个访问者来访问我的公开属性，如果需求有更改只要替换访问者即可

package
{
	import Interface.Ivisitor;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			// 东西
			var goods:Goods = new Goods();
			// 建立两个不同级别的访问者，前者访问级别低
			var v:Ivisitor = new Visitor();
			goods.showName(v);

			var v2:Ivisitor = new VisitorAdvance();
			goods.showName(v2);

		}
	}
}
package
{
	import Interface.Ivisitor;

	public class Goods
	{
		public var name:String = "好东西";
		public var sexsurname:String = "我不是"
		public function Goods()
		{
		}

		public function showName(visitor:Ivisitor):void{
		   return visitor.showName(this);
		}

	}
}
package
{
	import Interface.Ivisitor;

	public class Visitor implements Ivisitor
	{
		public function Visitor()
		{
		}

		public function showName(goods:Goods):void{
		   trace(goods.name);
		}
	}
}
package
{
	import Interface.Ivisitor;

	public class VisitorAdvance implements Ivisitor
	{
		public function VisitorAdvance()
		{
		}
		public function showName(goods:Goods):void{
			trace(goods.sexsurname + goods.name);
		}
	}
}
package Interface
{
	public interface Ivisitor
	{
		function showName(goods:Goods):void;
	}
}

中介者模式：我并不直接操作people进行工作，而是通过中介者-Shop，让中介者来对people操作

package
{
	import Interface.IShop;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var shop:IShop = new Shop();
			shop.createShopKeeper();
			shop.workAll();
		}
	}
}
package Interface
{
	public interface IShop
	{
		function createShopKeeper():void;
		function workAll():void;
	}
}
package
{
	public class People
	{
		private var workTime:int;
		public function People()
		{
			workTime = int(Math.random()*6)+2;
		}
		public function work():void{
		   trace("我工作",workTime,"小时");
		}
	}
}
package
{
	import Interface.IShop;

	public class Shop implements IShop
	{
		private var peopleArr:Array = [];
		public function Shop()
		{
		}

		public function createShopKeeper():void
		{
			peopleArr.push(new People());
			peopleArr.push(new People());
			peopleArr.push(new People());
			peopleArr.push(new People());
		}

		public function workAll():void
		{
			for each(var people:People in peopleArr){
				people.work();
			}
		}
	}
}

解释器模式：根据这个人的状态改变，它自己所执行的相同的方法结果可能就不一样，同时你也可以根据它的状态做出不同的事

package
{
	import Interface.IMachining;

	import flash.display.Sprite;

	public class Main extends Sprite
	{
		public function Main()
		{
			var item:Item = new Item("盾牌");
			var fire:IMachining = new FireMachining();
			var ice:IMachining = new IceMachining();
			fire.packing(item);
			trace(item.name);
			ice.packing(item);
			trace(item.name);
		}
	}
}
package Interface
{
	public interface IMachining
	{
		function packing(item:Item):void;
	}
}
package
{
	public class Item
	{
		public var name:String;
		public function Item(name:String)
		{
			this.name = name;
		}
	}
}
package
{
	import Interface.IMachining;

	public class IceMachining implements IMachining
	{
		public function IceMachining()
		{
		}

		public function packing(item:Item):void
		{
			item.name = "冰霜的" + item.name;
		}
	}
}
package
{
	import Interface.IMachining;

	public class FireMachining implements IMachining
	{
		public function FireMachining()
		{
		}

		public function packing(item:Item):void
		{
			item.name = "火焰的" + item.name;
		}
	}
}

时间： 2024-11-05 22:04:31

设计模式是什么？的相关文章

Java设计模式——创建型模式之单例模式

一.概述 作为第一个出场的设计模式,有必要先介绍一下设计模式(引用自百度百科): 设计模式(Design Pattern)是一套被反复使用.多数人知晓的.经过分类的.代码设计经验的总结. 使用设计模式的目的:为了代码可重用性.让代码更容易被他人理解.保证代码可靠性. 设计模式使代码编写真正工程化:设计模式是软件工程的基石脉络,如同大厦的结构一样. 设计模式概念的介绍,参见:http://blog.jobbole.com/101076/ 其中涉及的设计原则的概念,参见随笔:http://www.c

10大APP界面框架设计模式详解

随着移动互联网的发展,移动app已经成为了每个互联网公司的标配了,那作为产品经理,我们如何设计出更加符合用户体验的app产品呢?今天和大家分享的就是10中最常见的app界面光甲设计模式,一起来看看吧. 1.标签导航 标签导航是十大界面框架设计里最常用的界面框架设计,也是被业界之内公认的一种普遍使用的页面框架设计.那么这种页面框架设计在作业方面对一个用户来说也是最常见的一种页面框架设计,比如说微博.微信.手机百度.支付宝.淘宝,这些我们所谓的超级APP都是运用的标签导航,无一例外.从这个角度也可以

[js高手之路]设计模式系列课程-组合模式+寄生组合继承实战新闻列表

所谓组合模式,就是把一堆结构分解出来,组成在一起,现实中很多这样的例子,如: 1.肯德基套餐就是一种组合模式, 比如鸡腿堡套餐,一般是是由一个鸡腿堡,一包薯条,一杯可乐等组成的 2.组装的台式机同理,由主板,电源,内存条,显卡, 机箱,显示器,外设等组成的 把一个成型的产品组成部件,分成一个个独立的部件,这种方式可以做出很多灵活的产品,这就是组合模式的优势 比如:家用台式机电脑,要求配置比较低, 这个时候只需要主板+电源+内存条+机箱+显示器+外设就可以了,不需要配置独立显卡 鸡腿堡+鸡翅+紫薯

Happy 设计模式之适配器模式（JAVA）

设计模式-适配器模式 适配器模式定义 适配器模式,将一个类的的接口转换成客户或者产品希望的接口形式,就是原本不兼容或者甚至不相干的接口不能一起工作的接口一起工作,完成需求或者客户的需求. 适配器模式的使用场景 1.当你使用一个已经存在的类,而他的接口不符合你的需求. 2.你想要创建一个复用的类,该类可以与其相关的类或者不可见的类协同工作. 适配器角色 Target:目标接口 TargetImpl:目标实现类 Adapter:适配器 Adaptee:被适配者 代码解析: package com.d

设计模式 2/23 工厂模式

工厂模式是最常用的设计模式之一,用好了,代码优雅,可维护性高,对系统设计会上一个台阶 为什么这么说,因为工厂模式可以牵扯出抽象工厂模式,也有大家都会聊到的简单工厂模式 我们要了解一点,23中设计模式中,不包含简单工厂模式,之所以大家会去聊这个,四个字,渐进明细 通过对简单工厂模式的了解,我们引入工厂这个词,不然一个写代码的,天天给他讲工厂,工厂,工厂,西厂,东厂,会晕 同时,通过逐步的深入,从简单工厂,到工厂模式,再到抽象工厂,渐进明细的过程,逐步深入的理解,比较优劣,择优而为我们所用. 试想我

Java设计模式学习笔记，一：单例模式

开始学习Java的设计模式,因为做了很多年C语言,所以语言基础的学习很快,但是面向过程向面向对象的编程思想的转变还是需要耗费很多的代码量的.所有希望通过设计模式的学习,能更深入的学习. 把学习过程中的笔记,记录下来,只记干货. 第一部分:单例模式的内容 单例模式:类只能有一个实例. 类的特点:1.私有构造器:2.内部构造实例对象:3.对外提供获取唯一实例的public方法. 常见的单例模式实现有五种形式: 1.饿汉式. 2.懒汉式. 3.双重检查锁式. 4.静态内部类式. 5.枚举式. 以下分别

设计模式之单列模式

设计模式之单列模式 1,何为单列模式? 即singleton 在某个类采用了单列模式之后  其只能有一个实列对象 ,并且这个实列对象只能有内部自己创建并提供给外部的调用. 2.实现单列模式的方法 分为 :饿汉式 ,懒汉式 下面为饿汉式实现代码: public calss Singleton1{ //将构造函数私有化 防止外部通过new来创建对象 private Singleton1(){ } //创建一个私有静态变量并直接初始化 类加载的时候直接创建对象 private static Singl

设计模式之原型模式（Prototype）

1.初识原型模式 大家都知道连锁机构是现在灰常流行的商业模式,比如咖啡之翼,那么假设咖啡之翼要在长春新建立一个分店,所经营的产品和以前在其他的城市已经存在的店经营的产品差不多,那么面向对象开发的角度怎么解决这个问题呢?难道要重新的实例化一个咖啡之翼的店??这显然不太好吧,咖啡之翼里面经营的产品(假设是属性吧)都需要重新写,这就是在做大量的重复工作啊,这显然是不符合OO开发思想的.遇到这样的情况,并不是重新建立一个类来解决这样的问题,而是通过设计模式中的"原型模式"来解决这种问题.是这种

对设计模式的总结之简单工厂与策略模式

前言 面向对象编程追求的本质-提高扩展性.可维护性.灵活性和复用性.合理利用面向对象6个原则,能够很好的达到要求.如何利用好就是至关重要的了,前人总结了23+个设计模式能够让初学者更容易学到其中的精髓,本文就说说我对本人对简单工厂模式.策略模式的见解. 简单工厂模式与策略模式 简单工厂模式 工作中,常常遇到需要做一个功能(鸭子),这个功能中含有可控个数的子操作功能(鸭子叫,鸭子跑,鸭子飞),而且子功能在不同的情况下处理方式又不相同(成年鸭子/小鸭子叫,成年鸭子/小鸭子跑,成年鸭子/小鸭子飞).我

设计模式——介绍与工厂模式（扁平管理模式VS职业经理人模式）

本文主要对设计模式进行大概解说.特别是对工厂模式进行简明的解析: 一.设计模式的分类 创建型模式,共五种:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式. 结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式. 行为型模式,共十一种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.訪问者模式.中介者模式.解释器模式. 事实上还有两类:并发型模式和线程池模式. 二.设计模式的六大原则 1.开闭原则(Op