Actionscript 3 关于ActionScript中的类

我有一个folderProjects，其中包含两个文件：FirstPro.fla、FirstClass.as 我的问题的目标是和两个不同的物体互动，这是我自己创造的，我只有一个类，它只有一个类，我的目标是互动，因为MovieClip second有nameletterPanel没有类，它是现场唯一的MovieClip

在FirstClass.as中，我有下一个代码：

package
{
    import flash.utils.Timer; 
    import flash.events.TimerEvent; 
    import flash.display.MovieClip;
    import flash.events.*;
    import flash.display.Stage;

    public class FirstClass extends MovieClip
    {
        public function FirstClass()
        {
            var NewMyTimer:Timer = new Timer(100);
            NewMyTimer.addEventListener(TimerEvent.TIMER, hm);
            NewMyTimer.start();

        }

        public function hm(TimerEvent):void
        {
            this.y += 5;

            if(this.hitTestObject(letterPanel))
            {
                trace("Coincidens");

            }

        }

    }

}

在FirstPro.fla文件中，我在场景中有两个MovieClip图像，其中一个有FirstObjectName，它与我创建的类有链接，它工作了，我的对象FirstObjectJ随着计时器下降，但我想与第二个对象MovieClip letterPanel交互-ifthis.hitTestObjectletterPanel{TraceCocIncidens；}

---

如果我在我的类中编写此代码，此输出错误字母面板不是未定义的，我可以如何处理一个类中这两个对象的交互，

您必须分配MovieClip，并且在设置var之前，您也不能启动计时器

package{
  import flash.utils.Timer; 
  import flash.events.TimerEvent; 
  import flash.display.MovieClip;
  import flash.events.*;
  import flash.display.Stage;
  public class FirstClass extends MovieClip{
    private var _letterPanel:MovieClip;
    public function FirstClass(){

    }
    public function startConter( ):void{
      var NewMyTimer:Timer=new Timer(100);
      NewMyTimer.addEventListener(TimerEvent.TIMER, hm);
      NewMyTimer.start();
    }
    public function hm(TimerEvent):void{
      this.y+=5;
      if(this.hitTestObject(this._letterPanel)){
        trace("Coincidens");
       }
    }
    public function set letterPanel( val:MovieClip ):void{
      this._letterPanel = val;
    }
  }
}


var firstClass:FirstClass = new FirstClass( );
firstClass.letterPanel = letterPanel;
firstClass.startCounter( );

---

我最初的回答不是困惑，因为你对项目的解释有点难以理解，而是你没有很好地理解OOP。这个问题之前有一个我认为是正确的答案。如果我没记错的话，你拒绝它仅仅是因为它没有利用类。OOP是关于了解如何以及何时实现OOP概念，如抽象、封装、继承、多态性等

就你而言，我认为你的问题的简单答案如下：

stage.addEventListener(Event.ENTER_FRAME, onEnterFrame);

function onEnterFrame(e:Event):void
{
    if(displayObject1.hitTestObject(displayObject2)
    trace("hit");

}// end function

但是，如果您觉得需要真正使用类，我已经创建了一个类似的flash应用程序来演示如何使用它。舞台上基本上有3个可拖动的红色、绿色和蓝色圆圈显示对象，当您拖动一个圆圈显示对象，它与另一个圆圈显示对象重叠/相交时，会生成一条轨迹来描述碰撞。只需将以下代码复制并粘贴到文档类中，即可运行应用程序：

package 
{
    import flash.display.Sprite;
    import flash.events.Event;

    public class Main extends Sprite 
    {
        public function Main():void 
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);

        }// end function

        private function init(e:Event = null):void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);

            var redCircle:Circle = new Circle(Color.RED, 50);
            redCircle.name = "redCircle";
            redCircle.x = 100;
            redCircle.y = 100;
            addChild(redCircle);

            var greenCircle:Circle = new Circle(Color.GREEN, 50);
            greenCircle.name = "greenCircle";
            greenCircle.x = 300;
            greenCircle.y = 100;
            addChild(greenCircle);

            var blueCircle:Circle = new Circle(Color.BLUE, 50);
            blueCircle.name = "blueCircle";
            blueCircle.x = 500;
            blueCircle.y = 100;
            addChild(blueCircle);

            var collision:Collision = new Collision(stage, redCircle, greenCircle, blueCircle);
            collision.addEventListener(CollisionEvent.COLLISION, onCollision);

        }// end function

        private function onCollision(e:CollisionEvent):void
        {
            var collision:Collision = Collision(e.target);
            collision.removeEventListener(CollisionEvent.COLLISION, onCollision);

            trace("There was a collision between " + e.displayObject1.name + " and " + e.displayObject2.name);

        }// end function

    }// end class

}// end package

internal class Color
{
    public static const RED:uint = 0xFF0000;
    public static const GREEN:uint = 0x00FF00;
    public static const BLUE:uint = 0x0000FF;

}// end class

import flash.display.Sprite;
import flash.display.Stage;
import flash.events.EventDispatcher;
import flash.events.Event;
import flash.display.DisplayObject;
import flash.events.Event;
import flash.events.MouseEvent;

internal class Circle extends Sprite
{
    public function Circle(color:uint, radius:Number)
    {
        graphics.beginFill(color);
        graphics.drawCircle(0,0,radius);
        graphics.endFill();

        addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);

    }// end function

    private function onMouseDown(e:MouseEvent):void
    {
        parent.setChildIndex(this, parent.numChildren - 1);
        startDrag();

        stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUp)

    }// end function

    private function onMouseUp(e:MouseEvent):void
    {
        stage.removeEventListener(MouseEvent.MOUSE_UP, onMouseUp);

        stopDrag();

    }// end function

}// end class

internal class Collision extends EventDispatcher
{
    private var _stage:Stage;
    private var _doVector:Vector.<DisplayObject>; 

    public function Collision(stage:Stage, ...displayObjects)
    {
        _stage = stage;
        _doVector = getDOVector(validateArgs(displayObjects, DisplayObject));

        init();

    }// end function

    private function init():void
    {   
        _stage.addEventListener(Event.ENTER_FRAME, onEnterFrame);

    }// end function

    private function onEnterFrame(e:Event):void
    {
        for(var i:uint = 0; i < _doVector.length; i++)
        {
            for(var j:uint = 0; j < _doVector.length; j++)
            {
                if (_doVector[i] != _doVector[j])
                {
                    if (_doVector[i].hitTestObject(_doVector[j]))
                    dispatchEvent(new CollisionEvent(CollisionEvent.COLLISION, _doVector[i], _doVector[j]));

                }// end if

            } // end for

        }// end for

    }// end function

    private function validateArgs(args:Array, type:Class):Array
    {
        for each(var arg:* in args)
        if(!(arg is type))
        throw new ArgumentError("Argument must be of type " + type);

        return args;

    }// end function

    private function getDOVector(array:Array):Vector.<DisplayObject>
    {
        var doVector:Vector.<DisplayObject> = new Vector.<DisplayObject>();

        for each(var displayObject:DisplayObject in array)
        doVector.push(displayObject);

        return doVector;

    }// end function

}// end class

internal class CollisionEvent extends Event
{
    public static const COLLISION:String = "collision";

    private var _displayObject1:DisplayObject;
    private var _displayObject2:DisplayObject;

    public function get displayObject1():DisplayObject { return _displayObject1 };
    public function get displayObject2():DisplayObject { return _displayObject2 };

    public function CollisionEvent(type:String, 
                                   displayObject1:DisplayObject,
                                   displayObject2:DisplayObject,
                                   bubbles:Boolean = false,
                                   cancelable:Boolean = false):void
    {
        _displayObject1 = displayObject1;
        _displayObject2 = displayObject2;

        super(type, bubbles, cancelable);

    }// end function

    override public function clone():Event
    {
        return new CollisionEvent(type, displayObject1, displayObject2, bubbles, cancelable);

    }// end function

}// end class  

---

1061:通过静态类型为FirstClass的引用调用可能未定义的方法startCounter。1067:将类型为Class的值隐式强制为不相关的类型flash。显示：MovieClip。您需要导入FirstClass