Inicio » Documentación » Objetos publicos

Objetos publicos

Los objetos sirven para encapsular en una misma entidad variables y métodos. Cuando una variable pertenece a un objeto, se le llama atributo. Y cuando una función pertenece a un objeto, se le llama método.

Un objeto público es accesible y modificable desde cualquier lugar de la aplicación y define sus elementos (atributos y métodos) de manera declarativa, igual que una clase.

El objeto público más básico posible es el siguiente:

object Prueba
endobject

Con esto hemos creado un objeto público llamado Prueba. Sin embargo, no tiene atributos ni métodos, por lo que no sirve para nada.

Atributos

Los atributos son variables asociadas a un objeto. Para añadir atributos a un objeto, basta con definirlos uno por uno con var y, opcionalmente, asignarles un valor. Los valores de los atributos son creados en tiempo de compilación y se guardan en la memoria compartida. Una vez que la aplicación los modifica, se guardan en la memoria de sesion.

object Prueba
    var color = "Rojo"
    var peso = 2
    var loquesea
endobject

Después, podemos acceder y manipular estos valores poniendo el nombre del objeto seguido de un punto y el atributo que queremos leer o modificar.

def main()
    // Imprime el valor del atributo color del objeto Prueba 
    println Prueba.color

    // Asigna un nuevo valor a otro atributo
    Prueba.loquesea = 30
end

Dentro de los métodos de un objeto, no es necesario indicar el nombre del objeto antes del atributo. Si la variable a utilizar no coincide con una variable local, se buscará después como atributo en el propio objeto. Por ejemplo:

object Prueba
    var color = "Rojo"
    var peso = 2
    
    def metodoDePrueba()
        // Dentro del objeto, no es necesario poner delante el nombre del mismo y el punto
        println color
        color = "Azul"
    end
endobject

Ver orden de prioridad de acceso a variables en metodos para más información.

Colecciones en los atributos

Sin embargo, si un atributo se carga con una colección solo durante su definición con var, esta colección será inmutable (al igual que las constantes de usuario), por lo que no se podrán alterar sus elementos (modificarlos, borrarlos o añadir nuevos). Aún así, esto no significa que sea invariable, es decir, podemos asignarle un nuevo valor al atributo en cualquier momento.

El compilador avisará cuando se cree un atributo con una colección inmutable.

A continuación, un ejemplo de un objeto y un atributo con una colección inmutable. En la función main se intenta añadir un nuevo elemento a dicha colección, por lo que provocará un fallo:

object Prueba
    var nomuta = {"esta coleccion", "no", "se puede cambiar"}
endobject

def main()
    // Esto provocará un error
    nomuta.add("nuevo elemento")
end

Además, el compilador mostrará un mensaje de aviso durante la compilación:

* Aviso: Atributo de objeto clase [Prueba.nomuta] se ha inicializado 
con una coleccion que no se podra modificar (inmutable).

Si este no fuera el comportamiento deseado (como normalmente será), la manera de inicializar colecciones en atributos es dejando el atributo sin ningún valor y asignarle la colección más tarde en el método init.

object Prueba
    var simuta
    var otro

    def init()
        otro = #{}
        simuta = {"esta lista", "si",  "se puede cambiar"}
        simuta.add("nuevo elemento")
    end
endobject

Métodos

Los métodos son funciones asociadas a un objeto. Para crear un método, basta con definir una función normalmente dentro del objeto. Para ello, consultar el punto Definicion de funciones y parametros, que es totalmente válido para los métodos, con la excepción de que las funciones especiales que empiezan por # no están permitidas como métodos. El resto es igual:

• Para crear una función: def nombreFuncion.
• Para finalizar el bloque de la función, usar end (opcionalmente).
• Es posible dar más de un nombre a un método, simplemente separándolos por comas def nombre1, nombre2
• Los parámetros de entrada de los métodos van entre paréntesis: def nombreFuncion(parametro1, parametro2)
• Se pueden crear métodos en una sola línea, separando el nombre del método, del código, con dos puntos.
• Dentro del código del método, se pueden definir variables locales con local

Ejemplo de métodos en un objeto. Se puede comprobar que la definición es exactamente igual que las funciones.

object Prueba

    def sinparametros()
        println "Esto es un metodo que no recibe parametros"
    end

    def conparametros(parametro1, parametro2)
        println "Parametros recibidos "+parametro1+" "+parametro2
    end

    def foo,bar()
        local x, y, z
        println "Este es un metodo con dos nombres y algunas variables locales"
    end

    def enlinea() : println "Este es un método en una sola línea"

endobject

Llamadas a métodos

Para llamar a un método de un objeto, tan solo es necesario poner delante el nombre del objeto, seguido de un punto y después el nombre del método a llamar, con los parámetros que debe recibir entre paréntesis. La llamada a métodos se hace exactamente igual que las llamadas a funciones, sin ninguna diferencia.

def main
    Prueba.primero()
    Prueba.primero("Hola", "Adios")
end

object Prueba

    def primero(parametro1, parametro2)
        println "Parametros recibidos "+parametro1+" "+parametro2
    end

endobject

Llamar a métodos desde otros métodos dentro del el mismo objeto

Si llamamos a un método desde otro método dentro del mismo objeto, no es necesario poner delante el nombre del objeto y el punto (solo es necesario indicarlo si llamamos a los métodos desde fuera del objeto, como funciones u otros objetos).

En este ejemplo, la llamada al método segundo desde el método primero no requiere delante el nombre del objeto (aunque si se pusiera no pasaría nada).

def main
    Prueba.primero()
end

object Prueba

    def primero()
        println "Esto es el metodo primero"
        segundo()
    end

    def segundo()
        println "Esto es el metodo segundo"
    end

endobject

Llamar a una función con el mismo nombre de un método (desde un método)

Si el nombre de un método coincide con el nombre de una función, el método tiene preferencia sobre la función solo si se llama desde dentro del propio objeto que contiene el método. Si se quisiera dar prioridad a la función en vez de al método, sería necesario anteponer al método la variable especial #global

def main
    Prueba.primero()
end

object Prueba

    def primero()
        // Equivale a llamar a Prueba.segundo(), ya que los metodos del 
        // objeto Prueba tienen preferencia
        segundo()

        // Forzamos a llamar a la funcion segundo()
        #global.segundo()
    end

    def segundo()
        println "Esto es un metodo"
    end

endobject

def segundo()
    println "Esto es la funcion segundo"
end

El resultado es:

Esto es un metodo
Esto es la funcion segundo

Por supuesto, no es necesario utilizar #global si queremos llamar a una función desde otra función o desde el método de un objeto que no tiene otro método con el mismo nombre.

En este caso, para llamar a la función segundo() desde el objeto Prueba no es necesario utilizar #global

def main
    Prueba.primero()
end

object Prueba

    def primero()
        // Equivale a llamar a #global.segundo(), ya que Prueba.segundo() no existe
        segundo()
    end

endobject

def segundo()
    println "Esto es la funcion segundo"
end