在AS3 / Flash CS5中全局导入类

Question

I have a project in ActionScript 3, Flash Professional CS5.5, and AIR 3.

I have several custom classes that I need to access. Currently, I am successfully accessing via the traditional method:

import trailcrest.core.core;
var Core:core = new core();

However, I came to a realization in my code...this creates a COPY of the class, and doesn't give access to the original. This, of course is a problem - I need one symbol's scripts to modify a variable in the class, and another symbol's scripts access that changed variable. Obviously, right now, that is not occurring.

How do I do what I am describing? Should I somehow create a "public var" for the class (though I need instructions on how to do that...I can't use "public var" within stages or symbols)? Is there some way to directly access the class?

Help! And thanks in advance.

Answer 1

It is generally considered bad practice to use global variables. It usually leads to code that lacks flexibility and easily breaks when ,for instance , you introduce some changes or make modifications.

import trailcrest.core.core;
var Core:core = new core();

This is fine!

If an Object needs to change the value of a property in Core, you simply need to inform Core of the change of value by dispatching an Event.

 var object:MovieClip = new MovieClip();
 object.dispatchEvent ( property );

In that case, it would seem to make sense for Core to be your Document Class, in which case it would be aware of all the Objects in your app, whether as chidren, grand children etc...

If it's not your Document Class, then you could do...

 //In the Document Class
 var Core:core = new Core();
 var object:MovieClip = new MovieClip();

 // CoreEvent being a Custom Event
 object.addEventListener( CoreEvent.CHANGE , changeListener );
 addChild( object );

 //in another part of the Document Class
 //after a value has changed
 object.dispatchEvent ( property );

 //a method of the Document Class
 private function changeListener( event:CoreEvent ):void
 {
      var propNewValue:Object = event.property;
      //If you're using a singe instane of Core in the Document
      //Class, any other symbol can now access the new value.
      core.property = propNewValue;
 }

If objects are created in other parts of your application , you could always pass an instance of Core as a parameter.

  //In the Document Class
  var newobject:MovieClip = new CustomClass( core );

Edit

If you find this answer confusing, you should probably read about OOP's basic principles as well as Event Dispatching in AS3. Something of interest may be the Signals library , a nice alternative to Event Dispatching.

The general idea is to avoid to have your Objects tied up to a Singleton, or any type of Global variables. An Object , in theory, should only know about itself and you would use Events for Objects to communicate between themselves.

Answer 2

This is nicely accomplished by using Singleton design pattern . Here is sample AS3 implementation:

package   {

public class SomeClass {

    /** Singleton instance */
    private static var instance : SomeClass;

    /** This instance variable will be accesible globaly by calling it SomeClass.getInstance().somePublicVar */
    public var somePublicVar    : * ;

    /**
     * Get singleton instance of class
     * @return  singleton instance  SomeClass
     */
    public static function getInstance () : SomeClass {
        return SomeClass.instance ? SomeClass.instance : ( SomeClass.instance = new SomeClass() );
    }

}

}

Answer 3

The best method is to create something called a "singleton." A singleton is, quite simply, a static class without all the pesky cons of a static class. It makes a single instance (or single copy) available globally, which will then act exactly like a regular instance (because it is).

A singleton is possible through the use of static variables and functions. A static variable/function is a part of the class , not an instance. As such, there can only be one of each variable (there's only one class) and they are all globally accessible. A good example of static functions and properties is the built-in Math class. You get the value of Pi like this:

Math.PI

not like this:

var math:Math = new Math();
math.PI

As you can see, it's the class that has the method. We can use this to make a singleton by providing a static getInstance() function that will be globally accessible that will always return the same object. Here's a sample implementation of the singleton:

package {

    public class SingletonSample {

        // The singleton instance
        private static sharedSingleton:SingletonSample = null;

        // The constructor. AS3 doesn't allow for private constructors
        // so we have to protect it manually
        public function SingletonSample() {
            if (sharedSingleton != null)
                throw new Error ("SingletonSample cannot be created with the new keyword. Use getInstance() instead.");
        }

        // The method that will get the actual instance
        public function getInstance():SingletonSample {
            if (sharedSingleton == null)
                sharedSingleton = new SharedSingleton();
            return sharedSingleton;
        }

    }

}

Aside from those methods and variables defined in the sample, the rest of the class can be programmed normally. Then, when you want to use the class in your code, instead of doing this:

var instance:SingletonSample = new SingletonSample();
instance.doAThing(instance.aProperty);

do this:

var instance:SingletonSample = SingletonSample.getInstance();
instance.doAThing(instance.aProperty);

In fact, when you're just quickly calling methods, you don't need to create a local variable at all. Just do something like this:

SingletonSample.getInstance.aQuickFunction();

This is all globally available, provided the SingletonSample class has been imported. This design pattern makes a great "manager" class, so it will probably fit your needs. Keep in mind, though, singletons are generally not good for actually being manipulatable objects. Use them as managers that provide references to other things, a sort of "middleman" class, if you will. However, if used properly, they can be a powerful and convenient tool in a programmer's arsenal.

Answer 4

You can consider using a static class variable, something like:

package trailcrest.core {
    import trailcrest.core.core;
    public class YourCustomClass {
        public static var coreReachableFromAnywhere:Core //THE STATIC VARIABLE FOR CORE
    }
}

Then in your grandchild code:

import trailcrest.core.YourCustomClass;
yourCustomClass.coreReachableFromAnywhere = new Core();
yourCustomClass.coreReachableFromAnywhere.someMethod() ...

Edit

Of course adding the singleton type of method as was suggested by others would make it even cleaner, I will up-vote their answers as well.