Question

package uk.co.bigroom.utils 
{
    import flash.utils.Dictionary;
    /**
     * Class to create a weak reference to an object. A weak reference
     * is a reference that does not prevent the object from being
     * garbage collected. If the object has been garbage collected
     * then the get method will return null.
     */
    public class WeakRef
    {
        private var dic:Dictionary;

        /**
         * The constructor - creates a weak reference.
         * 
         * @param obj the object to create a weak reference to
         */
        public function WeakRef( obj:* )
        {
            dic = new Dictionary( true );
            dic[obj] = 1;
        }

        /**
         * To get a strong reference to the object.
         * 
         * @return a strong reference to the object or null if the
         * object has been garbage collected
         */
        public function get():*
        {
            for ( var item:* in dic )
            {
                return item;
            }
            return null;
        }
    }
}

In this Class, how they denote one as Weak Reference and one as Strong reference.

Answer 1

the class itself emulates a weak reference, and can be passed around as one.
if there are no other weak references to the value, it is garbage collected, since the reference to it is established through a dictionary with weak (reference) keys.

as soon as you get the value within, you obtain a reference of the object itself, which, like all direct object references in ActionScript, is a strong reference. as long as you keep that reference, the object will not be garbage collected.

edit: Difference between weak and strong references
During the execution of a program, memory needs to be managed. Low level languages require you to manually allocate memory (get free space) and free it, when the object is no longer needed. Higher level languages use garbage collection. This is a system that tries to determine, whether objects are still needed, or are “garbage”, i.e. can be discarded, freeing the memory they require. To determine, whether an object is needed, the garbage collector tries to find other objects, that “know” this object, i.e. have a reference to it. When an object is referenced by other objects, it is retained (in fact it isn’t, since otherwise unreferenced objects can reference each other cyclically, but let’s not get into details too much).
Thus “knowing”/referencing an object has the side effect of “keeping it alive”, since it cannot be removed. Sometimes, this side effect is not desidered. For example, if you need a list of all existing objects of some time for quicker access, having this list would keep them from being discarded, even if that very list is the only object to hold references to them. This is why there are weak references, in contrast to normal references that can also be refered to as “strong” since they keep the object from being garbage collected. Weak references allow you to reference an object, but are ignored by the garbage collector. This can often be very helpful, as in the case described above.

greetz
back2dos