Aiuto con concetti di scrittura classe

[Stan]

Ho scritto una classe che deve restituire un array con dei valori presi da un intervallo di tempo, con crescita in base alla funzione di easing passata.

package
{
	import flash.events.*;
	import fl.transitions.easing.Regular;
    
    public class easeTime  {

		private var arrayTempo:Array

		function easeTime(elementi:Number, myease:Function=null){
			if (myease==null){myease=Regular.easeOut}
			arrayTempo= new Array()
			for (var i=1;i<=elementi;i++){
				arrayTempo.push(myease(i,0,((i/elementi)/i)*elementi, elementi))
			}			
			restituisci()
		}
		function restituisci():Array{
			return arrayTempo
		}
	}
}

vorrei usarla così

var elementi:Number=10
var ease:Function = Regular.easeOut


trace(new easeTime(elementi, ease));// deve restituire l'array

Solo che mi restituisce l'istanza della classe. Non c'ho mai capito granché con le classi! Chi sa come risolvere?

[and80]

Una classe ha come elemento "costruttivo" di se stessa appunto un costruttore, ossia una funzione con lo stesso nome della classe, che restituisce la classe.
Poi ha degli elementi secondari che si dividono principalmente in "proprietà" e "metodi".
I metodi sono funzioni che la classe può richiamare, mentre le proprietà sono praticamente delle variabili che possono assumere determinati valori che agiscono ad esempio sull'aspetto della classe.
Ad esempio nella classe MovieClip, la funzione play() è un metodo di quella classe mentre la variabile alpha è una proprietà.

Ora è chiaro che la tua classe non può restituire un array dal costruttore, inoltre la classe Array è di tipo "final" e quindi non può essere neanche estesa.
Per intenderci non puoi fare

public class easeTime extends Array

Quindi ti serve una proprietà che a seconda dei valori che gli passi nel costruttore ti restituisce un determinato array.

package {
    import flash.events.*;
    import fl.transitions.easing.Regular;
    public class easeTime {
        private var arrayTempo:Array;
        public function easeTime (elementi:Number, myease:Function=null):void {
            arrayTempo = [];
            if (!myease) myease = Regular.easeOut;            
                for (var i:uint = 0; i <= elementi; i++) {
                    arrayTempo.push (myease(i, 0, ((i/elementi)/i)*elementi, elementi));
                }
            }
        }
        public function get tempo ():Array {
            return arrayTempo;
        }
    }
} 

import fl.transitions.easing.Regular;
var elementi:uint = 10;
var easeFunction = Regular.easeOut;
var eTime:easeTime = new easeTime(elementi, ease);
trace(eTime.tempo); // restituisce l'array 

[Stan]

Va bene, costruttore, metodi e proprietà più o meno li capisco. A quella soluzione c'ero già arrivato, anche grazie ad altre classi esaminate.

Però pensavo ci fosse anche la possibilità di ottenere un risultato subito, senza dover fare riferimento alla proprietà dell'istanza.

Sbaglio o ci sono anche classi che non vanno istanziate ad esempio, dove si possono usare subito i suoi metodi?

[and80]

Sì le classi singleton. Sono classi statiche che usano i metodi direttamente dal nome della classe, un esempio basato sulla tua necessità può essere questo:

package {
    import flash.events.*;
    import fl.transitions.easing.Regular;
    public class easeTime {
        private var arrayTempo:Array;
        public function easeTime ():void {
            throw (new Error("La classe è di tipo singleton e non può essere istanziata"));
        }
        public static function getArrayTempo (elementi:Number, myease:Function=null):Array {
            arrayTempo = [];
            if (!myease) myease = Regular.easeOut;            
                for (var i:uint = 0; i <= elementi; i++) {
                    arrayTempo.push (myease(i, 0, ((i/elementi)/i)*elementi, elementi));
                }
            }
            return arrayTempo;
        }
    }
} 

Aggiungendo l'attributo static alla costruzione di un metodo lo rendiamo utilizzabile in questo modo:

import fl.transitions.easing.Regular;
var elementi:uint = 10;
var easeFunction = Regular.easeOut;
trace(easeTime.getArrayTempo(elementi, easeFunction)); 

[Stan]

Non mi pare male per niente