ActionScript3(AS3)类库学习之（一）——Object基本对象

Object class 是所有类的基类，所有未申明继承的class都被默认的继承自Object class，如number，string等基本类型都是继承自Object类。甚至prototype，Class，Function等类都是继承自Object类,当然这些类虽然继承自Object类，但是还是不能当做普通的类一样操作。

一.Object的创建
可以使用关键字new 来创建Object 实例，并且可以给他们动态的赋值。

var obj:Object = new Object();
obj.a = "foo";
obj["b"] = "bar";
trace(obj.a);
trace(obj.b);

 
同时Object 实例可以按照下面的方式创建。

var obj:Object = {a:"foo", b:"bar"}
trace(obj.a);
trace(obj.b);

 
当一个类被声明为dynamic时，它就能被动态赋值，否则不能动态赋值。

public class A
{
  public function A()
  {        
  }
}
var obj:A = new A();
obj.a = "foo"; //error
obj.b = "bar"; //error
public dynamic class A
{
  public function A()
  {        
  }
}
var obj:A = new A();
obj.a = "foo";//right
obj.b = "bar";//right
trace(obj.a);
trace(obj.b);

 
二.prototype的使用
一个类的prototype对象是该对象的一个特殊的对象，它提供了一个机制用来让该类的所有对象共享该值。在编译程序的时候，当一个属性不能被在一个类的实例上找到的时候，编译器就会从代理（也就是类的prototype对象）上寻找该属性。如果那个prototype不含有那个属性，那么编译器就会继续从更高级别的类的prototype对象来寻找该属性。
prototype和class的继承和访问有如下特性：
1.class自有的属性和方法在声明为static时只能被类使用，不能被对象使用，且不支持继承。
2.class自有的属性和方法在不声明为static时只能被对象使用，不能被类使用,支持继承，属性不能被重定义，方法如果要被重定义需要加上override。
3.prototype的属性和方法可以被类使用也可以被对象使用，且都支持继承。被对象使用时，类需要定义成dynamic的，否则无法通过对象使用。被类使用时需要以class.prototype.property的形式使用不能直接使用。

    public dynamic class A
    {
        public var x:String = "x in A";
        public static var staticx:String = "staticx in A";
        prototype.px = "px in A";
        prototype.py = "py only in A";
        public function A()
        {
        }
        public function toLocaleString():String {
            return "a locale string in A";
        }
        public static function staticFunc():String
        {
            return "a static function in A";
        }
        public function thefunc():String
        {
            return "a func in A";
        }
    }
    public dynamic class B extends A
    {
        var x:String = "x in B"; //cannot redefine
        public static var staticx:String = "staticx in B";
        prototype.px = "px in B";
        public function B()
        {        
        }
        public function toString():String {
            return "a string in B";
        }
        public static function staticFunc():String
        {
            return "a static function in B";
        }
        public override function thefunc():String
        {
            return "a func in B";
        }
    }
            var ma:A = new A();
            var mb:B = new B();
            
            trace(A.staticx);
            trace(B.staticx);
            trace(ma.staticx); //undefined
            trace(A.staticFunc());
            trace(B.staticFunc());
            trace(ma.staticFunc());  //error
            
            trace(A.x); //error
            trace(ma.x);
            trace(mb.x);
            trace(ma.thefunc());
            trace(mb.thefunc());
            
            trace(ma.px);
            trace(mb.px);
            trace(mb.py);
            trace(A.prototype.px);
            trace(B.prototype.px);
            trace(B.prototype.py);
            
            trace(ma.toLocaleString());
            trace(mb.toLocaleString());
            trace(ma.toString());
            trace(mb.toString());
            trace(A.prototype.toString());
            trace(B.prototype.toString());

 
三.Object的一些属性和方法说明
共有属性
constructor：Object
指向Object class或者Object实例的构造函数
prototype：Object [static]
指向Object Class 或者Function Object 的原型（prototype）

公共方法
Object()
创建一个Object实例，并且使该实例的constructor property指向其构造函数。
hasOwnProperty(name:String)：Boolean
判断是否有具有该名称的property，对于静态的属性和方法和prototype得到的属性或方法会返回false
isPrototypeOf(theClass:Object)：Boolean
判断一个对象是否在指定的对象的原型链中
propertyIsEnumerable(name:String):Boolean
判断一个指定的属性是否存在并是否可列举
toLocaleString():String
返回一个代表该对象的locale-specific conventions字符串
toString() ：String
返回一个代表该对象的字符串
valueOf()：Object
返回对象的原始值

四.Class类
Class继承自Object，是一个特殊的类，用Class类可以实现更灵活的代码，如下例：

    public dynamic class A
    {
        public function A()
        {
        }
        public function toString():String
        {
            return "A class"
        }
    }
    public dynamic class B
    {
        public function B()
        {
        }
        public function toString():String
        {
            return "B class"
        }
    }
        var cls:Object = { "A":A as Class, "B":B as Class };
        public function CreateClass(type:String)
        {
            var myclass:Class = cls[type];
            return new myclass();
        }
            var newobj = CreateClass("A");
            trace(newobj.toString());

 
五.Function类
Function类继承自Object，是一个特殊的类，他有call和apply两个方法，这两个方法的基本功能是一样的，区别就在apply中将函数所有参数以数组的形式传入，而call则是用逗号分隔开来传入，使用function可以实现更灵活的代码，如下例：

    public dynamic class A
    {
        var ininum:int = 0;
        public function A()
        {
        }
    }
            var arr:Array = new Array(1, 2, 3);
            var obj:Object = new Object();
            obj.sumup = function(num1:int,num2:int,num3:int):int
            {
                return this.ininum + num1 + num2 + num3;
            }
            var sum1:A = new A();
            var sum2:A = new A();
            sum2.ininum = 100;
            trace(obj.sumup.apply(sum1, arr));
            trace(obj.sumup.call(sum1, 1, 2, 3));
            trace(obj.sumup.apply(sum2, arr));

 
六.几种基本类
int,uint,number是继承自Object，用来显示数字的三种类：
它们主要实现了toExponential（转为指数形式），toFixed（指定宽度），toPrecision（指定精确度）这三个函数
String用来显示字符串
Boolean用来判断是非等
Date用来处理时间
Math用来做计算，这个类不能构建对象，所有的操作都是基于类而不是对象进行的。
这些内置类都是按照值传递的，且被声明为final型类，也就是不能再被继承了。

转载于:https://www.cnblogs.com/studynote/archive/2013/03/24/2979662.html