Buenos días, hoy empezamos con el Capitulo 5 en el cual estudiaremos lo relacionado con el ámbito de variables y la construcción de clases. El objetivo es que aprendamos a determinar el ámbito correcto de la variable usada en el algoritmo y desarrollar el código que declara estas variables en cualquiera de los siguientes ámbitos: Variables de Instancia (Instance Variables, Parámetros de los métodos (Method parameters) y variables locales (local variables).
En el último capítulo vimos qué era una variable y como se declaraba para guardar diferentes valores. En esta sección veremos la manera en la que las variables están organizadas en el código
Como podemos imaginar una aplicación no trivial tendrá un número incontable de de ellas. Si todas las variables pudieran ser accedidas desde cualquier lugar del código, será dificil encontrar nombres únicos que conllevean a algún significado.
Para solventar este problema, Java tiene ámbito de variables. Esto se refiere a la sección de código que tiene aceso a esa variable declarada. El ámbito puede ser tan pequeño como unas pocas lineas, o puede incluir la clase entera.
En esta sección cubriremos los siguientes puntos:
- Local Variables
- Method Parameters
- Instance variables
Local Variables
El primer ámbto que discutiremos será el ámbito local de una variable. Las variables locales son aquellas que se declaran dentro de los métodos. Como el nombre implica, son usados de manera local en el código. Son comúnmente declaradas al principio del método y en bucles pero pueden ser declarados en cualquier lugar del código. Una variable local puede ser una variable temporal que es usada solo una vez, o una que es usada a través del método. El bloque de código donde la variable es declarada determina el ámbito de esta. Un bloque de código está determinado por llaves { y }. Por ejemplo si la variable es declarada al principio del método despues de la llave izquierda, el ámbito de esta variable terminará cuando termine el método con la llave derecha }. Una vez que se sale de ese lugar, la variable no puede ser usada y su valor se pierde. Un bloque de código puede ser creado en cualquier lugar, incluso dentro de otros bloques. los bloques mas comunes son los if y los bucles for y while.
El siguiente ejemplo demuestra el uso de variables locales dentro de bloques de código:
void sampleMethod(){ //Empieza el bloque de código A
int totalCount = 0;
for (int i=0;i<3;i++){ //Empieza el bloque de código B
int forCount=0;
totalCount++;
forCount++;
{ //Empieza el bloque de código C
int block1Count=0;
totalCount++;
forCount++;
block1Count++;
} //Termina el bloque de código C
{ //Empieza el bloque de código D
int block2Count=0;
totalCount++;
forCount++;
block2Count++;
} //Termina el bloque de código D
//Estas 2 variables no tienen ninguna relación con las anteriores aun
//teniendo el mismo nombre
int block1Count;
int block2Count;
} //Termina el bloque de código B
} //Termina el bloque de cósigo A
El bloque de código A es el método. Cualquier variable que sea declarada en este bloque podrá ser usada en todo el método. La variable totalCount está declarada en el bloque A, y puede ser accedida desde cualquier lugar del método.
El bloque de código B empieza en el bucle for. La variable i es declarada en este bloque. Aunque no esté entre las llaves, como ah sido declarada en la declaración del bucle, se considera parte del bloque B. La variable forCount está tambien declarada en el bloque B. Desde que han sido declaradas, su ámbito se reduce al bloque B y los bloques que estén dentro del bloque B. Están fuera del ámbito para el bloque A y el comilador dará error si se intenta acceder a ella desde algún lugar que sea fuera del bucle For.
El bloque B contiene al bloque C. Este bloque se empieza arbitrariamente. En java, esto es válido pero en la práctica no se suele usar. La variable block1Count es declarada en este bloque y solo puede ser usada en él, sin embargo las variables declaradas en el bloque A y B pueden usarse en el bloque C.
El bloque D contiene la variable block2Cou. El ámbito de esta variable es soloe ste bloque. Como pasa en el bloque C, el bloque D puede tener acceso a las variables del bloque A y B. Al finalizar el bloque D se declaran 2 nuevas variables en el bloque B, llamadas block1Count y block2Count. estas variables a pesar de tener el mismo nombre que las declaradas anteriormente en el bloque C y D, no tienen nada que ver con ellas.
|
|---|
Recordemos que una variable local es usada cuando un dato solo encesita ser accedido en una parte determinada, o loca, en el código. No es buena práctica usar variables con un ámbito mayor del que se va a necesitar, ya que puede originar un código dificil de mantener. Por ejemplo una variable usada como un contador debería ser una variable local.
Method Parameter
Los parámetros en los métodos son las variables que se han pasado al método en la llamada en un segmento de código. Son pasados como argumentos del método. Pueden ser objetos o variables de tipo primitive. SUn método puede tener tantos parámetros como el desarrollador defina. El ámbito de estas variables es el método. El siguiente ejemplo tiene 2 parámetros:
float findMilesPerHour (float milesTraveled, float hoursTraveled)
{
returns milesTraveled / hoursTraveled;
}
En este ejemplo, milesTraveled y hoursTraveled son parámetros del método. SOn declarados en la declaración del método. En este ejemplo están declaradas como floats. Cuando este método sea llamado, se deben pasar 2 variables de tipo float como argumentos.
Instance Variables
Son las variables que se declaran en la clase. Son llamadas variables de instancia o instance variables porque son creadas y permanecerán en memoria tanto tiempo como dure la instancia de la clase. Estas variables almacenan el estado del Objeto. Su ámbito ocupa toda la clase entera. Estos valores existen y conservan su valor desde que la clase es inicializada hasta que la clase es reinicializada o no se hace referencia a ella mas.
El siguiente ejemplo muestra 2 variables de instancia:
public class Television {
int channel = 0;
boolean on = false;
void setChannel(int channelValue){
this.channel = channelValue;
}
int getChannel(){
return this.channel;
}
void setOn (boolean on){
this.on = on;
}
boolean isOn(){
return this.on;
}
}
En este ejemplo, channel es declarada como un int, y on es declarada como un boolean. Ambas son variables de instancia. Es importante entender que las variables de instancia o instance variables deben ser declaradas en la clase, no en un método. Los cuatro métodos en la clase acceden a estas variables.
El método setChannel se usa para asignarle un valor a la variable channel con el valor del int pasado como argumento. Los métodos getChannel y isOn retornan los valores almacenados en las 2 instance variables respectivamente. Se puede ver que el método setOn tiene un parámetros con el mismo nombre que una instance variable. Esto es válido, para hacer referencia a la variable de instancia, se usa la keyword this. El siguiente código muestra la clase Televisión en uso:
Television tv1 = new Television(); Television tv2 = new Television(); tv1.setChannel(2); tv2.setChannel(7); System.out.println("Television channel for tv1: " + tv1.getChannel()); System.out.println("Television channel for tv2: " + tv2.getChannel());
Las primeras 2 lineas crean 2 instancias únicas de la calse Television. Cuando la instancia de la clase es creada, cada objeto tiene una variable de instancia que almacenará un canal. Las siguientes 2 lineas usa el método setChannel para asignar el canal 2 a tv1 y canal 7 a la tv2. Las últimas 2 lineas, nos muestran el valor channel para cada television.
Hasta aquí el ámbito de variables, en la próxima parte veremos como crear métodos para las clases, donde veremos un poco mas a fondo el tipo de paso de valores que existen dependiendo del tipo de dato que se pase como argumento.
Como siempre digo, cualquier corrección o aporte será bienvenido.
Saludos!!!