package 
{
	public class MenuItem
	{
		private var name:String;
		private var description:String;
		private var vegetarian:Boolean;
		private var price:uint;
 
		public function MenuItem( $name:String, $description:String, $vegetarian:Boolean, $price:uint )
		{
			this.name = $name;
			this.description = $description;
			this.vegetarian = $vegetarian;
			this.price = $price;
		}
 
		public function getName():String
		{
			return name;
		}
 
		public function getDescription():String
		{
			return description;
		}
 
		public function getPrice():uint
		{
			return price;
		}
 
		public function isVegetarian():Boolean
		{
			return vegetarian;
		}
	}
}

package 
{
	public class PancakeHouseMenu implements IMenu
	{
		private var menuItems:Array;
 
		public function PancakeHouseMenu () 
		{
			menuItems = new Array()
 
			addItem( "K&B 팬케이크 세트", "스크램블드 에그와 토스트가 곁들여진 팬케이크", true, 2990 )
			addItem( "레귤러 팬케이크 세트", "달걀 후라이와 소시지가 곁들여진 팬케이크", false, 2990 )
			addItem( "블루베리 팬케이크", "신선한 블루베리와 블루베리 시럽으로 만든 팬케이크", true, 3490 )
			addItem( "와플", "와플, 취향에 따라 블루베리나 딸기를 얹을 수 있습니다.", true, 3590 )
		}
 
		public function addItem( $name:String, $description:String, $vegetarian:Boolean, $price:uint ):void
		{
			var menuItem:MenuItem = new MenuItem( $name, $description, $vegetarian, $price )
			menuItems.push(menuItem);
		}
 
		/*
		 * 이터레이터 패턴 구현으로 사용하지 않게된 메서드
		public function getMenuItems():MenuItem
		{
			return menuItems;
		}
		*/
		public function createIterator():IIterator
		{
			return new PancakeHouseIterator( menuItems )
		}
 
		//기타 메뉴관련 메서드
	}
}

package 
{
	public class DinerMenu implements IMenu
	{
		private static const MAX_ITEM:uint = 6;
		private var numberOfItems:uint = 0;
		private var menuItems:Vector.<MenuItem>;
 
		public function DinerMenu () 
		{
			menuItems = new Vector.<MenuItem>( MAX_ITEM, true )
 
			addItem( "채식주의자용 BLT", "통밀 위에 (식물성)베이컨, 상추, 토마토를 얹은 메뉴", true, 2990 )
			addItem( "BLT", "통밀 위에 베이컨, 상추, 토마토를 얹은 메뉴", false, 2990 )
			addItem( "오늘의 스프", "감자 샐러드를 곁들인 오늘의 스프", false, 3290 )
			addItem( "핫도그", "사워크라우트, 갖은 양념, 양파, 치즈가 곁들여진 핫도그", false, 3050 )
		}
 
		public function addItem( $name:String, $description:String, $vegetarian:Boolean, $price:uint ):void
		{
			var menuItem:MenuItem = new MenuItem( $name, $description, $vegetarian, $price )
			if ( numberOfItems >= MAX_ITEM )
			{
				trace( "죄송합니다, 메뉴가 꽉 찼습니다. 더 이상 추가할 수 없습니다." )
			}
			else
			{
				menuItems[numberOfItems] = menuItem;
				numberOfItems++
			}
		}
 
		/*
		 * 이터레이터 패턴 구현으로 사용하지 않게된 메서드
		public function getMenuItems():MenuItem
		{
			return menuItems;
		}
		*/
		public function createIterator():IIterator
		{
			return new DinerMenuIterator( menuItems )
		}
 
		//기타 메뉴관련 메서드
	}
}

package 
{
	public interface IIterator
	{
		function hasNext():Boolean;
		function next():Object;
	}
}

package 
{
	public class PancakeHouseIterator implements IIterator
	{
		private var items:Array;
		private var position:int = 0;
 
		//생성자에서는 메뉴에서 넘어온 모든 메뉴를 한꺼번에 받음
		public function PancakeHouseIterator ( $items:Array )
		{
			this.items = $items;
		}
 
		//다음 메뉴 배열원소를 리턴
		public function next():Object
		{
			var memuItem:MenuItem = items[position];
			position++;
			return memuItem;
		}
 
		//다음 메뉴가 있는지 확인하고 Boolean을 리턴
		public function hasNext():Boolean
		{
			if ( position >= items.length )
			{
				return false;
			}
			else
			{
				return true;
			}
		}
	}
}

package 
{
	public class DinerMenuIterator implements IIterator
	{
		private var items:Vector.<MenuItem>;
		private var position:int = 0;
 
		public function DinerMenuIterator ( $items:Vector.<MenuItem> )
		{
			this.items = $items;
		}
 
		public function next():Object
		{
			var memuItem:MenuItem = items[position];
			position++;
			return memuItem;
		}
 
		public function hasNext():Boolean
		{
			//Vector 의 경우 원소가 없는 것은 null 이기 때문에 null 도 검사
			if ( position >= items.length || items[position] == null )
			{
				return false;
			}
			else
			{
				return true;
			}
		}
	}
}

package 
{
	public class Waitress
	{
		private var pancakeHouseMenu:IMenu;
		private var dinerMenu:IMenu;
 
		//웨이트리스는 생성자에서 양쪽 식당의 메뉴를 받아 변수에 저장
		public function Waitress( $pancakeHouseMenu:IMenu, $dinerMenu:IMenu ) 
		{
			this.pancakeHouseMenu = $pancakeHouseMenu;
			this.dinerMenu = $dinerMenu;
		}
 
		//이터레이터 객체를 준비
		public function printMenu():void
		{
			var pancakeIterator:IIterator = pancakeHouseMenu.createIterator();
			var dinerIterator:IIterator = dinerMenu.createIterator();
			trace( "\n메뉴n----\n아침메뉴" );
			printItMenu( pancakeIterator );
			trace( "\n메뉴n----\n점심메뉴" );
			printItMenu( dinerIterator );
		}
 
		//실제 개별 메뉴를 찍어줌
		private function printItMenu( $iterator:IIterator ):void
		{
			while ( $iterator.hasNext() )
			{
				var menuItem:MenuItem = MenuItem( $iterator.next() );
				trace( menuItem.getName(), ", ", menuItem.getPrice(), "--", menuItem.getDescription() );
			}
		}
	}
}

package 
{
	import flash.display.Sprite;
 
	public class Main extends Sprite 
	{
		public function Main():void 
		{
			var pancakeHouseMenu:PancakeHouseMenu = new PancakeHouseMenu();
			var dinerMenu:DinerMenu = new DinerMenu();
 
			var waitress:Waitress = new Waitress( pancakeHouseMenu, dinerMenu );
			waitress.printMenu();
		}
	}
}

package 
{
	public interface ICommand
	{
		function execute():void
	}
}

package 
{
	public class CeilingFanOffCommand implements ICommand
	{
		private var ceilingFan:CeilingFan;
 
		public function CeilingFanOffCommand( $ceilingFan:CeilingFan ) 
		{
			this.ceilingFan = $ceilingFan
		}
 
		public function execute():void
		{
			ceilingFan.off();
		}
	}
}

package 
{
	import flash.display.Sprite;
	import flash.events.*;
 
	public class CeilingFan extends Sprite
	{
		private var location:String = "";
		private var speed:int;
		public static const HIGH:int = 3;
		public static const MEDIUM:int = 2;
		public static const LOW:int = 1;
		public static const OFF:int = 0;
 
		public function CeilingFan( $location:String ):void
		{
			this.fan.cacheAsBitmap = true;
			this.location = $location;
			this.speed = OFF;
			this.addEventListener( Event.ENTER_FRAME, onEnterFrameHandler );
		}
 
		public function high():void
		{
			speed = HIGH;
			outputText();
		}
		public function medium():void
		{
			speed = MEDIUM;
			outputText();
		}
		public function low():void
		{
			speed = LOW;
			outputText();
		}
		public function off():void
		{
			speed = OFF;
			outputText();
		}
		public function getSpeed():int
		{
			return speed;
		}
		private function outputText():void
		{
			txtSpeed.text = location + " : Fan Speed - " + speed;
		}
		private function onEnterFrameHandler( e:Event ):void 
		{
			this.fan.rotation += speed;
		}
	}
}

package 
{
	import fl.controls.Button;
	import flash.display.Sprite;
	import flash.events.*;
	import flash.text.*;
 
	public class RemoteControlWithHistory extends Sprite 
	{
		private var arrCommands:Array = new Array();;
		private var commandHistory:Array = new Array();
		private var historyIndex:int;
		private var txtHistory:TextField = new TextField();
 
		public function RemoteControlWithHistory( $ceilingFan:CeilingFan, $numberOfbuttons:uint = 4 )
		{
			var noCommand:ICommand = new NoCommand();
			for ( var i:int = 0; i < $numberOfbuttons; i++ )
			{
				arrCommands[ i ] = noCommand;
			}
 
			var ceilingFanHigh:CeilingFanHighCommand = new CeilingFanHighCommand( $ceilingFan );
			var ceilingFanMedium:CeilingFanMediumCommand = new CeilingFanMediumCommand( $ceilingFan );
			var ceilingFanLow:CeilingFanLowCommand = new CeilingFanLowCommand( $ceilingFan );
			var ceilingFanOff:CeilingFanOffCommand = new CeilingFanOffCommand( $ceilingFan );
 
			setCommand( 0, ceilingFanOff );
			setCommand( 1, ceilingFanLow );
			setCommand( 2, ceilingFanMedium );
			setCommand( 3, ceilingFanHigh );
 
			init( $numberOfbuttons );
		}
 
		private function init( $numberOfbuttons:uint ):void
		{
			this.x = this.y = 10;
 
			for ( var i:uint = 0; i < $numberOfbuttons; i++ )
			{
				var button:Button = new Button();
				button.addEventListener( MouseEvent.CLICK, buttonWasPushed );
				button.label = i.toString();
				button.height = 30;
				button.y = i * ( button.height + 5 );
				addChild( button );
			}
 
			var undoButton:Button = new Button();
			var redoButton:Button = new Button();
			var historylistButton:Button = new Button()
			undoButton.y = 200;
			redoButton.y = 230;
			historylistButton.y = 260;
			undoButton.label = "undo";
			redoButton.label = "redo";
			historylistButton.label = "view history";
 
			undoButton.addEventListener( MouseEvent.CLICK, undoButtonWasPushed )
			redoButton.addEventListener( MouseEvent.CLICK, redoButtonWasPushed )
			historylistButton.addEventListener( MouseEvent.CLICK, historyView );
 
			addChild( undoButton );
			addChild( redoButton );
			addChild( historylistButton );
 
			txtHistory.width = 300;
			txtHistory.height = 300;
			txtHistory.x = historylistButton.width;
			txtHistory.y = historylistButton.y;
			addChild( txtHistory );
 
			//선풍기의 초기값은 정지상태
			this.buttonWasPushed( null );
		}
 
		public function setCommand( $slot:int, $command:ICommand ):void
		{
			arrCommands[ $slot ] = $command;
		}
 
		public function buttonWasPushed( $e:MouseEvent = null ):void
		{
			var slot:uint = ( $e == null ) ? 0 : uint( $e.target.label );
			arrCommands[ slot ].execute();
			stackProcess( arrCommands[ slot ] );
		}
 
		private function stackProcess( $command:ICommand ):void
		{
			//historyIndex가 undo 중일때 undo나 redo가 아닌 새로운 command가 들어올경우 redo 부분이 없어지도록 배열길이를 조정
			commandHistory.length = historyIndex;
			commandHistory.push( $command );
			historyIndex = commandHistory.length;
		}
 
		public function undoButtonWasPushed( $e:MouseEvent = null ):void
		{
			if ( historyIndex > 1 )
			{
				commandHistory[ ( --historyIndex - 1 ) ].execute();
			}
			else
			{
				trace( "No more Undo" )
			}
		}
 
		public function redoButtonWasPushed( $e:MouseEvent = null ):void
		{
			if ( historyIndex < commandHistory.length )
			{
				commandHistory[ historyIndex++ ].execute();
			}
			else
			{
				trace( "No more Redo" )
			}
		}
 
		public function getCommandList():String
		{
			var str:String = "\n------ Remote Control -------"
			for ( var i:int = 0; i < arrCommands.length; i++)
			{
				str += "\n[slot " + i + "] " + arrCommands[i] 
			}
			str += "\n[undo] " + commandHistory
			return str
		}
 
		private function historyView( e:MouseEvent ):void 
		{
			txtHistory.text = "******History list******"
			for each( var element:Object in commandHistory )
			{
				txtHistory.appendText( ( "\n" + element.toString() ) );
			}
		}
	}
}

package 
{
	import flash.display.Sprite;
 
	public class Main extends Sprite 
	{
		public function Main():void 
		{
			var ceilingFan:CeilingFan = new CeilingFan( "Living Room" )
			ceilingFan.x = 400;
			ceilingFan.y = 200;
			addChild( ceilingFan );
 
			var remoteControl:RemoteControlWithHistory = new RemoteControlWithHistory( ceilingFan, 4 );
			addChild( remoteControl );
 
		}
	}
}

package 
{
	public interface ICommand
	{
		function execute():void
	}
}

package 
{
	public class Stereo
	{
		private var location:String;
 
		public function Stereo( $location:String ) 
		{
			this.location = $location
		}
 
		public function on():void
		{
			trace( location , "스테레오 켬" )
		}
 
		public function off():void
		{
			trace( location , "스테레오 끔" )
		}
 
		public function setCD():void
		{
			trace( location , "스테레오에 CD 넣음" )
		}
 
		public function setDVD():void
		{
			trace( location , "스테레오에 DVD 넣음" )
		}
 
		public function setRadio():void
		{
			trace( location , "스테레오에 라디오 켬" )
		}
 
		public function setVolume( $volume:int ):void
		{
			trace( location , "스테레오 볼륨을", $volume, "으로 조정" )
		}
	}
}

package 
{
	public class StereoOnWithCDCommand implements ICommand
	{
		private var stereo:Stereo;
		public function StereoOnWithCDCommand( $stereo:Stereo ) 
		{
			this.stereo = $stereo;
		}
 
		public function execute():void
		{
			stereo.on();
			stereo.setCD();
			stereo.setVolume( 11 );
		}
	}
}

package 
{
	public class RemoteControl
	{
		private var onCommands:Array;
		private var offCommands:Array;
 
		public function RemoteControl()
		{
			onCommands = new Array();
			offCommands = new Array();
 
			var noCommand:ICommand = new NoCommand();
			for ( var i:int = 0; i < 7; i++ )
			{
				onCommands[ i ] = noCommand
				offCommands[ i ] = noCommand
			}
		}
 
		public function setCommand( $slot:int, $onCommand:ICommand, $offCommand:ICommand ):void
		{
			onCommands[ $slot ] = $onCommand;
			offCommands[ $slot ] = $offCommand;
		}
 
		public function onButtonWasPushed( $slot:int ):void
		{
			onCommands[ $slot ].execute();
		}
 
		public function offButtonWasPushed( $slot:int ):void
		{
			offCommands[ $slot ].execute();
		}
 
		public function toString():String
		{
			var str:String = "\n------ Remote Control -------"
			for ( var i:int = 0; i < onCommands.length; i++)
			{
				str += "\n[slot " + i + "] " + onCommands[i] + "  " + offCommands[i]
			}
			return str
		}
	}
}

package 
{
	import flash.display.Sprite;
 
	public class Main extends Sprite 
	{
		public function Main():void 
		{
			var remoteControl:RemoteControl = new RemoteControl();
 
			var livingRoomLight:Light = new Light( "거실" );
			var kitchenLight:Light = new Light( "주방" );
			var cellingFan:CeilingFan = new CeilingFan( "거실" )
			var garageDoor:GarageDoor = new GarageDoor( "" );
			var stereo:Stereo = new Stereo( "거실" )
 
			var livingRoomLightOn:LightOnCommand = new LightOnCommand( livingRoomLight );
			var livingRoomLightOff:LightOffCommand = new LightOffCommand( livingRoomLight );
 
			var kitchenLightOn:LightOnCommand = new LightOnCommand( kitchenLight );
			var kitchenLightOff:LightOffCommand = new LightOffCommand( kitchenLight );
 
			var ceilingFanOn:CeilingFanOnCommand = new CeilingFanOnCommand( cellingFan );
			var ceilingFanOff:CeilingFanOffCommand = new CeilingFanOffCommand( cellingFan );
 
			var garageDoorUp:GarageDoorUpCommand = new GarageDoorUpCommand( garageDoor );
			var garageDoorDown:GarageDoorDownCommand = new GarageDoorDownCommand( garageDoor );
 
			var stereoOnWithCD:StereoOnWithCDCommand = new StereoOnWithCDCommand( stereo );
			var stereoOff:StereoOffCommand = new StereoOffCommand( stereo );
 
			remoteControl.setCommand( 0, livingRoomLightOn, livingRoomLightOff );
			remoteControl.setCommand( 1, kitchenLightOn, kitchenLightOff );
			remoteControl.setCommand( 2, ceilingFanOn, ceilingFanOff );
			remoteControl.setCommand( 3, stereoOnWithCD, stereoOff );
 
			trace( remoteControl.toString() );
 
			remoteControl.onButtonWasPushed( 0 );
			remoteControl.offButtonWasPushed( 0 );
			remoteControl.onButtonWasPushed( 1 );
			remoteControl.offButtonWasPushed( 1 );
			remoteControl.onButtonWasPushed( 2 );
			remoteControl.offButtonWasPushed( 2 );
			remoteControl.onButtonWasPushed( 3 );
			remoteControl.offButtonWasPushed( 3 );
		}
	}
}

package 
{
	public interface ICommand
	{
		function execute():void
	}
}

package 
{
	public class Light
	{
		public function on():void 
		{
			trace( "불 켜짐" )
		}
		public function off():void 
		{
			trace( "불 꺼짐" )
		}
	}
}

package 
{
	public class LightOnCommand implements ICommand
	{
		private var light:Light;
 
		public function LightOnCommand( $light:Light )
		{
			this.light = $light;
		}
 
		public function execute():void
		{
			light.on();
		}
	}
}

package 
{
	public class SimpleRemoteControl
	{
		private var slot:ICommand;
 
		public function setCommand( $command:ICommand ):void
		{
			slot = $command
		}
 
		public function buttonWasPressed():void
		{
			slot.execute();
		}
	}
}

package 
{
	import flash.display.Sprite;
 
	public class Main extends Sprite 
	{
		public function Main():void 
		{
			var remote:SimpleRemoteControl = new SimpleRemoteControl();
			var light:Light = new Light();
			var garageDoor:GarageDoor = new GarageDoor();
			var lightOn:LightOnCommand = new LightOnCommand( light );
			var garageOpen:GarageDoorOpenCommand = new GarageDoorOpenCommand( garageDoor );
 
			remote.setCommand( lightOn );
			remote.buttonWasPressed(); //출력 : 불 켜짐
			remote.setCommand( garageOpen );
			remote.buttonWasPressed(); //출력 : 차고 문 열림
		}
	}
}

package
{
	public class ChocolateBoiler
	{
		private var empty:Boolean;
		private var boiled:Boolean;
		private static var uniqueInstance:ChocolateBoiler;
		private static var allowCreateSingleton:Boolean; 
 
		public function ChocolateBoiler()
		{
			if ( !allowCreateSingleton )
			{
				throw new Error( "Singleton 클래스 이므로 생성자를 직접 호출할 수 없습니다." )
			}
			else
			{
				empty = true;
				boiled = false;
			}
		}
 
		public static function getInstance():ChocolateBoiler
		{
			if ( uniqueInstance == null )
			{
				allowCreateSingleton = true;
				trace( "초콜렛 보일러 인스턴스 생성" )
				uniqueInstance = new ChocolateBoiler();
				allowCreateSingleton = false;
			}
			trace( "초콜렛 보일러 인스턴스 반환" )
			return uniqueInstance;
		}
 
		public function fill():void
		{
			if ( isEmpty() )
			{
				trace( " - 우유와 초콜렛을 보일러에 투입" )
				empty = false;
				boiled = false;
			}
		}
 
		public function drain():void
		{
			if ( !isEmpty() && isBoiled() )
			{
				trace( " - 끓인 재료를 다음 단계로 넘기기 위해 추출" )
				empty = true;
			}
		}
 
		public function boil():void
		{
			if ( !isEmpty() && !isBoiled() )
			{
				trace( " - 재료를 끓임" )
				boiled = true;
			}
		}
 
		public function isEmpty():Boolean
		{
			return empty;
		}
 
		public function isBoiled():Boolean
		{
			return boiled;
		}
	}
}

package
{
	import flash.display.Sprite;
	public class ChocolateController extends Sprite
	{
		public function ChocolateController()
		{
			var boiler:ChocolateBoiler = ChocolateBoiler.getInstance();
			boiler.fill();
			boiler.boil();
			boiler.drain();
 
			var boiler2:ChocolateBoiler = ChocolateBoiler.getInstance();
			boiler2.boil();
			//var boiler3:ChocolateBoiler = new ChocolateBoiler()
		}
	}
}

package
{
	public class Singleton
	{
		static private var _instance:Singleton;
 
		public function Singleton( singletonEnforcer:SingletonEnforcer ) { }
 
		public static function getInstance():Singleton
		{
			if ( Singleton._instance == null )
			{
				Singleton._instance = new Singleton( new SingletonEnforcer() );
			}
			return Singleton._instance;
		}
 
		public function doSometing():void
		{
			trace( "SOMETHING !" )
		}
 
	}
}
 
class SingletonEnforcer {}

package
{
	public class Singleton
	{
		static private var _instance:Singleton = new Singleton();
 
		public function Singleton()
		{
			if ( _instance )
			{
				throw new Error( "Singleton 클래스 이므로 생성자를 직접 호출할 수 없습니다." )
			}
		}
 
		public static function getInstance():Singleton
		{
			return _instance;
		}
 
		public function doSometing():void
		{
			trace( "SOMETHING !" )
		}
	}
}

package 
{
	public interface ISubject
	{
		function addObserver( $o:IObserver ):void
		function removeObserver( $o:IObserver ):void
		function notifyObserver():void
	}
}

package 
{
	import flash.events.Event;
	import flash.events.EventDispatcher;
 
	public class Subject implements ISubject 
	{
		private var dispatcher:EventDispatcher = new EventDispatcher();
		private var _arrObserver:Array = new Array();
		private var _infoObject:Object;
 
		public function Subject()
		{
 
		}
 
		//ISubject 를 구현 - 옵저버 등록
		public function addObserver( $o:IObserver ):void
		{
			dispatcher.addEventListener( ObserverEvent.NOTIFY, $o.update );
			addObject( $o );
		}
 
		//옵저버에 등록된 대상 객체를 배열에 저장
		private function addObject( $o:IObserver ):void
		{
			arrObserver.push( $o );
		}
 
		//ISubject 를 구현 - 옵저버 제거
		public function removeObserver( $o:IObserver ):void
		{
			dispatcher.removeEventListener( ObserverEvent.NOTIFY, $o.update );
			removeObject( $o );
		}
 
		//옵저버를 제거하면 배열에서 제거
		private function removeObject( $o:IObserver ):void
		{
			var index:int = arrObserver.indexOf( $o, 0 )
			arrObserver.splice( index, 1 )
		}
 
		//ISubject 를 구현 - 이벤트 발생 --> 정보 전달
		public function notifyObserver( ):void
		{
			dispatcher.dispatchEvent( new ObserverEvent( ObserverEvent.NOTIFY, this.infoObject ) )
		}
 
		//도큐먼트 클래스에서 호출할 메서드
		public function setClick( $x:int, $y:int ):void
		{
			makeInfoObject( $x, $y )
			notifyObserver();
		}
 
		//정보를 Object 로 만들어 변수에 저장
		private function makeInfoObject( $x:int, $y:int ):Object
		{
			return _infoObject = { infoX : $x, infoY : $y }
		}
 
		public function get infoObject():Object { return _infoObject; }
 
		public function get arrObserver():Array { return _arrObserver; }
	}
}

package 
{
	import flash.events.Event;
 
	public class ObserverEvent extends Event
	{
		static public const NOTIFY:String = "notify";
		private var _info:Object;
 
		public function ObserverEvent( $type:String, $info:Object, $bubble:Boolean = false, $cancelable:Boolean = false )
		{
			super( $type, $bubble, $cancelable );
			this._info = $info;
		}
 
		override public function clone():Event
		{
			return new CustomEvent( type, _info, bubbles, cancelable );
		}
 
		public function get info():Object
		{
			return _info;
		}
	}
}

package 
{
	import flash.events.Event;
	public interface IObserver
	{
		function update( $e: Event ):void
	}
}

package 
{
	import flash.display.Shape;
	import flash.display.Sprite
	import flash.events.Event;
	import flash.events.TimerEvent;
	import flash.text.TextField;
	import flash.text.TextFormat;
	import flash.utils.Timer;
	import gs.TweenMax
	import gs.easing.*;
 
	public class Item extends Sprite implements IObserver
	{
		public var txtId:TextField;
		private var _id:uint;
		private var _x:int;
		private var _y:int;
		private var stageWidth:uint;
		private var stageHeight:uint;
		private var timer:Timer = new Timer( 2000, 0 )
 
		private var isInfo:Boolean;
 
		public function Item ( $size:uint = 50 ) 
		{
			var circle:Shape = new Shape()
			circle.graphics.lineStyle( 0, 0, 0 )
			circle.graphics.beginFill( 0x000000, 1 )
			circle.graphics.drawCircle( 0, 0, $size )
			circle.graphics.endFill()
			addChild( circle )
 
			var hLine:Shape = new Shape();
			hLine.graphics.lineStyle( 1, 0xcc3300 );
			hLine.graphics.lineTo( 60, 0 );
			hLine.x = -30;
			addChild( hLine )
 
			var vLine:Shape = new Shape();
			vLine.graphics.lineStyle( 1, 0xcc3300 );
			vLine.graphics.lineTo( 0, 60 );
			vLine.y = -30;
			addChild( vLine )
 
			txtId = new TextField()
			var format:TextFormat = new TextFormat()
			format.font = "Verdana";
			format.color = 0xFFFFFF;
			format.size = 20;
			txtId.defaultTextFormat = format
			txtId.selectable = false;
			txtId.autoSize = "left";
			txtId.backgroundColor = 0x000000;
			addChild(txtId)
 
			this.addEventListener( Event.ADDED_TO_STAGE, initStage );
 
			timer.addEventListener( TimerEvent.TIMER, onTimeHandler )
			timer.start()
		}
 
		//옵저버가 되기위한 구현
		public function update( $e:Event ):void
		{
			var event:ObserverEvent = $e as ObserverEvent;
			this._x = event.info.infoX;
			this._y = event.info.infoY;
			// 정보로 들어온 값이 undefined 인지 아닌지 확인하여 isInfo에 Boolean 으로 저장
			this.isInfo = ( _x && _y ) ? true : false;
		}
 
		private function onTimeHandler( e:TimerEvent = null ):void 
		{
			if ( isInfo )
			{
				concentration()
			}
			else
			{
				deconcentration()
			}
		}
 
		private function initStage( e:Event ):void 
		{
			removeEventListener( Event.ADDED_TO_STAGE, initStage );
			stageWidth = stage.stageWidth;
			stageHeight = stage.stageHeight;
		}
 
		public function set id ( $value:uint ):void 
		{
			_id = $value;
			txtId.text = _id.toString()
		}
 
		public function get id():uint { return _id; }
 
		//Event 의 정보 값으로 모이기
		public function concentration():void
		{
			TweenMax.to( this, 1, { x:_x, y:_y , ease:Quart.easeInOut } );
		}
 
		//Event 정보 값이 undefined 일 경우 랜덤으로 움직이기
		public function deconcentration():void
		{
			TweenMax.to( this, 2, { x:Math.round(Math.random() * stageWidth), y:Math.round(Math.random() * stageHeight), 
					bezier:[ { x: Math.round(Math.random() * stageWidth), y: Math.round(Math.random() * stageHeight) } ], 
					ease:Quart.easeInOut } );
		}
	}
}

package 
{
	import flash.display.Sprite;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import gs.TweenLite;
 
	public class Main extends Sprite 
	{
		private var subject:Subject;
		private var isInfo:Boolean = true;
		private var clickedItem:Array = new Array();
		private var bg:Sprite;
 
		public function Main():void
		{
			subject = new Subject()
			createBG();
			createItem();
		}
 
		private function createBG():void
		{
			bg = new Sprite()
			bg.graphics.lineStyle(0, 0, 0)
			bg.graphics.beginFill(0x555555, 1)
			bg.graphics.drawRoundRect( 0, 0, stage.stageWidth, stage.stageHeight, 50, 50 )
			bg.graphics.endFill()
			addChild( bg )
			bg.addEventListener( MouseEvent.MOUSE_DOWN, bgClickHandler)
		}
 
		private function createItem():void
		{
			for ( var i:uint = 0; i < 10; i++ )
			{
				var item:Item = new Item()
				item.id = i;
				item.buttonMode = true;
				item.addEventListener( MouseEvent.MOUSE_DOWN, itemClickHandler );
				item.addEventListener( MouseEvent.MOUSE_OVER, itemRollOverHandler );
				addChild( item );
 
				subject.addObserver( item );
			}
		}
 
		//옵저버 객체에 마우스 이벤트가 일어나면 handleItem() 으로 객체를 보냄
		private function itemClickHandler( e:MouseEvent ):void 
		{
			var target:Item = e.currentTarget as Item
			handleItem( target )
		}
 
		//주제에 있는 옵저버 리스트(배열)을 조회하여 리스트에 있으면 옵저버 등록을 해지 (없으면 옵저버 등록)
		private function handleItem( $item:Item ):void
		{
			var isFind:Boolean;
			for each( var item:Object in subject.arrObserver )
			{
				if ( item === $item )
				{
					subject.removeObserver( $item );
					$item.alpha = 0.5;
					isFind = true;
					break
				}
			}
			if ( !isFind )
			{
				subject.addObserver( $item )
				$item.alpha = 1;
			}
		}
 
		//롤오버된 객체는 가장 위로 올림
		private function itemRollOverHandler( e:MouseEvent ):void 
		{
			setChildIndex( e.currentTarget as Sprite, numChildren - 1 );
		}
 
		//배경을 클릭한 지점을 주제 메서드로 보냄
		private function bgClickHandler( e:MouseEvent ):void
		{
			isInfo = !isInfo;
 
			if ( isInfo )
			{
				subject.setClick( undefined, undefined );
				TweenLite.to( bg, 1, { tint:0x555555 } );
			}
			else
			{
				subject.setClick( mouseX, mouseY );
				TweenLite.to( bg, 1, { tint:0x8D2545 } );
			}
		}
	}
}

package
{
	public interface IPizzaIngredientFactory
	{
		function createDough():IDough;
		function createSauce():ISauce;
		function createCheese():ICheese;
		function createVeggies():Array;
		function createPepperoni():IPepperoni;
		function createClam():IClams;
	}
}

package
{
	public class NYPizzaIngredientFactory implements IPizzaIngredientFactory
	{
		public function createDough():IDough
		{
			return new ThinCrustDough();
		}
 
		public function createSauce():ISauce
		{
			return new MarinaraSauce();
		}
 
		public function createCheese():ICheese
		{
			return new ReggianoCheese();
		}
 
		public function createVeggies():Array
		{
			var veggies:Array = [ new Garlic(), new Onion(), new Mushroom(), new RedPepper() ]
			return veggies;
		}
 
		public function createPepperoni():IPepperoni
		{
			return new SlicedPepperoni();
		}
 
		public function createClam():IClams
		{
			return new FreshClams();
		}
	}
}

package
{
	public class NYPizzaStore extends PizzaStore
	{
		public override function createPizza( $item:String ):Pizza
		{
			var pizza:Pizza = null;
			//구상객체로 생성해서 상위형으로 캐스팅합니다. 이게 바로 핵심이죠.
			var ingredientFactory:IPizzaIngredientFactory = new NYPizzaIngredientFactory();
 
			if ( $item == "cheese" )
			{
				//이 클래스에서 사용하는 재료공장은 위에서 이미 정해졌죠.
				pizza = new CheesePizza( ingredientFactory )
				//대신 이름은 여기서 달아줘야 합니다.
				pizza.setName( "뉴욕스타일 치즈피자" )
			}
			else if ( $item == "pepperoni" )
			{
				pizza = new PepperoniPizza( ingredientFactory )
				pizza.setName( "뉴욕스타일 페퍼로니피자" )
			}
			else if ( $item == "clam" )
			{
				pizza = new ClamPizza( ingredientFactory )
				pizza.setName( "뉴욕스타일 조개피자" )
			}
			else if ( $item == "veggie" )
			{
				pizza = new VeggiePizza( ingredientFactory )
				pizza.setName( "뉴욕스타일 야채피자" )
			}
 
			return pizza;
		}
	}
}

package
{
	public class CheesePizza extends Pizza
	{
		private var ingredientFactory:IPizzaIngredientFactory;
 
		public function CheesePizza( $ingredientFactory:IPizzaIngredientFactory )
		{
			this.ingredientFactory = $ingredientFactory;
		}
 
		public override function prepare():void
		{
			trace( "주문접수 : " , name );
			dough = ingredientFactory.createDough();
			sauce = ingredientFactory.createSauce();
			cheese = ingredientFactory.createCheese();
			trace( toString() )
		}
	}
}

package
{
	public class Pizza
	{
		protected var name:String;
		protected var dough:IDough;
		protected var sauce:ISauce;
		protected var veggies:Array = new Array();
		protected var cheese:ICheese;
		protected var pepperoni:IPepperoni;
		protected var clam:IClams;
 
		public function getName():String
		{
			return name;
		}
 
		public function setName( $name:String ):void
		{
			this.name = $name
		}
 
		public function prepare():void
		{
			throw new Error( "prepare() 추상 메서드" )
		}
 
		public function bake():void
		{
			trace( "피자를 굽습니다 :", name )
		}
 
		public function cut():void
		{
			trace( "피자를 자릅니다 :", name )
		}
 
		public function box():void
		{
			trace( "피자를 포장합니다 :", name )
		}
 
		public function toString():String
		{
			var display:String = "";
			display += "-----" + name + "를 준비합니다 -----";
 
			if ( dough != null )
				display += "\n도우 반죽중... : " + dough.toString();
 
			if ( sauce != null )
				display += "\n소스 추가중... : " + sauce.toString();
 
			if ( cheese != null )
				display += "\n치즈 추가중... : " + cheese.toString();
 
			if ( veggies.length > 0 )
			{
				var t:String = "";
				for (var i:uint = 0; i < veggies.length; i++ )
				{
					t += veggies[ i ].toString() + ", ";
				}
				display += ("\n야채 추가중... : " + t);
			}
			if ( clam != null )
				display += "\n조개 추가중... : " + clam.toString();
 
			if ( pepperoni != null )
				display += "\n페퍼로니 추가중... : " + pepperoni.toString();
 
			return display
		}
	}
}

package
{
	import flash.display.Sprite;
 
	public class Main extends Sprite
	{
		public function Main():void
		{
			//팩토리 메서드 패턴의 호스트코드 와 동일하게 사용
			var nyStore:PizzaStore = new NYPizzaStore();
			var chicagoStore:PizzaStore = new ChicagoPizzaStore()
 
			var pizza:Pizza = nyStore.orderPizza( "cheese" )
			trace( "주문한 피자 나왔습니다 :", pizza.getName() )
 
			pizza = chicagoStore.orderPizza( "veggie" )
			trace( "주문한 피자 나왔습니다 :", pizza.getName() )
		}
	}
}

package
{
	public class PizzaStore
	{
		public function createPizza( $item:String ):Pizza
		{
			throw new Error( "createPizza( $item:String ) 추상메서드" )
		}
 
		public function orderPizza( $type:String ):Pizza
		{
			//Simple Factory에서는 factory.createPizza( $type ) 로 만들었지만 여기서는 추상메서드를 통해 피자를 만듬
			var pizza:Pizza = createPizza( $type );
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
 
			return pizza;
		}
	}
}

package
{
	public class ChicagoPizzaStore extends PizzaStore
	{
		public override function createPizza( $item:String ):Pizza
		{
			var pizza:Pizza = null;
 
			if ( $item == "cheese" )
			{
				pizza = new ChicagoStyleCheesePizza()
			}
			else if ( $item == "pepperoni" )
			{
				pizza = new ChicagoStylePepperoniPizza()
			}
			else if ( $item == "clam" )
			{
				pizza = new ChicagoStyleClamPizza()
			}
			else if ( $item == "veggie" )
			{
				pizza = new ChicagoStyleVeggiePizza()
			}
 
			return pizza;
		}
	}
}

package
{
	public class ChicagoStylePepperoniPizza extends Pizza
	{
		public function ChicagoStylePepperoniPizza()
		{
			name = "시카고 스타일 페퍼로니피자";
			dough = "익스트라 크러스트 도우";
			sauce = "플럼 토마토 소스";
			toppings.push( "으깬 모짜렐라 치즈" )
			toppings.push( "검은 올리브" )
			toppings.push( "시금치" )
			toppings.push( "가지" )
			toppings.push( "슬라이스 페퍼로니" )
		}
 
		public override function cut():void
		{
			trace( "피자를 네모난 모양으로 자름" )
		}
	}
}

package
{
	public class Pizza
	{
		protected var name:String;
		protected var dough:String;
		protected var sauce:String;
		protected var toppings:Array = new Array()
 
		public function getName():String
		{
			return name;
		}
 
		public function prepare():void
		{
			var display:String = "n-----";
			display += name + "를 준비합니다 -----";
			display += "n도우 반죽중... : " + dough;
			display += "n소스 추가중... : " + sauce;
			var t:String = "";
			for (var i:uint = 0; i < toppings.length; i++ )
			{
				t += toppings[ i ].toString() + ", ";
			}
			display += ("n토핑 추가중... : " + t);
 
			trace( "n", display )
		}
 
		public function bake():void
		{
			trace( "피자를 굽습니다 :", name )
		}
 
		public function cut():void
		{
			trace( "피자를 자릅니다 :", name )
		}
 
		public function box():void
		{
			trace( "피자를 포장합니다 :", name )
		}
	}
}

package
{
	import flash.display.Sprite;
 
	public class Main extends Sprite
	{
		public function Main():void
		{
			/*
			 * Simple Factory 에서 피자를 만드는 방식
			 * var factory:SimplePizzaFactory = new SimplePizzaFactory()
			 * var store:PizzaStore = new PizzaStore( factory )
			 * var pizza:Pizza = store.orderPizza( "cheese" )
			*/
			var nyStore:PizzaStore = new NYPizzaStore();
			var chicagoStore:PizzaStore = new ChicagoPizzaStore()
 
			var pizza:Pizza = nyStore.orderPizza( "cheese" )
			trace( "주문한 피자 나왔습니다 :", pizza.getName() )
 
			pizza = chicagoStore.orderPizza( "veggie" )
			trace( "주문한 피자 나왔습니다 :", pizza.getName() )
		}
	}
}

package
{
	import flash.display.Sprite;
 
	public class Main extends Sprite
	{
		public function Main():void
		{
			var factory:SimplePizzaFactory = new SimplePizzaFactory()
			var store:PizzaStore = new PizzaStore( factory )
 
			var pizza:Pizza = store.orderPizza( "cheese" )
			trace( "주문한 피자 나왔습니다 :", pizza.getName() )
 
			pizza = store.orderPizza( "veggie" )
			trace( "주문한 피자 나왔습니다 :", pizza.getName() )
		}
	}
}

package
{
	public class SimplePizzaFactory
	{
		public function createPizza( $type:String ):Pizza
		{
			var pizza:Pizza = null;
 
			if ( $type == "cheese" )
			{
				pizza = new CheesePizza()
			}
			else if ( $type == "pepperoni" )
			{
				pizza = new PepperoniPizza()
			}
			else if ( $type == "clam" )
			{
				pizza = new ClamPizza()
			}
			else if ( $type == "veggie" )
			{
				pizza = new VeggiePizza()
			}
 
			return pizza;
		}
	}
}

package
{
	public class PizzaStore
	{
		private var factory:SimplePizzaFactory;
 
		public function PizzaStore( $factory:SimplePizzaFactory )
		{
			this.factory = $factory;
		}
 
		public function orderPizza( $type:String ):Pizza
		{
			var pizza:Pizza;
 
			pizza = factory.createPizza( $type );
 
			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
 
			return pizza;
		}
	}
}

package
{
	public class Pizza
	{
		protected var name:String;
		protected var dough:String;
		protected var sauce:String;
		protected var toppings:Array = new Array()
 
		public function getName():String
		{
			return name;
		}
 
		public function prepare():void
		{
			var display:String = "n-----";
			display += name + "를 준비합니다 -----";
			display += "n도우 반죽중...";
			display += "n소스 추가중...";
			var t:String = "";
			for (var i:uint = 0; i < toppings.length; i++ )
			{
				t += toppings[ i ].toString() + ", ";
			}
			display += ("n토핑 추가중... : " + t);
 
			trace( "n", display )
		}
 
		public function bake():void
		{
			trace( "피자를 굽습니다 :", name )
		}
 
		public function cut():void
		{
			trace( "피자를 자릅니다 :", name )
		}
 
		public function box():void
		{
			trace( "피자를 포장합니다 :", name )
		}
	}
}

package
{
	public class PepperoniPizza extends Pizza
	{
		public function PepperoniPizza()
		{
			name = "페퍼로니 피자";
			dough = "크러스트";
			sauce = "마리나라 소스";
			toppings.push( "슬라이스 페퍼로니" )
			toppings.push( "슬라이스 양파" )
			toppings.push( "으깬 파마산 치즈" )
		}
	}
}

package
{
	public class Beverage
	{
		protected var description:String;
 
		public function getDescription():String
		{
			return description;
		}
 
		public function cost():uint
		{
			throw new Error( "cost() 추상메서드 입니다." )
		}
	}
}

package
{
	public class Espresso extends Beverage
	{
		public function Espresso ()
		{
			description = "에스프레소"
		}
 
		public override function cost():uint
		{
			return 1990;
		}
	}
}

package
{
	public class CondimentDecorator extends Beverage
	{
		public override function getDescription():String
		{
			throw new Error( "getDescription() 추상메서드 입니다." )
		}
	}
}

package
{
	public class Mocha extends CondimentDecorator
	{
		private var beverage:Beverage;
 
		public function Mocha ( $beverage:Beverage )
		{
			this.beverage = $beverage;
		}
 
		public override function getDescription():String
		{
			return beverage.getDescription() + ", 모카";
		}
 
		public override function cost():uint
		{
			return 200 + beverage.cost();
		}
	}
}

package
{
	import flash.display.Sprite;
 
	public class Main extends Sprite
	{
		public function Main():void
		{
			var beverage:Beverage = new Espresso();
			trace( beverage.getDescription(), beverage.cost(), "원" )
			//출력 : 에스프레소 1990 원
 
			var beverage2:Beverage = new DarkRoast();
			beverage2 = new Mocha( beverage2 )
			beverage2 = new Mocha( beverage2 )
			beverage2 = new Whip( beverage2 )
			trace( beverage2.getDescription(), beverage2.cost(), "원" )
			//출력 : 다크로스트, 모카, 모카, 휘핑 크림 1490 원
 
			var beverage3:Beverage = new HouseBlend();
			beverage3 = new Soy( beverage3 );
			beverage3 = new Mocha( beverage3 );
			beverage3 = new Whip( beverage3 );
			trace( beverage3.getDescription(), beverage3.cost(), "원" )
			//출력 : 하우스 블렌드 커피, 두유, 모카, 휘핑 크림 1340 원
		}
	}
}

package
{
	public class CurrentConditionsDisplay implements IObserver, IDisplayElement
	{
		private var temperature:Number;
		private var humidity:Number;
		//주제를 저장하는 인스턴스변수 삭제
		//private var weatherData:ISubject;
 
		//생성자 메서드에 있던 $weatherData:ISubject 주제를 받는 인자 삭제
		public function CurrentConditionsDisplay ()
		{
			//생성자에서 옵저버역할에 대해서는 할일 없음. 모두 삭제
			//this.weatherData = $weatherData;
			//weatherData.registerObserver( this )
		}
 
		public function update( $temperature:Number, $humidity:Number, $pressure:Number ):void
		{
			this.temperature = $temperature;
			this.humidity = $humidity;
			display();
		}
 
		public function display():void
		{
			trace( "현재 온도 :", temperature, "도 / 습도 :", humidity )
		}
	}
}

package
{
	import flash.display.Sprite;
 
	public class Main extends Sprite
	{
		public function Main()
		{
			//주제 객체를 생성
			var weatherData:WeatherData = new WeatherData();
 
			//디스플레이를(옵저버) 객체를 생성
			var currentDisplay1:CurrentConditionsDisplay = new CurrentConditionsDisplay();
			var currentDisplay2:CurrentConditionsDisplay = new CurrentConditionsDisplay();
			var currentDisplay3:CurrentConditionsDisplay = new CurrentConditionsDisplay();
 
			//이렇게 주제가 옵저버를 등록하게 하면 옵저버는 주제를 몰라도 되겠죠.
			weatherData.registerObserver( currentDisplay1 );
			weatherData.registerObserver( currentDisplay2 );
			weatherData.registerObserver( currentDisplay3 );
 
			weatherData.setMeasurement( 20, 65, 30.4 ); // 1,2,3 의 디스플레이가 출력
				//출력 : 현재 온도 : 20 도 / 습도 : 65
				//출력 : 현재 온도 : 20 도 / 습도 : 65
				//출력 : 현재 온도 : 20 도 / 습도 : 65
			weatherData.removeObserver( currentDisplay1 ); // 1번을 빼면
			weatherData.setMeasurement( 28, 90, 29.2 ); // 2,3 의 디스플레이가 출력
				//출력 : 현재 온도 : 28 도 / 습도 : 90
				//출력 : 현재 온도 : 28 도 / 습도 : 90
		}
	}
}

package
{
	public interface IObserver
	{
		function update( temp:Number, humidity:Number, pressure:Number ):void
	}
}

package
{
	public interface IDisplayElement
	{
		function display():void
	}
}

package
{
	public class CurrentConditionsDisplay implements IObserver, IDisplayElement
	{
		private var temperature:Number;
		private var humidity:Number;
		private var weatherData:ISubject;
 
		public function CurrentConditionsDisplay ( $weatherData:ISubject )
		{
			this.weatherData = $weatherData;
			weatherData.registerObserver( this )
		}
 
		public function update( $temperature:Number, $humidity:Number, $pressure:Number ):void
		{
			this.temperature = $temperature;
			this.humidity = $humidity;
			display();
		}
 
		public function display():void
		{
			trace( "현재 온도 :", temperature, "도 / 습도 :", humidity )
		}
	}
}

package
{
	public interface ISubject
	{
		function registerObserver( o:IObserver ):void;
		function removeObserver( o:IObserver ):void;
		function notifyObservers():void;
	}
}

package
{
	public class WeatherData implements ISubject
	{
		//옵저버들을 배열로 저장할 인스턴스선언과 세 가지 측정값을 저장하는 변수선언
		private var observers:Array;
		private var temperature:Number;
		private var humidity:Number;
		private var pressure:Number;
 
		public function WeatherData()
		{
			observers = new Array()
		}
 
		//옵저버를 등록, ISubject 인터페이스를 구현함.
		public function registerObserver( o:IObserver ):void
		{
			observers.push( o )
		}
 
		//등록된 옵저버를 등록을 해제, ISubject 인터페이스를 구현함.
		public function removeObserver( o:IObserver ):void
		{
			var i:uint = observers.indexOf( o )
			if ( i >= 0 )
			{
				observers.splice( i, 1 )
			}
		}
 
		//각 옵저버들에게 info를 전달, ISubject 인터페이스를 구현함.
		public function notifyObservers():void
		{
			for ( var i:uint = 0; i < observers.length; i++ )
			{
				var observer:IObserver = observers[ i ];
				observer.update( temperature, humidity, pressure );
			}
		}
 
		//측정값(info)이 변경되었음을 경우 notifyObservers()를 호출
		//그러나 이 메서드는 현재 변경에 대한 코드가 없는 상태입니다. 메서드를 전달만 하고 있네요.
		public function measurementsChanged():void
		{
			notifyObservers();
		}
 
		//호스트코드에서 info를 주제에게 던질때 사용하는 메서드
		public function setMeasurement( $temperature:Number, $humidity:Number, $pressure:Number ):void
		{
			this.temperature = $temperature;
			this.humidity = $humidity;
			this.pressure = $pressure;
			measurementsChanged();
		}
	}
}

package
{
	import flash.display.Sprite;
	import flash.utils.describeType;
 
	public class Main extends Sprite
	{
		public function Main()
		{
			//WeatherData 객체를 만들어 각각의 옵저버 구상 객체에 넣어주었습니다.
			var weatherData:WeatherData = new WeatherData();
			var currentDisplay1:CurrentConditionsDisplay = new CurrentConditionsDisplay( weatherData );
			var currentDisplay2:CurrentConditionsDisplay = new CurrentConditionsDisplay( weatherData );
			var currentDisplay3:CurrentConditionsDisplay = new CurrentConditionsDisplay( weatherData );
 
			weatherData.setMeasurement( 20, 65, 30.4 );
				//출력 : 현재 온도 : 20 도 / 습도 : 65
				//출력 : 현재 온도 : 20 도 / 습도 : 65
				//출력 : 현재 온도 : 20 도 / 습도 : 65
 
			weatherData.removeObserver( currentDisplay1 ); //이렇게 1번 디스플레이를 옵저버 리스트에서 빼면
			weatherData.setMeasurement( 22, 70, 29.2 ); //1번 디스플레이를 뺀 2, 3번만 디스플레이 됩니다.
				//출력 : 현재 온도 : 22 도 / 습도 : 70
				//출력 : 현재 온도 : 22 도 / 습도 : 70
 
			weatherData.registerObserver( currentDisplay1 ); //이렇게 다시 넣어줄 수도 있겠죠.
			weatherData.setMeasurement( 28, 90, 29.2 ); // 2, 3, 1 번 모두 디스플레이 됩니다.
				//출력 : 현재 온도 : 28 도 / 습도 : 90
				//출력 : 현재 온도 : 28 도 / 습도 : 90
				//출력 : 현재 온도 : 28 도 / 습도 : 90
		}
	}
}

var currentDisplay1:CurrentConditionsDisplay = new CurrentConditionsDisplay( weatherData );

package
{
	public interface IArmor
	{
		function wearBonus():int;
	}
}

package
{
	public class Plate implements IArmor
	{
		public function Plate ()
		{
			trace( "판금갑옷을 착용하였습니다." )
		}
 
		public function wearBonus():int
		{
			trace( "현재 hp에 + 50" )
			return 50;
		}
	}
}

package
{
	public class Character
	{
		protected var weapon:IWeapon;
		protected var armor:IArmor;
		protected var _hp:int = 0;
		protected var _name:String;
		protected var _characterClass:String;
 
		public function Character ()
		{
			trace( "-----새로운 캐릭터를 생성합니다.-----" )
		}
 
		//무기를 장비함
		public function equipWeapon( $weapon:IWeapon ):void
		{
			weapon = $weapon;
		}
 
		//무기를 사용함
		public function weaponAction():void
		{
			weapon.useWeapon()
		}
 
		//갑옷을 입음
		public function equipArmor( $armor:IArmor ):void
		{
			armor = $armor;
 
			//해당 갑옷의 보너스 hp를 리턴받아 캐릭터의 hp에 더함
			_hp += armor.wearBonus();
 
			//방어력, 이동속도 등 다른 착용효과 구현 가능
		}
 
		//현재 장비하고 있는 무기를 리턴
		public function getObjectWeapon():IWeapon
		{
			return weapon
		}
 
		//캐릭터 이름, 직업, hp 현황을 리턴
		public function getStat():String
		{
			return _name + "(" + _characterClass + ") 현재 hp : " + _hp
		}
 
		public function get hp():int { return _hp; }
 
		public function get name():String { return _name; }
 
		public function get characterClass():String { return _characterClass; }
	}
}

package
{
	public class Knight extends Character
	{
		public function Knight ( $name:String )
		{
			_hp = 100;
			_name = $name;
			_characterClass = "기사"
			trace( name , " (이)라는 이름을 가진 ", characterClass ," 캐릭터를 생성하였습니다." )
			weapon = new Fist();
			armor = new Naked();
		}
	}
}

package
{
	import flash.display.Sprite;
 
	public class Main extends Sprite
	{
		public function Main():void
		{
			var player1:Character = new Knight( "세계의끝" );
							//출력 : -----새로운 캐릭터를 생성합니다.-----
							//출력 : 세계의끝  (이)라는 이름을 가진  기사  캐릭터를 생성하였습니다.
							//출력 : 맨주먹입니다. (무기가 없습니다)
							//출력 : 아무것도 착용하지 않았습니다.
			trace( player1.getStat() );		//출력 : 세계의끝(기사) 현재 hp : 100
			player1.weaponAction();		//출력 : 주먹을 휘두릅니다.
			player1.equipWeapon( new Sword() );	//출력 : Sword 를 장비하였습니다.
			player1.weaponAction();		//출력 : Sword 를 휘두릅니다
			player1.equipArmor( new Plate() );	//출력 : 판금갑옷을 착용하였습니다.
							//출력 : 현재 hp에 + 50
			trace( player1.getStat() );		//출력 : 세계의끝(기사) 현재 hp : 150
			trace( player1.getObjectWeapon() );	//출력 : [object Sword]
 
			var player2:Character = new Wizard( "댄스댄스댄스" );
							//출력 : -----새로운 캐릭터를 생성합니다.-----
							//출력 : 댄스댄스댄스  (이)라는 이름을 가진  마법사  캐릭터를 생성하였습니다.
							//출력 : 맨주먹입니다. (무기가 없습니다)
							//출력 : 아무것도 착용하지 않았습니다.
			trace( player2.getStat() );		//출력 : 댄스댄스댄스(마법사) 현재 hp : 80
			player2.weaponAction();		//출력 : 주먹을 휘두릅니다.
			player2.equipWeapon( new Staff() );	//출력 : Staff 를 장비하였습니다.
			player2.weaponAction();		//출력 : Staff 에서 마법을 발사합니다.
			player2.equipArmor( new Leather() );	//출력 : 가죽갑옷을 착용하였습니다.
							//출력 : 현재 hp에 + 30
			trace( player2.getStat() );		//출력 : 댄스댄스댄스(마법사) 현재 hp : 110
			trace( player2.getObjectWeapon() );	//출력 : [object Staff]
		}
	}
}

function wearBonus():int {
	var bonus:int;
	if ( armor == "Plate" ) {
		bonus = 50;
	} else if ( armor == "Leather" ) {
		bonus = 30;
	} else {
		bonus = 0;
	}
	return bonus;
}

package
{
	public interface IFly
	{
		function fly():void;
	}
}

package
{
	public class FlyWithWings implements IFly
	{
		public function fly():void
		{
			trace( "날고 있어요!!" )
		}
	}
}

package
{
	public class FlyNoWay implements IFly
	{
		public function fly():void
		{
			trace( "저는 못 날아요" )
		}
	}
}

package
{
	public class FlyRocketPowered implements IFly
	{
		public function fly():void
		{
			trace( "로켓 추진으로 날아갑니다." )
		}
	}
}

package
{
	public class Duck
	{
		//서브클래스에서 사용할 수 있도록 protected 로 변수선언
		protected var quackBehavior:IQuack;
		protected var flyBehavior:IFly;
 
		public function Duck() {}
 
		//오리의 모양새를 표현하는 메서드. 서브클래스에서 override 하지 않으면 컴파일 에러를 던지도록 함
		public function display():void
		{
			throw new Error( "추상 메서드입니다 override 하세요" )
		}
 
		public function performQuack():void
		{
			quackBehavior.quack();
		}
 
		public function performFly():void
		{
			flyBehavior.fly();
		}
 
		//서브클래스에서도 항상 똑같을 것으로 예상되는 메서드는 Duck 클래스에서 구현해 버립니다.
		public function swim():void
		{
			trace( "모든 오리는 물에 뜹니다. 가짜 오리도 뜨죠." )
		}
 
		//아래의 두개의 메서드는 인터페이스로 빼낸 두가지의 행동을 동적으로 바꾸기 위한 setter 메서드들
		public function setIFly( $fly:IFly ):void
		{
			flyBehavior = $fly;
		}
 
		public function setIQuack( $quack:IQuack ):void
		{
			quackBehavior = $quack;
		}
	}
}

package
{
	public class MallardDuck extends Duck
	{
		public function MallardDuck()
		{
			//quackBehavior와 flyBehavior는 Duck에서 상속받은 인스턴스변수
			//인스턴스변수에 구상클래스의 인스턴스(구체적인 행동)를 생성하여 집어넣음
			quackBehavior = new Quack();
			flyBehavior = new FlyWithWings();
		}
 
		//Duck 클래스의 추상 메서드를 override
		public override function display():void
		{
			trace( "n저는 물오리 입니다." )
		}
	}
}

package
{
	public class ModelDuck extends Duck
	{
		public function ModelDuck()
		{
			quackBehavior = new MuteQuack();
			flyBehavior = new FlyNoWay();
		}
 
		public override function display():void
		{
			trace( "n저는 모형오리 입니다." )
		}
	}
}

package
{
	import flash.display.Sprite;
 
	public class Main extends Sprite
	{
		public function Main()
		{
			var mallard:Duck = new MallardDuck();
			mallard.display();		//출력: 저는 물오리 입니다.
			mallard.performQuack();	//출력: 꽥!
			mallard.performFly();	//출력: 날고 있어요!!
 
			var model:Duck = new ModelDuck();
			model.display()		//출력: 저는 모형오리 입니다.
			model.performQuack();	//출력: << 조용~ >>
			model.performFly();	//출력: 저는 못 날아요
 
			//실행중에 오리의 행동을 바꾸고 싶으면 원하는 행동에 해당하는 Duck의 setter 메소드를 호출합니다.
			model.setIFly( new FlyRocketPowered() );
			model.performFly();	//출력: 로켓 추진으로 날아갑니다.
		}
	}
}

package
{
	public interface IDuck
	{
		function quack ():void;
		function fly ():void;
	}
}

package
{
	public class MallardDuck implements IDuck
	{
		public function quack():void
		{
			trace( "꽥!" )
		}
		public function fly():void
		{
			trace( "날고 있어요~" )
		}
	}
}

package
{
	public interface ITurkey
	{
		function gobble():void;
		function fly():void;
	}
}

package
{
	public class WildTurkey implements ITurkey
	{
		public function gobble():void
		{
			trace( "골골~" )
		}
 
		public function fly():void
		{
			trace( "조금밖에 못날아요" )
		}
	}
}

package
{
	public class TurkeyAdapter implements IDuck
	{
		private var turkey:ITurkey;
 
		public function TurkeyAdapter ( $turkey:ITurkey )
		{
			this.turkey = $turkey
		}
 
		public function quack():void
		{
			turkey.gobble();
		}
 
		public function fly():void
		{
			for ( var i:int = 0; i < 5; i++ )
			{
				//칠면조가 어댑터로 실행된 것을 구분하기 위해 오리흉내(5번 짧게 날기) 를 냅니다.
				turkey.fly();
			}
		}
	}
}

package
{
	import flash.display.Sprite;
 
	public class Main extends Sprite
	{
		public function Main():void
		{
			var duck:MallardDuck = new MallardDuck();
			var turkey:WildTurkey = new WildTurkey();
			var turkeyAdapter:IDuck = new TurkeyAdapter( turkey );
 
			trace( "n칠면조가 말함" );
			turkey.gobble();
			turkey.fly();
 
			trace( "n오리가 말함" );
			testDuck( duck );
 
			trace( "n칠면조 어댑터가 말함" );
			testDuck( turkeyAdapter );
		}
 
		private function testDuck( $duck:IDuck ):void
		{
			$duck.quack();
			$duck.fly();
		}
	}
}