Variables y Constantes en Java PDF

Preview

Summary

Download Variables y Constantes en Java PDF

Description

Variables y Constantes en Java

Programación Orientada a Objetos

Variables y constantes en Java Uso de Java "A pesar de ser internamente complejo, Java tiene una sensación de simplicidad inicial” (Beneke, 2015,

goo.gl/OKF1oc).

Java es un lenguaje fuertemente tipado, lo que significa que el almacenado de datos en el programa debe ser en variables previamente declaradas que deben tener algún tipo de dato asignado. Esto permite al compilador anticipar el uso que le dará a los datos y reservar lugar en la memoria para ellos. También le permite al compilador controlar que el uso de los datos es consistente con los tipos que se han declarado. Como habíamos mencionado, el estado de un programa está determinado 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



Claridad de código "La legibilidad es crítica porque, con el software, la cantidad de tiempo que pasas escribiendo un pedazo de código que entra en producción es microscópico comparado con el tiempo que tú y tus sucesores pasarán leyéndolo" (Beneke, 2015,

goo.gl/OKF1oc).

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 tipo int. Las declaraciones deben aparecer antes de que la variable sea usada por primera vez. En Java, las declaraciones son instrucciones simples y deben terminar con punto y coma (;). A una variable se le puede asignar un valor haciendo una asignación. Por ejemplo, la expresión: j = 1200 le asigna a la variable de la izquierda (j) el valor de la derecha (1200). La variable retiene ese valor hasta que se le asigne otro valor y hasta el final de la ejecución del programa. 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 por

Orden de precedencia

Tipos aplicables

var++ var-

Postincremento/decre m.

-

8

Alfanumérico

++var --var

Preincremento/decrem .

-

8

Alfanumérico

!

NO lógico, negación

derecha

7

Booleanos

* / %

Producto, división y resto

izquierda

6

Alfanumérico

+ -

Suma, resta

Izquierda

5

Alfanumérico

< >=

Comparación de orden

Izquierda

4

Alfanumérico

== !=

Pruebas de igualdad

Izquierda

3

Todos

&& ||

Y lógico O lógico

Izquierda izquierda

2 1

Booleanos 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, según CamelCase, deben ir en mayúsculas.

final int MAX = 2147483647; // el entero mas grande de Java final int SEGUNDOSAÑO = 365*24*60*60 //segundos en un año no bisiesto 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 bytes

0 a 65535

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

( ) 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á A

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), (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 a...