// ActionScript 2.0クラス定義ファイル: A.as
class A{
	var protoProp:String="protoProp";
	var instanceProp:String;
	function protoMeth():String{
		return "protoMeth";
	}
	function protoMeth2():String{  // [追加]
		return "protoMeth";
	}
}

// フレームアクション
var a:A = new A();
trace(a.protoMeth() == A.prototype.protoMeth()); //true
// 以下追加テスト
trace(a.protoMeth2() == A.prototype.protoMeth());  // true
trace(a.protoMeth2 == A.prototype.protoMeth);  // false
trace(a.protoMeth == A.prototype.protoMeth);  // true
trace(_root.play() == _root.stop());  // true

function A(){}
A.prototype.protoProp = "protoProp";
A.prototype.protoMeth = function(){
    return "protoMeth";
}

//(2004/2/13修正)
//エラーにして欲しいです…ビルトインクラスを上書きしてどんなメリットが?
//var Math:A = new A(); //エラーなし
　
//////////////////////////////////////////////////AS2.0によるクラス定義//
　
/* A.as
class A{
	var protoProp:String="protoProp";
	var instanceProp:String;
	function protoMeth(Void):String{
		return "protoMeth";
	}
}*/
　
/* B.as
class B extends A{}*/
　
//AS2.0のdynamicクラスでなくてもAS1.0の仕様でprototypeには動的にエレメントを追加できる
A.prototype.extraProp = "extraProp";
A.prototype.extraMeth = function(Void):String{return "extraMeth";};
　
var a:A = new A();
//dynamicクラスではないのでprototypeで動的に追加したエレメントは呼び出せない
trace(a.protoProp == A.prototype.protoProp); //true
trace(a.instanceProp == A.prototype.instanceProp); //true
trace(a.protoMeth == A.prototype.protoMeth); //true
trace(a.__proto__.extraProp == A.prototype.extraProp); //true
trace(a.__proto__.extraMeth == A.prototype.extraMeth); //true
//trace(a.extraProp); //エラー  a.extraPropとすることは禁止される(AS2.0のクラス定義に準ずる)
//trace(a.extraMeth()); //エラー  a.extraMethとすることは禁止される(AS2.0のクラス定義に準ずる)
　
var b:B = new B(); //class B extends A AS2.0によりBクラスはAクラスを継承
trace(b.__proto__.extraProp == A.prototype.extraProp); //true
trace(b.__proto__.extraMeth == A.prototype.extraMeth); //true
//trace(b.extraProp); //エラー  b.extraPropとすることは禁止される(AS2.0のクラス定義に準ずる)
//trace(b.extraMeth()); //エラー  b.extraMethとすることは禁止される(AS2.0のクラス定義に準ずる)
　
//trace(B.prototype.__proto__ == A.prototype); //true ですが、これはAS2.0での継承とは意味が違う
　
//////////////////////////////////////////////////AS1.0によるクラス定義//
function C(){ //class C AS1.0により定義(class A相当)
	this.instanceProp;
}
C.prototype.protoProp="protoProp";
C.prototype.protoMeth = function(){return "protoMeth";};
C.prototype.extraProp = "extraProp";
C.prototype.extraMeth = function(){return "extraMeth";};
　
function D(){} //class D AS1.0により定義('D.prototype = new C();'でclass B相当)
　
c = new C();
trace(c.protoProp == C.prototype.protoProp); //true
trace(c.instanceProp == C.prototype.instanceProp); //true
trace(c.protoMeth == C.prototype.protoMeth); //true
trace(c.extraProp == C.prototype.extraProp); //true
trace(c.extraMeth == C.prototype.extraMeth); //true
　
D.prototype = new C(); //class D extends C AS1.0によりDクラスはCクラスを継承
d = new D();
trace(d.extraProp == C.prototype.extraProp); //true
trace(d.extraMeth == C.prototype.extraMeth); //true
　
//trace(D.prototype.__proto__ == C.prototype); //true これはAS1.0での継承を意味する
　
//以上

//ProtoExample.as
dynamic class ProtoExample{
	
	//__proto__をシュミレートするObject _proto
	var _proto:Object;
	static var num:Number=0; //追加
	var idName:String; //追加
	
	function ProtoExample(proto:Object){
		_proto = proto;
		num++; //追加
		idName="obj" + num; //追加
	}
	
	//もしProtoExampleのインスタンスに無いプロパティが呼び出されたら呼ばれる
	function __resolve(prop:String){
		
		trace([idName+".__resolve called","Prop:"+prop]); //追加
		
		//引数に入ってきたものと同名のプロパティを_protoから探す
		var f = _proto[prop];
	
		//それがFunctionなら関数として返す。
		if( typeof f== "Function")
			return f.apply(this,arguments);
		
		return f;
	}
}

//example:
PROTOTYPE = new Object();
PROTOTYPE.prop = "prototypeProperty";
PROTOTYPE.datas = [1,2,3,4,5];
	
var obj1:ProtoExample = new ProtoExample(PROTOTYPE);
var obj2:ProtoExample = new ProtoExample(PROTOTYPE);
// [問題の処理部分]
obj1.datas[0] = "X"; //*datasプロパティの配列を参照して変更
// 問題はobj1の2回のみ
//obj1.__resolve called,Prop:datas
//obj1.__resolve called,Prop:datas
trace(obj1.datas); //X,2,3,4,5

// [問題の処理部分]
var temp = obj1.datas;  //obj1.__resolve called,Prop:datas
temp[0] = "X";
//obj1.__resolve called,Prop:datas
trace(obj1.datas); //X,2,3,4,5

//ProtoExample.as
dynamic class ProtoExample{
	
	//__proto__をシュミレートするObject _proto
	var _proto:Object;
	static var num:Number=0; //追加
	var idName:String; //追加
	
	function ProtoExample(proto:Object){
		_proto = proto;
		num++; //追加
		idName="obj" + num; //追加
	}
	
	//もしProtoExampleのインスタンスに無いプロパティが呼び出されたら呼ばれる
	function __resolve(prop:String){
		
		trace([idName+".__resolve called","Prop:"+prop]); //追加
		
		//引数に入ってきたものと同名のプロパティを_protoから探す
		var f = _proto[prop];
	
		//それがFunctionなら関数として返す。
		if( typeof f== "Function")
			return f.apply(this,arguments);
		
		return f;
	}
}

//example:
PROTOTYPE = new Object();
PROTOTYPE.prop = "prototypeProperty";
PROTOTYPE.datas = [1,2,3,4,5];
	
var obj1:ProtoExample = new ProtoExample(PROTOTYPE);
var obj2:ProtoExample = new ProtoExample(PROTOTYPE);
trace([obj1.idName,obj2.idName]); //obj1,obj2
	
//obj1.prop,obj2.propがないため__resolve2回呼ばれる
//obj2.__resolve called,Prop:prop
//obj1.__resolve called,Prop:prop
trace([obj1.prop,obj2.prop]); //prototypeProperty,prototypeProperty
	
//ex:obj1.prop = "instanceProperty";
obj1.prop = "instanceProperty"; //dynamicによりobj1.propプロパティ新規追加
	
//obj2.propがないため__resolve1回呼ばれる
//obj2.__resolve called,Prop:prop
trace([obj1.prop,obj2.prop]);//instanceProperty,prototypeProperty
	
//ex: obj1.__proto__.prop = "OOps...";
obj1._proto.prop = "OOps..."; //クラス内で定義されてるobj1._proto.propプロパティ書き換え
	
//obj2.propがないため__resolve1回呼ばれる
//obj2.__resolve called,Prop:prop
trace([obj1.prop,obj2.prop]); //instanceProperty,OOps...
	
//obj1.datas,obj2.datasがないため__resolve2回呼ばれる
//obj2.__resolve called,Prop:datas
//obj1.__resolve called,Prop:datas
trace([obj1.datas,obj2.datas]); //1,2,3,4,5 , 1,2,3,4,5
	
obj1.datas[0] = "X"; //dynamicによりobj1.datasプロパティ新規追加
//参照型のためPROTOTYPE.datasに設定した配列を変更することに…
////////////////////ここでなぜか__resolve3回呼ばれます////////////////////
//obj1.__resolve called,Prop:datas
//obj2.__resolve called,Prop:datas
//obj1.__resolve called,Prop:datas
trace([PROTOTYPE.datas,obj1.datas,obj2.datas]); //X,2,3,4,5 , X,2,3,4,5 , X,2,3,4,5
trace([obj1._proto.datas,obj2._proto.datas]); //X,2,3,4,5 , X,2,3,4,5

class Test{
    static var staticProp:Number;
    ..
}
../Test/prototype/protoProp 
../Test/prototype/instanceProp 
../Test/staticProp

↑のようにstaticプロパティはTestの直下にきます

class SuperTest{
    var superProp:Number;
}
../SuperTest/prototype/superProp

class Test extends SuperTest{
    ....
}
SuperTestを継承するTestのクラス定義の時にはSuperTest/prototypeフォルダーのショートカットが
../Test/prototype/直下に __proto__と言う名前でできます。

../Test/prototype/__proto__
../Test/prototype/protoProp
../Test/prototype/instanceProp
(等々）

インスタンス化すると
../this/__proto__/__proto__/superProp
../this/__proto__/protoProp
../this/__proto__/instanceProp
となります。