ActionScript 3
Programación orientada a objetos

Constructor "sobrecargado" a través del método estático

La sobrecarga de constructores no está disponible en As3.

Con el fin de proporcionar una forma diferente de recuperar una instancia de una clase, se puede proporcionar un método public static para que sirva como un "constructor" alternativo.

Un ejemplo de esto es flash.geom.Point , que representa un objeto de punto 2D. Las coordenadas para definir el punto pueden ser

• cartesiano en el constructor regular

  public function Point(x:Number = 0, y:Number = 0) 
  

  ejemplo de uso:

  var point:Point = new Point(2, -.5);
  

• polar en un método estático

  public static function polar(len:Number, angle:Number):Point
  

  ejemplo de uso:

  var point:Point = Point.polar(12, .7 * Math.PI);
  

  Debido a que no es un constructor real, no hay una new palabra clave.

establecer y obtener funciones

Para garantizar la encapsulación, las variables de los miembros de una clase deben ser private y solo deben ser accesibles al public través de métodos public acceso a get / set . Es una práctica común prefijar campos privados con _

public class Person
{
    private var _name:String = "";

    public function get name():String{
        return _name;
        //or return some other value depending on the inner logic of the class
    }


    public function set name(value:String):void{
        //here you may check if the new value is valid
        //or maybe dispatch some update events or whatever else
        _name = value;
    }

A veces ni siquiera es necesario crear un campo private para un par de get / set .
Por ejemplo, en un control como un grupo de radio personalizado, necesita saber qué botón de opción está seleccionado, sin embargo, fuera de la clase, solo necesita una forma de get / set solo el valor seleccionado:

public function get selectedValue():String {
    //just the data from the element
    return _selected ? _selected.data : null;
}
public function set selectedValue(value:String):void {
    //find the element with that data
    for (var i:int = 0; i < _elems.length; i++) {
        if (_elems[i].data == value) {
            _selected = _elems[i];//set it 
            processRadio();//redraw
            return;
        }
    }
}

Paquetes

Los paquetes son paquetes de clases. Cada clase debe ser declarada dentro de un paquete usando la declaración del package . La declaración del package va seguida del nombre de su paquete, o seguida de nada en el caso de agregar clases al paquete de nivel superior. Los subpaquetes se crean utilizando la delimitación de puntos ( . ) A la declaración del paquete le sigue un bloque que contendrá una sola definición de class . Ejemplos:

package {
    // The top level package.
}

package world {
    // A package named world.
}

package world.monsters {
    // A package named monsters within a package named world.
}

Los paquetes deben correlacionarse con la estructura de archivos de las clases en relación con la raíz de origen. Suponiendo que tiene una carpeta raíz de origen llamada src , lo anterior podría representarse correctamente en el sistema de archivos como:

src
    TopLevelClass.as
    
    world
        ClassInWorldPackage.as
        AnotherClassInWorldPackage.as
        
        monsters
            Zombie.as

Método de anulación

Cuando extend una clase, puede override métodos que la clase heredada define usando la palabra clave de override :

public class Example {
    public function test():void {
        trace('It works!');
    }
}

public class AnotherExample extends Example {
    public override function test():void {
        trace('It still works!');
    }
}

Ejemplo:

var example:Example = new Example();
var another:AnotherExample = new AnotherExample();

example.test(); // Output: It works!
another.test(); // Output: It still works!

Puede usar la palabra clave super para hacer referencia al método original de la clase que se hereda. Por ejemplo, podríamos cambiar el cuerpo de AnotherExample.test() a:

public override function test():void {
    super.test();
    trace('Extra content.');
}

Resultando en:

another.test(); // Output: It works!
                //         Extra content.

La anulación de los constructores de clases es un poco diferente. La palabra clave de override se omite y el acceso al constructor heredado se realiza simplemente con super() :

public class AnotherClass extends Example {
    public function AnotherClass() {
        super(); // Call the constructor in the inherited class.
    }
}

También puede anular métodos get y set .

getter y setter

Getters y setters son métodos que se comportan como propiedades. significa que tienen una estructura funcional, pero cuando se usan, se usan igual que las propiedades:

Estructura de las funciones getter :

que deberían tener get palabra clave después de function de palabras clave y antes del nombre de la función, sin ningún argumento, especifica un tipo de retorno y debe devolver un valor:

public function get myValue():Type{
    //anything here
    return _desiredValue;
}

Sintaxis :

para obtener el valor de un captador, la sintaxis es la misma que obtener un valor de una propiedad (no se utilizan parens () ).

trace(myValue);

Estructura de las funciones de setter :

deberían haber set palabra clave después de la palabra clave de la function y antes del nombre de la función, con un argumento y sin retorno de valor.

public function set myValue(value:Type):void{
    //anything here
    _desiredProperty=value;
}

Sintaxis :

para establecer el valor de un definidor, la sintaxis es la misma que para establecer un valor en una propiedad (usando el signo igual = luego valor).

myValue=desiredValue;

configurando un captador y definidor para un valor :

Nota: si creas solo getter o solo setter con un nombre, esa propiedad sería de solo lectura o solo de set.

para hacer que una propiedad sea legible y programable, debe crear un captador y un establecedor con:

1.el mismo nombre.
2.el mismo tipo (tipo de valor de retorno para el captador y tipo de valor de entrada (argumento) para el configurador,

Nota: los captadores y los definidores no deben tener un nombre igual al de otras propiedades o métodos.

Uso de getters y setters:

El uso de captadores y definidores en lugar de las propiedades normales tiene muchas ventajas:

1. Hacer propiedades de solo lectura o solo de set:
por ejemplo, número de hijos en un objeto de visualización. no puede ser setable

2. Accediendo a propiedades privadas:
un ejemplo:

private var _private:Type=new Type();
//note that function name "private" is not same as variable name "_private"  
public function get private():Type{
    return _private;
}

3. cuando se requiere algún cambio después de establecer un valor:
en este ejemplo, se debe notificar el cambio de esta propiedad:

public static function set val:(input:Type):void{
    _desiredProperty=input;
    notifyValueChanged();
}

y muchos otros usos