Namespaces und ihre Funktion in Flash

[_crypto_]

Ja, also warum gibt es sie in flash?
da bin ich echt überfragt.

namespaces können nur auf funktionen von klassen gesetzt
werden und nicht auf öffentliche funktionen in einem package.

wo is da der sinn?
ich mein ich kann eine funktion in der klasse eh nur 1x definieren.

wenn die namespaces auch auf funktionen gehen würden, würde ich
es verstehen und sogar mal gut finden, denn dann könnte man
funktionen in gewisser weise überladen.

method1(param: *): *;

namespace::method1(): void;

wäre dann beides möglich, da der compiler ja weiß welche von beiden
zu nehmen ist.

aber da dies in flash nicht geht ... warum dann

kann man die nicht in irgendeiner art und wiese gebrauchen um überladen zu
ermogeln?

[Omega Psi]

Mal eben schnell zusammen gepastet aus der Language Reference:

The Namespace class contains methods and properties for defining and working with namespaces. There are three scenarios for using namespaces:

• Namespaces of XML objects Namespaces associate a namespace prefix with a Uniform Resource Identifier (URI) that identifies the namespace. The prefix is a string used to reference the namespace within an XML object. If the prefix is undefined, when the XML is converted to a string, a prefix is automatically generated.
• Namespace to differentiate methods Namespaces can differentiate methods with the same name to perform different tasks. If two methods have the same name but separate namespaces, they can perform different tasks.
• Namespaces for access control Namespaces can be used to control access to a group of properties and methods in a class. If you place the properties and methods into a private namespace, they are inaccessible to any code that does not have access to that namespace. You can grant access to the group of properties and methods by passing the namespace to other classes, methods or functions.

package {
    import flash.display.Sprite;
  
    public class Namespace_3_Example extends Sprite {     
        public function Namespace_3_Example() {
            addChild(new StateButton("Press Me."));
        }
    }
}
 
import flash.display.Sprite;
import flash.text.TextField;
import flash.events.Event;
import flash.events.MouseEvent;
 
class StateButton extends Sprite{
    private namespace out;
    private namespace over;
    private namespace down;
    private var label:TextField;
    private var labelTxt:String;
    private var ns:Namespace;
    out var bgColor:Number = 0xFF0000;
    over var bgColor:Number = 0xFFFF00;
    down var bgColor:Number = 0xFFFFFF;
      
    public function StateButton(str:String) {
        buttonMode = true;
        labelTxt = str;
        ns = out;
        draw();
        addLabel();
        addListeners();
    }
 
    private function addLabel():void {
        label = new TextField();
        label.text = labelTxt;
        label.width = 50;
        label.height = 20;
        label.mouseEnabled = false;
        addChild(label);
    }
      
    private function addListeners():void {
        addEventListener(MouseEvent.MOUSE_UP, mouseOverHandler);
        addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
        addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
        addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
    }
 
    private function mouseOutHandler(e:Event):void {
        ns = out;
        draw();
    }
 
    private function mouseOverHandler(e:Event):void {
        ns = over;
        draw();
    }
 
    private function mouseDownHandler(e:Event):void {
        ns = down;
        draw();
    }
 
    private function draw():void {
        this.graphics.clear();
        this.graphics.beginFill(ns::bgColor);
        this.graphics.drawRect(0, 0, 60, 20);
    }
} 

Letzten Endes läuft es darauf hinaus, so wie ich es verstehe (und auch das Beispiel oben), dass es nicht um Methodennamen geht, sondern darum Bezeichner innerhalb eines Scopes allgemein öfter zu verwenden. Denn ActionScript erlaubt es beispielsweise auch nicht, dass Variablen und Methoden gleich benannt sind.

Wirkliches Überladen von Methoden ist es nicht, da du nur Zugriff auf die Felder/Funktionen des entsprechenden Namespace hast, wenn dein aufrufender Scope (ausgenommen der eigenen Klasse, die muss ihn ja kennen) diesen Namespace auch kennt.

Edit: viel wichtiger ist: es handelt sich immer um eigenständiges Objekte und hat mit Überladen gar nichts zu tun ich Semmel.

Die mehrfache Verwendung von Bezeichnern ist aber nicht die eigentliche Intention: es geht darum, wie auch bei package Deklarationen von Klassen und Funktionen, Attribute und Funktionen noch differenzierter innerhalb eines Scopes betrachten und klassifizieren zu können. Da kannst du am besten die Analogie zu Namespaces ziehen, wie sie in XML verwendet werden.

[_crypto_]

naja aber warum die das ganze niht dann auf normale
funktionen übertragen haben find ich schade.

ich versteh zwar jetzt ein bisschen was man damit anstellen kann
zumindest in punkt 2.

german function sayHello(): void { trace("Hallo!"); }
english function sayHello(): void{ trace("Hello!"); }

und dein beispiel versteh ich auch.

trozdem fehlt es auch für normale funktionen

[Omega Psi]

Was fehlt für normale Funktionen?

[_crypto_]

mir ging es hauptsächlich darum, das wenn ich z.b. öffentliche
funktionen erstelle, ala getTimer, setInterval etc.

das ich diese ebenfalls mit einem namespace belegen kann,
denn so kann ich ausschließen das der benutzer eine funktion
hat die ebenfalls so heißt, da beide funktionen dann noch gültig sind.
sowas geht halt nicht:

package pack1.pack2
{
    import pack1.my_namespace;
 
    use namespace my_namespace;
 
    my_namespace function doSomething(param: *): * {
        // ..
        return;
    }
}
 
 
import pack1.*;
import pack1.pack2.*;
 
function doSomething(): void {
    // ...
}
 
doSometing();
my_namespace::doSometing(10); 

wäre dann beides möglich.