Actionscript 3 AS3：优化对象内存大小

我有一门课是我写的，它看起来比应该的要大。它没有扩展任何内容，并且几乎没有什么进展——或者我是这么想的——但是每一个都占用了不到100k100字节（感谢back2dos）。我想我并没有很好地理解是什么真正影响了一个对象在AS3中占用了多少内存

如果有人能给我指出一些关于这个主题的可能有用的阅读资料，或者解释一些关于如何思考这个问题的见解，那就太棒了

我想在内存中保存很多这样的对象——我想我可以一直保存到现在，但是在这样的大小下，我将不得不创建它们或使用某种对象池技术

谢谢你的帮助

编辑：虽然我已经整理好了，但是为了完整起见，我保留了我在这里发布的代码。该类已从原始版本进行了大量修改。引用其他文件的值已被设置为静态，以允许代码为其他人运行（理论上，呵呵…）

虽然我的情况已经解决了，但我会给出一个关于课程和记忆的参考答案

在这种情况下，类有15个变量。我只使用一个字符串和一组整数、数字和布尔值，并在全局可用的XML数据中引用更多相同的内容。它还为构造函数导入点，尽管没有存储点。在测试中，即使没有全局XML引用或Point类，每个引用也大约为84k。除了构造函数之外，还有7个变量的getter和几个方法。所有这些都少于20行（我有一个非常稀疏的编码风格）

提到的类仅供参考，但请随意概括：

package
{
    public class AObject
    {
        private var _counter:int;
        private var _frames:int;
        private var _speed:int;

        private var _currentState:String;
        private var _currentFrame:int;

        private var _offset:int;
        private var _endFrame:int;

        private var _type:int;
        private var _object:int;
        private var _state:int;

        private var _x:Number;
        private var _y:Number;

        private var _w:int;
        private var _h:int;

        private var _update:Boolean;

        public function AObject( targetX : int,  targetY : int,  state : int,  object : int,  type : int )
        {       

            _x = targetX;
            _y = targetY;

            _type = type;
            _object = object;
            _state = state;
            _counter = 0;
            _w = 32;
            _h = 32
            _update = true;
            setState( state );
        }

        public function setState( state:int ) : void
        {
            _currentState = "bob";
            var frameCounter : int = 0;
            var stateCounter : int = state - 1;
            while ( state > 0 )
            {
                frameCounter += 4;
                --stateCounter; 
            }
            _offset = frameCounter;
            _currentFrame = _offset;
            _speed = 10;
            _frames = 4;
            _endFrame = _offset + _frames - 1;
        }

        public function get state() : int
        {
            return _state;
        }

        public function animate() : Boolean
        {
            if ( count() )
            {
                if( _currentFrame < _endFrame )
                {
                    ++_currentFrame;
                }
                else
                {
                    _currentFrame = _offset;    
                }
                _speed = 10;
                return true;
            }
            else
            {
                return false;
            }
        }

        private var adder: Number = 0;

        private function count():Boolean
        {
            _counter++;
            if ( _counter == _speed )
            {
                _counter = 0;
                return true;
            }
            else
            {
                return false;
            }
        }

        public function get x():int
        {
            return _x;
        }

        public function get y():int
        {
            return _y;
        }

        public function get type():int
        {
            return _type;
        }

        public function get object():int
        {
            return _object;
        }

        public function get currentFrame():int
        {
            return _currentFrame;
        }

        public function get w():int
        {
            return _w;
        }

        public function get h():int
        {
            return _h;
        } 
    }
}

包
{
公共类对象
{
专用变量计数器：int；
私有变量框架：int；
私有变量速度：int；
私有变量_currentState:字符串；
私有变量currentFrame:int；
私有var_偏移量：int；
私有变量_endFrame:int；
私有变量类型：int；
私有var_对象：int；
私有变量状态：int；
私有变量x：数字；
私有变量：数字；
私有变量w:int；
私有变量：int；
私有变量更新：布尔值；
公共函数AOObject（targetX:int，targetY:int，state:int，object:int，type:int）
{       
_x=targetX；
_y=目标；
_类型=类型；
_对象=对象；
_状态=状态；
_计数器=0；
_w=32；
_h=32
_更新=真；
设置状态（状态）；
}
公共函数设置状态（状态：int）：无效
{
_currentState=“bob”；
var frameCounter:int=0；
var stateconter:int=state-1；
而（状态>0）
{
帧计数器+=4；
--状态计数器；
}
_偏移量=帧计数器；
_当前帧=_偏移量；
_速度=10；
_帧=4；
_结束帧=_偏移量+_帧-1；
}
公共函数get state（）：int
{
返回状态；
}
公共函数animate（）：布尔值
{
if（count（））
{
如果（当前帧<结束帧）
{
++_当前帧；
}
其他的
{
_当前帧=_偏移量；
}
_速度=10；
返回true；
}
其他的
{
返回false；
}
}
专用var加法器：数字=0；
私有函数计数（）：布尔值
{
_计数器++；
如果（\u计数器==\u速度）
{
_计数器=0；
返回true；
}
其他的
{
返回false；
}
}
公共函数get x（）：int
{
返回x；
}
公共函数get y（）：int
{
返回y；
}
公共函数get type（）：int
{
返回型；
}
公共函数get object（）：int
{
返回_对象；
}
公共函数get currentFrame（）：int
{
返回当前帧；
}
公共函数get w（）：int
{
返回w；
}
公共函数get h（）：int
{
返回h；
} 
}
}

我很惊讶，这完全可以编译。。。当我试图用FlexSDK编译它时，它与内置类对象（任何类的基类）产生了巨大的冲突，使我的跟踪输出溢出

除此之外，如果为大于0的状态传递值，则这是一个无限循环

while ( state > 0 )
{
        frameCounter += 4;
        --stateCounter; 
}

但是这些物体这么大，看起来真的很奇怪。。。重命名并注意不要通过状态的0后，我运行了一个测试：

package {
    import flash.display.Sprite;
    import flash.sampler.getSize;
    import flash.system.System;
    public class Main extends Sprite {
        public function Main():void {
            const count:int = 100000;
            var start:uint = System.totalMemory;
            var a:Array = [];
            for (var i:int = 0; i < count; i++) {
                a.push(new MyObject(1, 2, 0, 4, 5));
            }
            var mem:uint = System.totalMemory - start - getSize(a);
            trace("total of "+mem+" B for "+count+" objects, aprox. avg. size per object: "+(mem/count));
        }       
    }   
}

所以这很好。。。我认为实际的大小应该是4（对于bool）+4*11（对于int）+4（对于字符串的引用）+8*3（对于三个浮点（对于

加法器

在

计数

的某个地方）对于空类+8（对于traits对象的引用+其他东西），总共给您88个字节…这是您得到的，如果您

getSize

对象…请注意，

getSize

只会给您对象本身的大小（此处计算），忽略对象引用的字符串或其他对象的大小

所以，是的，除了这个名字你肯定应该改变，问题一定是在其他地方

格里茨

如果您真的想，请后退2步

total of 10982744 B for 100000 objects, aprox. avg. size per object: 109.82744

width    height
0xFFFF + 0xFFFF

offset   endframe
0xFFFF + 0xFFFF

writing:
size = (width & 0x0000FFFF) << 16 | (height & 0x0000FFFF);

reading:
get width():uint { return (size & 0xFFFF0000) >> 16 };