Methode der Main-Klasse aufrufen von eingebetteter Klasse

[nonverbla]

Hallo, ich habe ein Problem und komme einfach nicht drauf, deshalb habe ich jetzt mal eine Musterklasse geschrieben, in der ich es so mache, wie ich denke, dass es genmacht werden muss (tut's aber nicht):

PHP-Code:

package {
    import Trigger;
    import flash.display.*;
    import flash.events.*;
    
    public class Main extends MovieClip {
        
        public function Main(){
            
            function traceIt(){ // die Funktion, die später angesprochen werden soll von der Klasse trigger
                trace("la");
            }
            
            var myTrigger = new Trigger();
            stage.addChild(myTrigger);
            myTrigger.init();
        }
        
    }
} 


PHP-Code:

package {
    
    import flash.display.*;
    import flash.events.*;
    
    public class Trigger extends MovieClip {
        public function Trigger (){
            
        }
        public function init(){
            stage.addEventListener(MouseEvent.CLICK, clickHandler);
        }
        
        public function clickHandler(event:MouseEvent){
            super.traceIt(); // Bei Klick soll die funktion »traceIt()« in der Main-Klasse angesprochen werden
        }
    }
} 


Das ganze geht leider nicht, was genau mache ich falsch? Im Moment gibt er mir bei Klick die Nachricht »ReferenceError: Error #1070: Methode traceIt nicht in flash.display.MovieClip gefunden at Trigger/clickHandler()« aus....

[Omega Psi]

Da ist einiges durcheinander.

package {
 
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
 
    public class App extends Sprite {
 
        protected var trigger:Trigger;
 
        public function App() {
            super();
            this.inititialize();
        }
 
        protected function initialize():void {
            this.trigger = new Trigger();
            this.trigger.addEventListener(MouseEvent.CLICK, eventListener, false, 0, true);
        }
 
        protected function eventListener(event:Event):void {
            if (event.type = Mouseevent.CLICK) {
                trace(event.target);
            }
        }
    }
} 

package {
 
    import flash.display.Sprite;
 
    public class Trigger extends Sprite {
 
        public function Trigger() {
            super();
            this.initialize();
        }
 
        protected function initialize():void {
            /* Do something. */
        }
    }
} 

So sieht das etwas anders aus. Schaue dir nochmal das Event-System an und Vererbung an. Da sind bei dir nämlich die Fehler.

[nonverbla]

ayayay, ja dann schau ich mir das nochmal an, leider denke ich beim Anschauen meißt an anderes

Danke erstmal, ich werde es später testen

Rasso

[nonverbla]

ähm,

ich glaube, ich habe mich nicht verständlich genug gemacht...

Mir geht es darum, aus der unterklasse eine Funktion in der Hauptklasse aufzurufen. Wie geht das?

Das mit dem Event-Ding war nur als Beispiel gedacht...

[Omega Psi]

Ich sagte ja, du solltest dich nochmal mit der Vererbung und dem Eventsystem befassen. Ein Beispiel für Vererbung:

package {
  public class SuperClass {
    public function SuperClass() {
      super();
      trace("SuperClass#initialize");
      this.initialize();
    }
    protected function initialize():void {
      trace("SuperClass#initialize");
    }
    public function doSomething():void {
      trace("SuperClass#doSomething");
    }
  }
} 

package {
  public class SubClass extends SuperClass {
    public function SubClass() {
      super();
      trace("Sub#initialize");
      this.initialize()
    }
    protected function initialize():void {
      trace("SubClass#initialize");
    }
    public function doSomething():void {
      trace("SubClass#doSomething");
      super.doSomething();
      trace("\tdoSomethingMore");
    }
  }
} 

Das Beispiel sollte die Beziehung zwischen Super- und Kindklasse gut illustrieren.

[Omega Psi]

So nebenbei: schaue dir nochmal die ganzen Fachwörter an.

Wenn du von eingebetteter Klasse sprichst, könnte man meinen du sprichst von einer gekapselten Klasse. Vererbung ist was anderes.

[nonverbla]

So, hier habe ich jetzt die Lösung gefunden:

http://greenethumb.com/article/23/un...t-class-in-as3

Man muss also angeblich das root als type der Hauptklasse casten

danke und vielleicht hilfts ja jemandem.

[nonverbla]

Entschuldige, habe deine Beiträge nicht bemerkt...

Mein Problem ist, dass ich garnicht weiss, wo ich in der riesigen Flash-Hilfe überhaupt anfangen soll zu lesen, ausserdem weiss nicht, was Vererbung auf Englisch heisst

Das Geheimnis bei Deinem Beispiel scheint also irgendwie dieses ominöse »super()« im Konstrukor zu sein und dass die SubClass die MainClass extendet, oder?

Tut mir leid, ich habe dazu in der Hilfe wirklich noch nichts gefunden...

[Omega Psi]

Deutsch/Englisch, Englisch/Deutsch: http://dict.leo.org/, http://www.dict.cc/

Wenn du in der Hilfe nichts über super gefunden hast, hast du sie nicht benutzt oder falsch. super(); im Konstruktor ruft den Konstruktor der Superklasse auf. super.<Functionsname>() ruft die Funktion der Superklasse auf, wenn die Methode public oder protected deklariert ist.

Und hier findest du die Dokumentation auf deutsch: Link

[nonverbla]

Wie dem auch sei... Hier ein funktionierendes Beispiel:

[messingfeld]

root ist keine schöne Lösung

Lösung 1:

Anstatt stage.addChild() verwende this.addChild(), wenn du die Klasse Main als Dokumenten Klassen verwendest

package {
	import flash.display.*;
	import flash.events.*;

	public class Main extends MovieClip {
		public function Main() {
			super();
			var myTrigger:Trigger = new Trigger();
			this.addChild(myTrigger);
			myTrigger.init();
		}
		public function traceIt():void {
			trace("la");
		}
	}
}

package {

	import flash.display.*;
	import flash.events.*;

	public class Trigger extends MovieClip {
		public function Trigger() {
			super();
		}
		public function init():void {
			stage.addEventListener(MouseEvent.CLICK, clickHandler);
		}
		public function clickHandler(event:MouseEvent):void {
			var parentClip:MovieClip = MovieClip(this.parent);
			parentClip.traceIt();
		}
	}
}

Lösung 2, aber nicht sehr schön:

Wenn du unbedingt stage.addChild verwenden willst , dann ist die Instanz der Klasse Main ein Kind (Child) von stage.
Und das ist in diesem Fall das erste Kind.

package {
	import flash.display.*;
	import flash.events.*;

	public class Main extends MovieClip {
		public function Main() {
			super();
			var myTrigger:Trigger = new Trigger();
			stage.addChild(myTrigger);
			myTrigger.init();
		}
		public function traceIt():void {
			trace("la");
		}
	}
}

package {
	import flash.display.*;
	import flash.events.*;

	public class Trigger extends MovieClip {
		public function Trigger() {
			super();
		}
		public function init():void {
			stage.addEventListener(MouseEvent.CLICK, clickHandler);
		}
		public function clickHandler(event:MouseEvent):void {
			var parentClip:MovieClip = MovieClip(this.parent.getChildAt(0));
			parentClip.traceIt();
		}
	}
}

Lösung 3:

Du übergibt eine Referenz.

package {
	import flash.display.*;
	import flash.events.*;

	public class Main extends MovieClip {
		public function Main() {
			super();
			var myTrigger:Trigger = new Trigger();
			myTrigger.target = this;
			// stage oder this
			stage.addChild(myTrigger);
			myTrigger.init();
		}
		public function traceIt():void {
			trace("la");
		}
	}
}

package {

	import flash.display.*;
	import flash.events.*;

	public class Trigger extends MovieClip {
		public var target:MovieClip;
		public function Trigger() {
			super();
		}
		public function init():void {
			stage.addEventListener(MouseEvent.CLICK, clickHandler);
		}
		public function clickHandler(event:MouseEvent):void {
			this.target.traceIt();
		}
	}
}

[nonverbla]

Oh mann, genial, das funktioniert super! Danke für die tollen Beispiele, messingfeld!

Ich werde mich wohl an Methode 3 halten, weil dann kann ich ja auch zwischen verschiedenen Unterklassen kommunizieren, einfach indem man die Ziele Methoden bei der Instanzierung in der Main-Klasse übergibt, ne?

Das einzige, was ich noch nicht kapiere, ist, warum ihr immer im Konstruktor dieses »super()« angebt. Nach der Hilfe ruft dieses den Konstruktor der Übergeordneten Klasse auf. Warum genau macht ihr das? Wenn ich es weglasse, funktioniert es nämlich trotzdem...