Waarom zijn deze statement nodig?

[PageMaker]

Ik heb een klasse die via javascript enige gegevens ophaalt; dat werkt perfekt, ik heb de volgende klasse. Voor het overzicht sterk ingekort.
import GetParamEvent;

public class GetScreenParams extends EventDispatcher
{
private var textBox:TextField;

public var sParamArr:Array = new Array();

public function GetScreenParams( txtBox:TextField )
{
this.textBox = txtBox;
..........................
private function newScreenParams( sParamArr ):void
{
this.sParamArr = sParamArr;
// Nu: doorgeven van data aan de luisteraar(s);
dispatchEvent( new GetParamEvent( GetParamEvent.PARAM_EVENT, sParamArr ));
} // getScreenParams

De output in de Main klasse krijg ik als volgt:
public class Main extends Sprite
{
public var screenParam:Array = new Array();

public function Main()
{
textBox.text = '1 - Main \n';
var getScreenParams = new GetScreenParams( textBox );
getScreenParams.addEventListener( GetParamEvent.PARAM_EVENT, onGetParams );
} // constructor

private function onGetParams( evt:GetParamEvent ):void
{
textBox.appendText("evt: " + evt + "\n"); // output: [evt.... etc.....]
textBox.appendText("evt.target: " + evt.target + "\n"); // output [Object GetScreenParams]
textBox.appendText("evt.target.sParamArr: " + evt.target.sParamArr + "\n");
textBox.appendText("evt.currentTarget: " + evt.currentTarget + "\n"); // output [Object GetScreenParams]
textBox.appendText("evt.currentTarget.sParamArr: " + evt.currentTarget.sParamArr + "\n"); // output [Object GetScreenParams]
/*
textBox.appendText("evt.target.paramInfo: " + evt.target.paramInfo + "\n"); // werkt niet
textBox.appendText("evt.target.paramInfo(): " + evt.target.paramInfo() + "\n"); // werkt niet
*/

var scrnParams = evt.currentTarget as GetScreenParams;
screenParam = scrnParams.sParamArr;

textBox.appendText("screenParam.length: " + screenParam.length + "\n");

} // onGetParamsIk begrijp niet waarom:
1. sParamArr in GetScreenParams public gedefinieerd moet zijn - zonder dat geen output in Main; en
2. het statement: "this.sParamArr = sParamArr; " perse in newScreenParams moet staan want zonder dat ook geen output.

Ik heb in Main al van alles geprobeerd maar tot dusver zonder resultaat; het lijkt alsof de wel in GetParamEvent aanwezige gevulde array sParamArr niet bereikbaar is. Hoe doe je dat nu?
Voor verkregen output zie het plaatje.

[jaspermuts]

1. sParamArr in GetScreenParams public gedefinieerd moet zijn - zonder dat geen output in Main;

Dat is precies wat het verschil tussen public en private is: benaderbaar van buiten af. Private vars kun je alleen maar aanspreken van binnenuit de class (dus alleen vars waar op dat moment je this voor kunt zetten).
Over het algemen zijn de meeste vars private. Dit om je code te beschermen tegen verkeerd gebruik. Door zoveel mogelijk (public) getters en setters te gebruiken heb je beter in de hand wat er gebeurt als er iets verandert. Als ik je class zou gebruiken zou ik bijv ook een array met allemaal troep zonder controle in sParamArr kunnen opslaan, en ook die array zonder controle kunnen bewerken, dan is het fijn dat je dat kunt voorkomen door het wat minder open (public) te maken.
De meeste properties van de standaard classes van AS3 zijn ook niet public, het zijn getters en setters van private properties.
Neem bijv rotation van een displayobject, dat lijkt n public property maar als je naar de implementation in de livedocs kijkt zie je dit:

rotation property
rotation:Number []
Language Version : ActionScript 3.0
Runtime Versions : AIR 1.0, Flash Player 9
Indicates the rotation of the DisplayObject instance, in degrees, from its original orientation. Values from 0 to 180 represent clockwise rotation; values from 0 to -180 represent counterclockwise rotation. Values outside this range are added to or subtracted from 360 to obtain a value within the range. For example, the statement my_video.rotation = 450 is the same as my_video.rotation = 90.


Implementation
public function get rotation():Number
public function set rotation(value:Number):void

Wat er aan de binnenkant gebeurt kun je helaas niet zien :)


2. het statement: "this.sParamArr = sParamArr; " perse in newScreenParams moet staan want zonder dat ook geen output.

Ik begrijp hier niet zo goed wat je doet, je hebt een functie binnen een functie (sowieso geen normaal gebruik binnen AS3), en daarbij zijn de class-en functie namen nogal onlogisch: een class naam zou een enkelvoudige zelfstandige naam moeten zijn (bijv ScreenParamCollection oid), en een functie een werkwoord (bijv getScreenParams()), met uitzondering van de constructor, die heeft dezelfde naam als de class (ScreenParamCollection()). De constructor is de functie die wordt aangeroepen op het moment dat je new JeClassNaam() aanroept.
Ik zal je functie newScreenParams() maar even lezen alsof je de constructor had bedoeld: je hebt daar een argument in de functie, die je als class member wil opslaan. Het is misschien duidelijker waarom je dat wil als ik de namen (op een overdreven manier) verander:

private var paramsArrayInClassInstantieScope:Array;

public function ScreenParamCollection( paramsArrayInFunctieScope:Array ):void
{
this.paramsArrayInClassInstantieScope = paramsArrayInFunctieScope;
}
Dat Event dat je dispatchet, daar geef je ook je params array aan, maar daar doe je verder niets mee (je gebruikt in de event handler namelijk evt.currentTarget.sParamArray, ipv evt.sParamArray.
(ik vind het via evt overigens ook logischer, want het is dus dubbelop om het in het event op te slaan als je het al uit de currentTarget van het event kunt halen)

[PageMaker]

Dank voor je reactie; het is een heel verhaal geworden.
Ik heb inmiddels een werkende versie gemaakt die veel eenvoudiger is en die wel doet wat ik er van verwacht.
Dit is ém:
// SimpelCustomEvents Main.as
package
{
import flash.display.Sprite;
import flash.text.TextField;

import CustomEventClass;
import DispatcherClass;

public class Main extends Sprite
{
public function Main()
{
textBox.text = '1 - Main \n';

var disPatch = new DispatcherClass( textBox );

disPatch.addEventListener( CustomEventClass.CUSTOM_EVENT, handleCustomEvent );

disPatch.dispatchMyEvent(); // dit statement triggert bovenstaand event
} // constructor

private function handleCustomEvent( evt:CustomEventClass ):void
{
textBox.appendText('\t\t evt: ' + evt + '+\n')
textBox.appendText('\t\t demoFunctionArray(): ' + evt.demoFunctionArray() + '\n');

} // handleCustomEvent

} // class Main
} // package// SimpelCustomEvents DispatcherClass.as
package
{
import CustomEventClass;
import flash.events.EventDispatcher;
import flash.text.TextField;

public class DispatcherClass extends EventDispatcher
{
private var textBox:TextField;
private var anArray:Array = new Array();

public function DispatcherClass( txtBox:TextField ):void
{
this.textBox = txtBox;

anArray.push("Pos-1", 'Pos-2', 'Pos-3');

textBox.appendText("2 - DispatcherClass \n");
textBox.appendText("\t\t anArray: " + anArray + "\n");
} // constructor

public function dispatchMyEvent():void
{
var customEventClass:CustomEventClass = new CustomEventClass( anArray, textBox );

dispatchEvent( customEventClass );
} // dispatchMyEvent

} // class DispatcherClass
} // package// SimpelCustomEvents CustomEventClass.as
package
{
import flash.events.Event;
import flash.text.TextField;

public class CustomEventClass extends Event
{
public static const CUSTOM_EVENT:String = "MyFirstCustomEvent";

public var thisArray:Array = new Array();
private var textBox:TextField;

public function CustomEventClass( myArray:Array, txtBox ):void
{
this.textBox = txtBox;
this.thisArray = myArray;

textBox.appendText("3 - CustomEventClass \n");
textBox.appendText("\t\t thisArray: " + thisArray + "\n");

var type:String = CUSTOM_EVENT;
var bubbles:Boolean = true;
var cancelable:Boolean = false;

super( type, bubbles, cancelable );
} // constructor

public function demoFunctionEvent():*
{
return "Bla Bla Banaan"; //retour;
} // demo

public function demoFunctionArray():Array
{
return thisArray; //retour;
} // demo

public override function toString():String
{
return formatToString('CustomEventClass', 'type', 'thisArray',
'bubbles', 'cancelable', 'eventPhase' );
} // toString

} // class CustomEventClass
} // package
De kern van het verhaal lijkt te zijn:
1. dat in de EventClass de door te geven property public moet zijn gedeclareerd; en
2. dat je de inhoud van die property via een functie moet doorgeven.

Ik zeg: "moet", maar misschien kan het ook anders.

1. Is zelfs niet noodzakelijk! Maar dan moet je de property wel uit formatToString verwijderen.

[PageMaker]

Output vergeten.

[jaspermuts]

1. dat in de EventClass de door te geven property public moet zijn gedeclareerd;

Nee, de event zou niet veel meer dan de bron van het event en de type en andere aanvullende info van de gebeurtenis moeten bevatten.
Eigenschappen van de bron (bedoel ik currentTarget mee ) van het event zou ik in de bron houden.

2. dat je de inhoud van die property via een functie moet doorgeven.

Ja, moeten is inderdaad een groot woord, maar getters en setters zijn wel zo netjes.
Toch raad ik aan wat meer in de boeken/tutorials te duiken (met name AS3 OOP ), voordat je veel complexe vragen post: uit de naamgeving en gebruik van je functies en classes blijkt toch nog dat er nog veel niet duidelijk is.

De naam van een class is dus zoals ik zei normaal gesproken een zelfstandig naamwoord, maar eigenlijk een waarbij het pas klopt als dat is wat 'new JeClassNaam()' returnt. Daarmee bedoel ik dat je dus niet een class 'DoosjeClass' hebt, maar 'Doosje' zodat je krijgt: 'new Doosje()', je maakt namelijk een nieuw doosje aan, niet een nieuwe class. Dit geldt dus ook zo voor EventClass.
De dispatcher class is overbodig, je voegt m in Main toe, Main is een subclass van Sprite, en Sprite is een subclass van EventDispatcher, dus Main kan prima zelf events dispatchen

[PageMaker]

Ja, moeten is inderdaad een groot woord, maar getters en setters zijn wel zo netjes.
Voor mij nog wel zoiets waarbij ik vraag: "Kun je dat eten?"
Wanneer je een goede tut hebt houd ik me aanbevolen; vooral ook om de vraag te beantwoorden waarom het dan wel zo netjes is.
Voor het overige zeer bedankt voor de uitleg.