Modificadores de visibilidad

En este post veremos los distintos tipos de visibilidad que podemos usar para las clases, variables y métodos explicaremos que modificadores aplican a cada uno y sus diferencias, como primer paso comenzaremos nombrando cuales están presente en JavaFX.

Modificadores:

• Default Access

• The package Access Modifier

• The protected Access Modifier

• The public Access Modifier

• The public-read Access Modifier

• The public-init Access Modifier

Default Access
Este modificador es uno que sin saberlo lo usamos en todos los ejemplos anteriores e hicimos mención a él cuando dijimos que se lo conoce como el modificador "script-only", esto quiere decir que cualquier clase, variable o función que no le definamos una visibilidad por defecto podrá ser vista desde cualquier parte del mismo script y de ningún otro lado

The Package Access Modifier
El modificador por package nos permite definir visibilidad de paquete en clases, variables o funciones , ósea nosotros podríamos tener dos archivos .fx los cuales estén el mismo paquete así que podríamos usar las cosas de uno en el otro siempre y cuando hayamos definido su visibilidad en package

Ejemplo:

script1.fx

// Aquí definimos el paquete de este script
package tutorial;

// Definimos la var message con visibilidad de paquete
package var message = "Hello from script1.fx!";

// Definimos la función también con visibilidad de paquete
package function printMessage() {
     println("{message} (in function printMessage)");
}

script2.fx

// Aquí definimos el paquete de este script
package tutorial;

// acedemos a la var message del script1
println(script1.message);

// Llamamos a la función del script1
script1.printMessage();

En el ejemplo se ve como desde un script podemos acceder a las variables o funciones de otro script si están definidos en el mismo paquete y si esas variables o funciones tienen definida una visibilidad de paquete.

The Protected Access Modifier
Con este modificador podremos definir visibilidad en variables y funciones entre el mismo paquete y entre subclases.

Ejemplo:

one.fx

// Aquí definimos el paquete de este script
package tutorial;

public class one {
protected var message = "Hello!";
}

two.fx

style="font-size:100%;">// Importamos el script one
import tutorial.one;

// Como two hereda de one y message esta
// definida como protected puede hacer a su valor
class two extends one {
function printMessage() {
println("Class two says {message}");
}
};
var t = two{};
t.printMessage();

The public Access Modifier
Al usar este modificador estamos dando la posibilidad de acceder ya sea desde cualquier clase o paquete a las clases, variables y funciones que hayan sido expuestas como públicas.
Ejemplo:

One.fx

package tutorial;
public def someMessage = "This is a public script variable, in one.fx";
public class one {
     public var message = "Hello from class one!";
     public function printMessage() {
         println("{message} (in function printMessage)");
}
}

Two.fx

import tutorial.one;
println(one.someMessage);
var o = one{};
println(o.message);
o.printMessage();

The public-read Access Modifier
Bueno los dos últimos modificadores son los más complicados a mi parecer así que prestemos atención como funciona.
Public read nos da la posibilidad que a las variables les digamos que son de solo lectura desde cualquier lado pero funciona para la escritura desde el mismo paquete, pero acá es donde está la trampa nosotros también podríamos definir que sea de solo lectura pública y definir otro scope para la escritura, esto lo logramos de tres maneras.

// Aquí estamos en el caso donde la variable
// es de solo lectura, excepto en el mismo script
public-read var example1 = 'Test';

// Aquí estamos en el caso donde la variable
// es de solo lectura, excepto para los script del mismo paquete
package public-read var example2 = 'Test';

// Aquí estamos en el caso donde la variable
// es de solo lectura, excepto para los script
// del mismo paquete o de subclases
protected public-read var example3 = 'Test';

Me parece que viendo las tres variantes de arriba nos debería quedar una idea clara de cómo funciona este modificador pero si surge alguna duda, no duden en comentar.

The public-init Access Modifier
Este es muy parecido al modificador anterior con la diferencia que este lo usamos para definir donde podemos iniciar nuestra variable.

Ejemplo

Two.fx

import tutorial.one;
var o = one {
     message: "Initialized this variable from a different package!"
}

// No compila, ya que no se definió su escritura
// así que por defecto es el mismo script
o.message = "Changing the message...";
println(o.message);

Bueno con esto hemos echado un vistazo a cada uno, en esta parte no dimos una gran explicación teórica porque creo que los ejemplos reflejan bien los conceptos y además no hay mucho más que decir acerca de estos modificadores.

En el próximo post nos concentraremos en los operadores del lenguaje veremos que son muy similares a Java, pero conviene explicarlo aunque sea brevemente y marcar las diferencias.

Saludos