as3的一些测试

 

as3用了这么久，还没有仔细的看看细节，所以做了这么几个测试

/**/ /**
* as3类测试文件1
* @author 湘西悍匪
* @version 0.1
*/

package test ... {

    public class Test ...{
        private static var a:String;
        /**//**
         * 以下的程序块在as3之中，被看作一个匿名的static函数
         * 和java的块相同的是，as3里的块语句执行的顺序是和java一样的，先于构造函数执行
         * 和java的块不同的是,java的块不是被看作static的
         * failed code:
         * private var a:String;
         * {
         *         a = "hello";
         *         trace(a);
         * }
         * throw:Access of undefined property a.
         * 以上代码会抛出错误，因为成员变量a不是static的，所以在这个块中将无法访问
         */
        ...{
            a = "hello";
            trace(a);
        }
        public function Test()...{
            trace("in construct:"+a);
        }
    }
    
}

 

 

/**/ /**
* as3类测试文件2
* @author 湘西悍匪
* @version 0.1
*/

package test  ... {
    /**//**
     * 在as3中，private ,portected关键字只能用于类成员的定义，不能在package里使用这两个关键字
     * package里只能有1个显示定义(public ,internal都算显式定义)
     * failed code:
     * package{
     *     public class Test2{
     *     }
     *     class A{
     *     }
     * }
     * throw:An ActionScript file can not have more than one externally visible definition: Test2,A
     * 以上代码抛出一个异常，ActionScript文件里只能有1个显式定义
     * 
     * 在as3中，如果没有使用public关键字来标注一个class为公共的
     * 则这个class默认为internal的
     * failed code:
     * package{
     *     class Test2{
     *         public function Test2(){
     *             trace("ok");
     *         }
     *     }
     * }
     * thorw:Type was not found or was not a compile-time constant: Test2.
     * 以上代码会抛出一个异常，该类型在编译时未能被找到，也就是说，没有用public
     * 来标注这个class，这个class是internal的，internal指的是仅仅能在内部被访问
     */
     public class Test2 ...{
        public function put():void ...{
            trace(new A().value);
            trace(new B().value);
            trace("A.getValueFromB:"+new A().getValueFromB());
            trace(n);
        }
    }
}



/**/ /**
 *同样的，internal 方法和变量都遵循这个原则
 * 若果要任何内部成员可访问这些internal的属性和方法则这些属性和方法必须要放在包外，并且不再任何内类之中
 * 这样任何内部的类，都可以访问到这些internal的方法和变量。
 * 如果是在类的内部使用了internal关键字，则这个属性或方法，仅在这个类的内部可被访问.且不能被其他的internal class 访问
 */
internal  function  t(): void ... {
    trace("_________");
}
internal  var  n:Number  =   5 ;

/**/ /**
 * as3中一个package里只能定义个class,其他的class定义要放在package以外
 * public关键字限定的class只能放在package内，也就是说，需要给外部可使用的class放在package里
 * 而其他辅助的internal class，则放在package外，给外部访问的class需要用public关键字来标记
 * failed code:
 * package{
 *      class Test{
 *     }
 * }
 * public class A{
 * }
 * throw: The public attribute can only be used inside a package.
 * 以上代码抛出一个异常，public 关键字 只能在package里使用
 */
internal class A  ... {
    public var value:String ="a";
    /**//**
     * 这里可以看到，internal class在内部环境里是可以访问的到的
     * class A可以访问到class B
     * 如果是在外部(例如在fla里的帧上写代码，试图创建一个B的实例)，则会抛出错误
     */
    public function getValueFromB():String...{
        t();
        return new B().value;
    }
}
internal class B  ... {
    public var value:String = "b";
}

 

/**/ /**
* as3类测试文件5
* @author 湘西悍匪
* @version 0.1
*/

package test ... {
    /**//**
     * 根据as3里，actionscript文件package里只能有1个显示定义的原则。
     * 如象flash.utils.trace这样的包方法，需要单独编写一个as文件
     * 因为要被外部使用，所以方法的限定符号为public
     * 文件名要和function名字存成一样
     */
    public function myTrace(v:*):void...{
        trace(v);
    }
}

 

/**/ /**
* as3类测试文件4
* @author 湘西悍匪
* @version 0.1
*/

package test ... {
    /**//**
     * 在as3中，public class的编译顺序早于interval class
     * 通过以下代码可以测试到:
     * package{
     *     public class A{
     *         {
     *             trace("A was initialize");
     *         }
     *     }
     * }
     * internal class B{
     *         {
     *             trace("B was initialize");
     *         }
     *    }
     * 以上代码运行结果为:
     * A was initialize
     * B was initialize
     * 
     * 所以，不能将一个public class 的基类设置成一个internal class
     * failed code:
     * package{
     *     public class A extends B{
     *     }
     * }
     * internal class B{}
     * throw:Forward reference to base class B.
     * 以上代码抛出一个异常，因为A比B的编译顺序要早，在A被加载开始初始化的时候，B还没有加载
     */
    public class  Test4 ...{
        public function Test4()...{
            new B().traceAll();
        }
    }
    
}
internal class A  ... {
    private var a:String;
    public var b:String;
    protected var c:String;
    internal var d:String;
    public function A()...{
        trace("im running!");
        a = "a";
        b = "b";
        c = "c";
        d = "d";
    }
    private function f1():void...{
        trace("f1");
    }
    public function f2():void...{
        trace("f2");
    }
    protected function f3():void...{
        trace("f3");
    }
    internal function f4():void...{
        trace("f4");
    }
}
internal class B extends A ... {
    public function traceAll():void...{
            /**//**
             * private限定符表示严格的私有只能在当前类可以访问，而子类不能访问
             * public限定符表示完全公开，当前类，子类，外部都可以访问
             * protected限定符表示友好的，当前类，子类，可访问，但外部不能访问
             * internal限定符表示内部友好，当前类，子类，可访问，外部不能访问
             */
            //trace(this.a);
            trace(this.b);
            trace(this.c);
            trace(this.d);
            
            /**//**
             * 对于和父类重名的方法,as3规定，必须使用override关键字标明重载
             * 这和java有点不一样，因为as3中没有多态。对于同方法名，不同参数和不同返回值的方法，as3会认为是定义重复
             * private 标记的方法不会从父类继承下来，所以这里的f1不需要重载
             * public,protected,internal这些关键字定义的方法，如果在子类里有重名，是必须要重载的
             * as3里的重载和java是不一样的，必须严格的按照父类的方法定义进行重载
             * java里允许子类对父类方法重载而且可以改变访问限制，如public 的可以在子类里变成private的
             * java的规则是从宽松的访问方式到严格的可以，反之则不行，例如将private的变成public，这将抛出异常
             * as3里父类的方法限定符号是什么，子类也必须使用这个限定符号，并且参数，返回值也必须是一致的
             * 从外观上来看，父类方法和子类方法的区别在于子类多出了一个override关键字
             * 方法被重载以后，可以通过super关键字访问到父类的原始方法，如：super.f2();
             * 在被重载的方法里这个super关键字对位置没有要求，不必放在第1行，可以根据需求来改变
             */
            f1();
            f2();
            f3();
            f4();
        }
    
        private function f1():void...{
            trace("b.f1");
        }
        public override function f2():void...{
            super.f2();
            trace("b.f2");
        }
        protected override function f3():void...{
            trace("b.f3");
        }
        internal override function f4():void...{
            trace("b.f4");
        }
}

 

/**/ /**
* as3类测试文件3
* @author 湘西悍匪
* @version 0.1
*/

package test ... {
    
    ///
     // 在as3中，只有public 关键字限定的类，方法，属性才能被外部访问
     // 其他如private ,portected,internal等关键字限定的东西，都不可以被外部访问
     //    private ,portected,internal在类的内部都是可以访问的，没有限制
     //
    public class Test3 ...{
        private var a:String;
        public var b:String;
        protected var c:String;
        internal var d:String;
        public function Test3()...{
            a = "a";
            b = "b";
            c = "c";
            d = "d";
        }
        public function traceAll():void...{
            trace(a);
            trace(b);
            trace(c);
            trace(d);
        }
    }
    
}

 

以上仅仅自己测试得出的结论，如有错误，请告之我，谢谢