Variables y

Constantes en
Java

Programación
Orientada a
Objetos

1
 Variables y constantes en Java
Uso de Java Java es un lenguaje fuertemente tipado, lo que significa que el almacenado
de datos en el programa debe ser en variables previamente declaradas que
"A pesar de ser deben tener algún tipo de dato asignado. Esto permite al compilador
internamente anticipar el uso que le dará a los datos y reservar lugar en la memoria para
complejo, Java tiene ellos. También le permite al compilador controlar que el uso de los datos es
una sensación de
consistente con los tipos que se han declarado.
simplicidad inicial”
(Beneke, 2015,
Como habíamos mencionado, el estado de un programa está determinado
goo.gl/OKF1oc).
por las variables y constantes dentro del programa. Las variables no solo
nos dan el estado inicial y final del programa, sino que van dando, paso a
paso, los estados intermedios por los que el programa pasa.

En esta lectura veremos los tipos de datos primitivos que representan las
formas más simples de datos, incluidos enteros y caracteres.

Veamos un sencillo ejemplo:

7 es de tipo entero, mientras 7.0 es de tipo punto flotante (lo que
usualmente llamamos números decimales) y 7 es un carácter.

Aunque 7 y 7.0 tienen el mismo valor aritmético, Java no los considera

iguales (desde el punto de vista de la programación), pues tienen diferente
tipo. Por otro lado 7 ya no representa un número, sino el carácter y Java lo
considera una letra y no un número.

Otros identificadores mantienen el mismo valor durante todo el programa

(por ejemplo, un identificador que indique MESESPORAÑO). Este
identificador corresponde a una constante y será declarada de forma
especial.

No parece tener sentido ponerle nombre a las constantes, pues podríamos

escribir el valor de la constante cada vez que aparece en el programa. Sin
embargo, si se le da nombre a las constantes y si por alguna razón
queremos cambiar su valor, solo debemos cambiar una línea de
programación donde se la define y se le asigna el valor de la constante y
luego, compilar el archivo .java para obtener el archivo .class con el valor
cambiado (Programar ya, 2015).

Como mencionamos anteriormente, las variables nos sirven para observar

los distintos estados de un programa. Para declarar una variable de tipo int,
debemos incluir sentencias como los siguientes ejemplos:

 int i; // “i” es usado frecuentemente como un contador;

2
  int j,k; //dos variables en una declaración de tipo de datos int.

Una declaración de tipo de dato que tendrá el identificador le sirve al

compilador para reservar espacio para guardar un valor, en este caso, de
Claridad de código tipo int. Las declaraciones deben aparecer antes de que la variable sea
"La legibilidad es usada por primera vez. En Java, las declaraciones son instrucciones simples
crítica porque, con el
y deben terminar con punto y coma (;).
software, la cantidad
de tiempo que pasas
A una variable se le puede asignar un valor haciendo una asignación. Por
escribiendo un pedazo
ejemplo, la expresión:
de código que entra en
producción es
microscópico
j = 1200
comparado con el
tiempo que tú y tus le asigna a la variable de la izquierda (j) el valor de la derecha (1200). La
sucesores pasarán variable retiene ese valor hasta que se le asigne otro valor y hasta el final
leyéndolo" (Beneke, de la ejecución del programa.
2015,
goo.gl/OKF1oc). Si miramos a = como un operador, este operador devuelve el valor
asignado a la variable y este valor puede ser usado en una expresión más
grande. Por ejemplo,

int miEdad, tuEdad;

tuEdad = (miEdad = 14);

Luego de declararlas como int, le asigna 14 a miEdad y ese contenido lo

asigna a tuEdad. Como se puede observar en la tabla 1, con los operadores
Java, el operador = es asociativo a derecha, con lo cual la asignación
anterior es equivalente a la expresión:

tuEdad = miEdad = 14;

que es la forma que más se utiliza. También se utiliza una tercera variante
equivalente:

miEdad = 14;
tuEdad = miEdad;

3
Tabla 1 : Operadores Java

Operador Significado Asociativo Orden de Tipos

por precedencia aplicables
var++ var- Postincremento/decre - 8 Alfanumérico
- m.
++var --- Preincremento/decrem - 8 Alfanumérico
var .
! NO lógico, negación derecha 7 Booleanos
* / Producto, división y izquierda 6 Alfanumérico
% resto
+ - Suma, resta Izquierda 5 Alfanumérico
< <= > Comparación de orden Izquierda 4 Alfanumérico
>=
== != Pruebas de igualdad Izquierda 3 Todos
&& Y lógico Izquierda 2 Booleanos
|| O lógico izquierda 1 Booleanos
= Asignación Derecha 0 Todos

Fuente: elaboración propia.

El orden de precedencia indica que los valores mas altos corresponden a

los operadores que van a ser evaluados primero, a menos que se indique lo
contrario con el uso de paréntesis. Los tipos alfanuméricos incluyen a int,
long, float, double y char (que es convertido automáticamente en int).

Si una variable es declarada, pero no se le asigna un valor, entonces no

debería ser utilizada. Todas las variables de un programa deben ser
inicializadas asignándoles el valor que se considere más útil. Por ejemplo,
podría ser razonable inicializar con 0 una variable que acumula una suma o
con 1 una variable que acumula productos. Para facilitar estos
procedimientos, Java nos permite inicializar las variables cuando las
declaramos, por ejemplo:

int miEdad = 14

4
 Inicialice las variables antes de usarlas

Java considera las constantes como un tipo especial de variables a las

cuales se les puede asignar un solo valor. Este valor es llamado el valor final
y se indica agregando al comienzo de la declaración el modificador final:
¡Recordar!
Las constantes de Java, final int MAX = 2147483647; // el entero mas grande de Java
según CamelCase, final int SEGUNDOSAÑO = 365*24*60*60 //segundos en un año no bisiesto
deben ir en
mayúsculas. El último ejemplo muestra que en el momento de la asignación podemos
también calcular el valor de la variable o constante.

Tipos de datos primitivos

Java proporciona ocho tipos de datos primitivos, que pueden ser usados
para operaciones básicas.

Tabla 2: Tipos de datos primitivos

Nombre Tipo y tamaño Rango de valores

byte Entero, 1 byte -128 a 127
short Entero, 2 bytes -32768 a 32767
int Entero, 4 bytes -2**31 a (2**31) -1
long Entero, 8 bytes -2**63 a (2**63)-1
float Decimal, 4 bytes Muy grande
double Decimal, 8 bytes Muy grande
Char Carácter simple, 2 0 a 65535
bytes
Boolean Valor lógico true o false

Fuente: elaboración propia.

5
Tipo de datos entero

Ya estamos en condiciones de diseñar programas sencillos que usen

números enteros. Computemos la suma de los primeros cinco números
naturales.

Un entero o int, i, mantiene el valor del número entero que debe ser
acumulado a la suma y otro entero, sum, mantiene los valores intermedios
de la suma.

Archivo CalculoSuma.java
// Calcula la suma de los primeros cinco numeros naturales
public class CalculoSuma {
public static void main(String args[])
{
int suma = 0;
int a = 1;
suma = suma + a; // suma vale 1
a = a+1; // a vale 2
suma = suma + i; // suma vale 3
a = a+1; // ahora a vale 3
suma = suma + a; // suma vale 6
a = a+1; // ahora a vale 4
suma = suma + a; // ahora suma vale 10
a = a+1; // ahora a vale 5
suma = suma + a; // ahora suma vale 15
System.out.println(suma); // muestra el valor de suma
}
}

Es bastante tedioso que para un programa tan sencillo se deba tipear

tanto, más aún cuando repetimos dos instrucciones (i = i + 1 y sum = sum +
i) cinco veces cada una. Veremos más adelante que existen varios métodos
para realizar estas repeticiones en forma concisa (observa que, en realidad,
este problema se resuelve matemáticamente en forma más sencilla: la
suma de los primeros n números naturales es: n(n + 1)/2).

El rango de int es lo suficientemente grande como para abarcar casi todos

los casos que necesitaremos. Sin embargo, de hacer falta, Java provee el
tipo long para números mucho más grandes.

Los enteros de tipo long reciben los valores con una L al final del número,
por ejemplo:

6
final long VELOCIDADLUZ = 300000000L //velocidad de la luz en metros por
segundo

La anterior es una declaración válida. No es conveniente trabajar con long

si no es necesario, puesto que ocupan mucho más lugar en memoria que
los int. Los números de tipo long permiten escribir todos los números
enteros de hasta 18 cifras.

Veamos ahora formas equivalentes de realizar asignaciones. La expresión

sum += i es equivalente a sum = sum + i.

Las expresiones -= i y *=i son expresiones análogas para la resta y el

producto. Finalmente, incrementar o decrecer una variable en uno se
puede escribir como i++ o i--, respectivamente.

Si la variable ocurre en una expresión, entonces esta es cambiada después

de ser usada. En cambio, cuando ponemos ++i o --i, la variable se
incrementa (o la hacemos decrecer) antes de ser usada. Con estas
convenciones, el programa anterior se puede reescribir:

archivo Suma.java
// Calculara la adicion de los primeros cinco números naturales

public class Suma {

public static void main(String args[])
{
int suma = 0;
int i = 1;
suma += i; // la suma vale 1
i++; // i vale 2
suma += i; // la suma vale 3
i++; // i vale 3
suma += i; // la suma vale 6
i++; // i vale 4
suma += i; // la suma vale 10
i++; // i vale 5
suma += i; // suma vale 15
System.out.println(sum);
}
}

7
Tipo de datos numéricos de punto flotante

Los números de punto flotante son aquellos que escribimos con decimales.
Aunque nosotros estamos acostumbrados a escribir los decimales después
de una coma, Java usa la convención de escribir los decimales después de
un punto (.). Por ejemplo, nosotros diríamos tres coma veinticinco; en Java
lo escribimos 3.25. Una notación muy usada para escribir números muy
grandes o muy pequeños es la notación científica: los números son
expresados de la forma a × 10n donde a es un decimal y n es un número
entero. Por ejemplo, la luz viaja en el vacío a una velocidad aproximada de
3,00 × 108 metros por segundo. Podemos escribir el número
12/10000000000 como 1,20 × 10−9.

La notación en Java para la cantidad de días que tarda la Tierra en dar una
vuelta alrededor del Sol es 365.2422 o 3.652422E2.

Java provee dos tipos para números decimales, el tipo float y el tipo
double. El tipo float tiene un rango que va desde −3,4028 × 1038 a 3,4028 ×
1038, mientras que en los de tipo doublé, el rango va desde −1,7977 ×
10308 a 1,7977 × 10308. Los números de tipo float permiten escribir
decimales con hasta 45 decimales (y algunos más). Los números de tipo
float deben tener una f o F al final. Los números de tipo double pueden
tener (es optativa) una d o D al final. Veamos algunos ejemplos de
declaraciones de este tipo de números en Java:

float velocidad = 3E8F // velocidad de la luz

float velocidad = 3E+8F // velocidad de la luz

float nanoseg = 0.000000001F o float nanoseg = 1.00E-9F

// 1/1000000000 partes de un segundo

double pi = 3.14159265358979323E0D
double DIASDELAÑO = 3.652422e+2

Por supuesto que en estos casos también contamos con los operadores
numéricos habituales: +, -, *, / (aquí / produce el cociente exacto).

Por supuesto que también podemos manejar números enteros dentro de

los tipos float o double, pero si estamos en esta situación y queremos
trabajar dentro del tipo int, Java nos provee un método llamado moldeado
o casting en inglés, para poder realizar esto. El casting permite convertir un
tipo en otro, su sintaxis general es:

8
( <tipo> ) <valor>

Los paréntesis angulosos se usan para remarcar un componente lógico y no

se usan en la declaración real. A continuación, se presenta una sucesión de
castings:

double r = 3.0E+2; // el valor de r (300) es declarado double float p;

int q;
q = (int)r; // es sin pérdida de información
p = (float)r; // r no es grande, luego no se pierde información

Java también hace moldeado automático, por ejemplo, si 3 es de tipo int y

hacemos 3 + 5.5, entonces el compilador convierte 3 a tipo double y realiza
la suma. Sin embargo, aunque la suma 3.5 + 5.5 de entera, Java no hace, en
este caso, moldeado automático.

Tipo de datos de caracteres.

Los tipos de dato char nos permiten representar los caracteres simples. Los
valores a, B, 3 y & son todos caracteres válidos. Los valores de los
caracteres siempre aparecerán entre los símbolos y. Luego, a se refiere a
un carácter, mientras que a se podría referir a una constante o una
variable.

El siguiente bloque de programa Java

har grade;
grade = ’A’;
System.out.println( grade );

imprimirá

Los caracteres simples no son en realidad demasiado útiles por sí mismos.

Las que son más útiles son las palabras o cadenas de caracteres. Veremos
esa clase de expresiones que serán de tipo string. Quizás lo más
interesante del tipo char es que es casi un sinónimo del tipo int. A cada
carácter se le asigna un entero, el 97 a la a, el 98 a la b y así sucesivamente
hasta la z. Luego seguimos con las mayúsculas en el orden alfabético. Todas
las operaciones que hemos definido para enteros también valen para el
tipo char. El fragmento de programa:

9
char firstLetter = ’a’;
System.out.println((int)firstLetter);
System.out.println(firstLetter);

genera como salida:

97
a

Este sencillo programa muestra que a es representado en la computadora

por el número 97.

Observemos que si queremos escribir con caracteres la palabra no,

debemos poner las instrucciones

System.out.print(’n’);
System.out.print(’o’);

Tipo de datos boolean

Hay veces en que es necesario, dentro de un programa de computación,

tomar una decisión. Estas decisiones dependen, por supuesto, del estado
de las variables en ese momento. Los lenguajes de alto nivel como Java
permiten hacer preguntas sobre los estados (variables) y obtener como
respuesta un verdadero o falso (true o false, respectivamente). Un caso
típico es cuando queremos repetir un bloque de instrucciones cierta
cantidad de veces, digamos, por ejemplo, cincuenta veces.

Cada vez que el programa termina de ejecutar el bloque, debe preguntar si

ya ha hecho la repetición cincuenta veces, y en base a la respuesta, tomar
la acción adecuada. Para lograr lo anterior, usualmente se define una
variable, digamos cuenta, que se inicializa en 1 y luego se ejecuta el bloque
repetidas veces. Cada vez que se termina de ejecutar el bloque, el
programa pregunta si cuenta < 50, si es así (es decir si el programa
devuelve true), se le suma uno a cuenta (cuenta = cuenta + 1) y se ejecuta
el bloque de nuevo. Cuando cuenta < 50 es false, el programa continúa con
las instrucciones que siguen al bloque.

Todos los tipos de datos primitivos Java pueden ser comparados usando el
test de igualdad (==) o el de desigualdad (!=). Los tipos numéricos o el tipo
carácter tiene un orden y pueden ser comparados usando relaciones de
orden: < (menor que), <= (menor igual que), > (mayor que), >= (mayor igual
que). Todas las condiciones anteriores devuelven true cuando el test se
verifica, y devuelven false en caso de que no se verifique. Una expresión

10
booleana es una expresión para la cual tiene sentido preguntar si es
verdadera o falsa (por ejemplo, contar < 50). Para declarar expresiones
booleanas, usamos la palabra reservada boolean. El operador unario !
invierte el valor de la expresión booleana, es decir !true es false y
viceversa.

Tabla 3: Resultado de las operaciones logicas con dos variables Boolean P

yQ

P Q !P P==Q P!=Q P||Q P&&Q

true true False true False true true

true false false false True true false

false true false false True true false

false false false true False false false

Fuente: elaboración propia.

Dadas las declaraciones

boolean result;
int a, b;

cada una de las siguientes expresiones booleanas hacen que result sea true

// las siguientes son verdaderas:

result = 42 == (41+1); // mismo valor: 42
result = 42 >= 42; // 42 y 42 son iguales
result = ’A’ < ’B’; // ’B’ esta después en el alfabeto
result = ’A’ == 65; // en ASCII el codigo de ’A’ es 65
result = Math.sqrt(4.0) == 2.0;
result = ((a/b)*b + (a%b)) == a;// siempre verdadero
result = a == a; // cualquier valor es igual a si mismo
result = (a != a) == false;
result = !false;
result = true == true; // true es igual a true

mientras que las siguientes hacen que result sea false

// las siguientes son falsas:

result = 42 != 42;
result = !(42 == 42);

11
result = ’a’ == ’A’; //minúscula y mayúscula son
//diferentes
result = !true;
result = true == false;

Hay una serie de operaciones que combinan expresiones booleanas para

obtener otras más complejas:

|| (o lógico) y && (y lógico). Estos operadores toman dos valores

booleanos y nos devuelven otro. El operador o devuelve true si alguna de
las dos expresiones es true. El operador y devuelve true solo si las dos
expresiones son true. Podemos ver, por ejemplo, si un valor se encuentre
entre 100 y 200, combinado dos test:

boolean entre = (100 < a) && (a < 200);

El resultado es true cuando a es más grande que 100 y más pequeño que
200. Podemos hacer una expresión cuyo valor es false de la siguiente
manera:

result = (100 > a) && (a > 200);

Esto no es posible, pues ningún valor puede ser menor que 100 y mayor
que 200. Una expresión que siempre es falsa es llamada una falacia. Una
expresión que siempre es verdadera es llamada una tautología.

La siguiente expresión es una tautología:

result = (100 < a) || (a < 200);

Esta expresión siempre es verdadera, pues cualquier entero es mayor que

100 o menor que 200. Debemos evitar incluir tautologías o falacias en los
programas, es mejor asignar el valor (true o false) directamente.

Un error muy común es tratar de escribir expresiones lógicas usando

abreviaturas de las expresiones matemáticas. Por ejemplo,

entre = 100 < a < 200; // queremos ver si 100 < a y a < 200

El compilador interpreta esta instrucción como

entre = ((100 < a) < 200);

La primera comparación genera un boolean, por lo tanto, la segunda

comparación no tiene sentido.

12
La forma correcta de escribir esto es la que fue explicada anteriormente.

Al escribir expresiones lógicas complicadas, debemos asegurarnos de

representar lo que queremos decir. Es bueno seguir el siguiente principio:

Use paréntesis para hacer explícito el orden de evaluación.

A menudo, una expresión booleana larga puede ser simplificada con poco
trabajo. Por ejemplo, es importante tener en cuenta que como true es el
elemento neutro del test de igualdad, una expresión del tipo a == true, se
puede reemplazar por a. Por otro lado, la expresión a == false, se puede
reemplazar por !a.

Conclusión:

En esta lectura estudiamos diferentes tipos de datos primitivos: enteros,

punto flotante, caracteres y booleanos.

Toda variable en Java está asociada a un tipo. Esta asociación es llamada

una declaración y ayuda al compilador a determinar el uso correcto de la
variable en el programa.

Los tipos de datos primitivos tienen un rango de valores predeterminado.

Cualquier intento de asignarle a una variable un valor fuera del rango
producirá un error de compilación.

Tipos diferentes tienen operaciones diferentes. Algunos operadores tienen

diferente significado cuando se aplican a variables de diferentes tipos. Por
ejemplo, / realiza la división entera en int o long y realiza la división exacta
en float o double.

Valores primitivos de un tipo se convierten automáticamente (si fuera

necesario) a un tipo de mayor precisión. Por ejemplo, una operación entre
un int y un double hace que el valor int se convierta a double y después se
realice la operación, dando por resultado un double. También, podemos
convertir datos de un tipo en otro usando casting.

13
Referencias
Beneke, T. (2015). A conversation with Mark Reinhold. Recuperado de
https://community.oracle.com/docs/DOC-921872

Programar ya. (2015). “Declaración y uso de constantes en Java. Uso del

final en Java, datos final”. Recuperado de http://goo.gl/guJouk

14