¿Qué es una Variable?

Una variable es el nombre dado a una ubicación de memoria. Es la unidad básica de almacenamiento en un
programa. El valor almacenado en una variable se puede cambiar durante la ejecución del programa.

“En Java, todas las variables deben declararse antes de que puedan ser utilizadas.”

¿Cómo declarar variables?

Podemos declarar las variables en Java de la siguiente manera:

 tipo de dato: tipo de datos que se pueden almacenar en

esta variable.
 nombre_variable: nombre dado a la variable.

 valor: es el valor inicial almacenado en la variable.

Ejemplos:

1. float simpleInterest; //Declarando variable float

2. int time = 10, speed = 20; //Declarando e Inicializando la variable integer
3. char var = 'h'; // Declarando e Inicializando la variable character

Por ejemplo, el tipo de dato String se puede especificar para permitir que una variable llamada “mensaje”
contenga texto con esta declaración:

String mensaje;

1. class PrimeraVariable
2. {
3. public static void main ( String[] args ) {
4. String mensaje = "Valor inicial";
5. System.out.println(mensaje);
6. mensaje = "Valor modificado" ;
7. System.out.println(mensaje);
8. }
9. }

Los nombres de variables también deben evitar las palabras clave de Java, ya que tienen un significado
especial en el lenguaje Java.
Tipos de variables

Hay tres tipos de variables en Java:

 Variables locales
 Variables de instancia
 Variables estáticas

3.1. Variables locales

Una variable definida dentro de un bloque, método o constructor se llama variable local.

 Estas variables se crean cuando el bloque ingresado o método se llama y destruye después de salir del
bloque o cuando la llamada regresa del método.
 El alcance de estas variables solo existe dentro del bloque en el que se declara la variable, es decir,
podemos acceder a estas variables solo dentro de ese bloque.

Ejemplo 1:

1. public class StudentDetails

2. {
3. public void StudentAge()
4. { //variable local age
5. int age = 0;
6. age = age + 5;
7. System.out.println("La edad del estudiante es : " + age);
8. }
9.
10. public static void main(String args[])
11. {
12. StudentDetails obj = new StudentDetails();
13. obj.StudentAge();
14. }
15. }

Salida:

La edad del estudiante es : 5

En el programa anterior, la variable age (edad) es una variable local para el método StudentAge(). Si usamos
la variable age fuera del método StudentAge(), el compilador producirá un error como se muestra a
continuación en el programa.

Ejemplo 2:

1. public class StudentDetails

2. {
3. public void StudentAge()
4. { //variable local age
5. int age = 0;
6. age = age + 5;
7. }
8.
9. public static void main(String args[])
10. {
 11. //utilizando la variable local age fuera de su alcance
12. System.out.println("La edad del estudiante es : " + age);
13. }

Salida:

error: cannot find symbol " + age);

3.2. Variables de instancia

Las variables de instancia son variables no estáticas y se declaran en una clase fuera de cualquier método,
constructor o bloque.

 Como las variables de instancia se declaran en una clase, estas variables se crean cuando un objeto de la
clase se crea y se destruye cuando se destruye el objeto.
 A diferencia de las variables locales, podemos usar especificadores de acceso para variables de instancia.
Si no especificamos ningún especificador de acceso, se utilizará el especificador de acceso
predeterminado.

Ejemplo:

1. import java.io.*;
2. class Points
3. {
4. //Estas variables son variables de instancia.
5. //Estas variables están en una clase y no están dentro de ninguna función/método
6. int engPoints;
7. int mathsPoints;
8. int phyPoints;
9. }
10.
11. class PointsDemo
12. {
13. public static void main(String args[])
14. { //primer objeto
15. Points obj1 = new Points();
16. obj1.engPoints = 50;
17. obj1.mathsPoints = 80;
18. obj1.phyPoints = 90;
19.
20. //segundo objeto
21. Points obj2 = new Points();
22. obj2.engPoints = 80;
23. obj2.mathsPoints = 60;
24. obj2.phyPoints = 85;
25.
26. //mostrando puntos para el primer objeto
27. System.out.println("Puntos para el primer objeto:");
28. System.out.println(obj1.engPoints);
29. System.out.println(obj1.mathsPoints);
30. System.out.println(obj1.phyPoints);
31.
32. //mostrando puntos para el segundo objeto
33. System.out.println("Puntos para el segundo objeto:");
34. System.out.println(obj2.engPoints);
35. System.out.println(obj2.mathsPoints);
 36. System.out.println(obj2.phyPoints);
37. }
38. }

Salida:

Puntos para el primer objeto:

50
80
90
Puntos para el segundo objeto:
80
60
85

Como puede ver en el programa anterior, las variables engPoints, mathsPoints, phyPoints; son variables de
instancia. En caso de que tengamos varios objetos como en el programa anterior, cada objeto tendrá sus
propias copias de variables de instancia. Del resultado anterior se desprende que cada objeto tendrá su propia
copia de la variable de instancia.

3.3. Variables estáticas

Las variables estáticas también se conocen como variables de clase.

 Estas variables se declaran de forma similar a las variables de instancia, la diferencia es que las variables
estáticas se declaran utilizando la palabra clave static dentro de una clase fuera de cualquier constructor o
bloque de métodos.
 A diferencia de las variables de instancia, solo podemos tener una copia de una variable estática por
clase, independientemente de cuántos objetos creemos.
 Las variables estáticas se crean al inicio de la ejecución del programa y se destruyen automáticamente
cuando finaliza la ejecución.

Para acceder a variables estáticas, no necesitamos crear ningún objeto de esa clase, simplemente podemos
acceder a la variable como:

nombre_clase.nombre_variable;

Ejemplo:

1. import java.io.*;
2. class Emp {
3.
4. // salario como variable estatica
5. public static double salary;
6. public static String name = "Alex";
7. }
8.
9. public class EmpDemo
10. {
11. public static void main(String args[]) {
12.
13. //acceder a la variable estatica sin objeto
14. Emp.salary = 1000;
15. System.out.println(Emp.name + " tiene un salario promedio de: " + Emp.salary);
16. }
 17.
18. }

Salida:

Alex tiene un salario promedio de: 1000.0

Creando constantes

La palabra clave “final” es un modificador que se puede usar al declarar variables para evitar cualquier
cambio posterior en los valores que inicialmente se les asignaron.

Esto es útil cuando se almacena un valor fijo en un programa para evitar que se altere accidentalmente.

Las variables creadas para almacenar valores fijos de esta manera se conocen como “constantes“, y es
convencional nombrar constantes con todos los caracteres en mayúsculas, para distinguirlas de las
variables regulares. Los programas que intentan cambiar un valor constante no se compilarán, y el compilador
javac generará un mensaje de error.

Ejemplo:

1. class Constants
2. {
3. public static void main ( String[] args ) {
4. //inicializamos tres constantes enteras
5. final int CONSTANTE1 = 6 ;
6. final int CONSTANTE2 = 1 ;
7. final int CONSTANTE3 = 3 ;
8.
9. //declaramos variables regulares del tipo int
10. int td,pat,fg,total;
11.
12. //Inicializamos las variables regulares
13. td = 4*CONSTANTE1;
14. pat = 3*CONSTANTE2;
15. fg = 2*CONSTANTE3;
16.
17. total = (td+pat+fg) ;
18.
19. System.out.println("Resultado: " + total);
20. }
21. }

Nomenclatura de parámetros y variables

Los nombres de parámetros y variables deben ser cortos y describir el propósito del contenido que van a
almacenar. Se utiliza siempre el singular (excepto variables que almacenen un conjunto de elementos) y
normalmente se utilizan sustantivos.

Se deben evitar los nombres de variable de un sólo carácter, excepto variables temporales usadas en bucles
como pueden ser i, j, k, m, y n.

Las variables deben ir en minúsculas, con la primera letra de las palabras en mayúscula exceptuando la
primera. Los nombres de variables no deben empezar con caracteres como subrayado "_" o "$".
permiso;
codigoPostal;

Nomenclaturas de constantes

Las constantes deben nombrarse todas en mayúsculas. Los nombres de variables constantes y las constantes
ANSI deberían escribirse completamente en mayúsculas con las palabras separadas por subrayados (_).

static final INT LONGITUD_MAXIMA = 999;

Nombres de Objetos (notación húngara)

Cada objeto tiene un “name”.

Por defecto, dicho nombre hace referencia al tipo de control, por ejemplo, el primer formulario de una
aplicación tiene por defecto el nombre Form1, el segundo Form2, etc.
Los nombres que aparecen por defecto no son los más adecuados. Hay una convención ampliamente
aceptada (para los programadores de Microsoft es obligatoria), que es la siguiente:
“Se utilizan 3 letras minúsculas que indican el tipo de control, seguidas de otras letras (la primera
mayúscula), que hacen referencia al uso que se va a dar a dicho control”.
Asi:
 cmdBorrar: CommandButton que sirve para “borrar”
 txtSaludo: TextBox que sirve para “saludar”

Algunos de los prefijos más comunes son:

Objeto Prefijo Objeto Prefijo
CommandButton cmd ListBox lst
Form frm Frame fra
Label lbl OptionButton opt
TextBox txt Image img
CheckBox chk Shape shp
ComboBox cbo Line lin
DriveListBox drv Timer tmr
DirListBox dir Menu mnu
HorizontalScrollBar hsb PictureBox pct
FileListBox fil

Eventos
Las acciones del usuario o del sistema sobre nuestro programa se llaman EVENTOS.
Cada vez que se produce un evento sobre un determinado control, se ejecuta un procedimiento
o función que realiza la acción o acciones programadas por el programador para este evento concreto.
Se denominan procedimientos de evento y su nombre, por ejemplo: cmdAceptar_ Click, corresponde a
la acción de hacer clic en el botón cmdAceptar