Clases

Introduciremos rápidamente la estructura de las clases a la que podrías estar familiarizado si has tenido contacto anterior con programación OO :

    package mi.paquete;
    /*
        esto definirá la clase mi.paquete.MiClase
    */
    class MiClase {
        // ....
    }

Una clase puede tener varias variables y métodos.

    package mi.paquete;

    class MiClase {

        var id : Int;

        static var name : String = "MiCadena";

        function foo() : Void {
        }

        static function bar( s : String, v : Bool ) : Void {
        }
    }

Las variables y métodos pueden tener los siguientes modificadores :

• static : el campo pertenece a la clase en sí y no a las instancias de esta clase. Los identificadores estáticos se pueden referenciar directamente dentro de la clase. Desde fuera de la clase, se debe acceder a ellos mediante el nombre de la clase (por ejemplo : mi.paquete.MiClase.nombre).
• dynamic: el campo puede ser vuelto a fijar de manera dinámica.
• override: el campo está siendo redeclarado en una subclase.
• public : se puede acceder al campo desde fuera de la clase.
• private : el acceso al campo está restringido a la propia clase y a clases que derivan de ella: la "extienden" (extends). Esto asegura que el estado interno de la clase no sea accesible.
  Por omisión, todos los campos son private.

Todas las variables de clase deben ser declaradas con un tipo (puedes usar Dynamic si no sabes qué tipo usar). Los tipos los argumentos de las funciones y de devolución son opcionales pero se siguen comprobando de forma estricta de la manera indicada en la inferencia de tipos.

Las variables que no son estáticas no pueden tener un valor inicial. Las variables estáticas pueden tener un valor inicial, aunque no es preciso.

Constructor

La clase puede tener un único constructor, que es la función no estática llamada new. Es una palabra clave que también puede ser usada como nombre de una función de clase :

    class Point {
        public var x : Int;
        public var y : Int;

        public function new() {
            this.x = 0;
            this.y = 0;
        }
    }

Parametrización y sobrecarga de un constructor :

    public function new( x : Int, ?y : Int ) {
        this.x = x;
        this.y = (y == null) ? 0 : y; // "y" es opcional
    }

Herencia de clases

Al declararla, es posible hacer que una clase extienda otra clase e implemente varias otras clases o interfaces. Esto significa que la clase heredará varios tipos al mismo tiempo y puede ser tratada como tales. Por ejemplo :

    class D extends A, implements B, implements C {
    }

Cada instancia de D tendrá el tipo D pero también serás capaz de usarla donde se precise una instancia de tipo A, B o C. Esto significa que cada instancia de D también tiene los tipos A , B y C.

Extends

Al extender una clase, la nueva clase hereda todos los campos públicos y privados que no sean estáticos. Puedes usarlos en tu clase como si los hubieras declarado allí. También puedes redeclarar un método redefiniéndolo con el mismo número y tipo de argumentos que en su superclase. La nueva clase no puede heredar campos estáticos.

Cuando se redeclara un método, puedes seguir accediendo al de la superclase usando super :

    class B extends A {
        function foo() : Int {
            return super.foo() + 1;
        }
    }

En el constructor de tu clase también puedes invocar al constructor de la superclase usando super :

    class B extends A {
        function new() {
            super(36,"");
        }
    }

Implements

Cuando se implementa una clase o interfaz, se precisa que la nueva clase implemente todos los campos declarados o heredados por la clase que implementa, con los mismos tipos y nombres. Sin embargo, el campo puede haber sido heredado ya desde una superclase.

Interfaces

Una Interfaz es un tipo abstracto. Se declara usando la palabra clave interfaz. Por omisión, todos los campos de interfaz son públicos. No se puede instanciar las interfaces.

    interface PointProto {
        var x : Int;
        var y : Int;
        function length() : Int;
    }

Una interfaz, a su vez, puede implementar una o más interfaces :

    interface PointMore implements PointProto {
        function distanceTo( p : PointProto ) : Float;
    } 

«« Inferencia de tipos - Parámetros de tipo »»