PDF de programación - Controlar el flujo del programa - Piensa en Java

3: Controlar el flujo

del programa

Al igual que una criatura con sentimientos, un programa debe manipular su mun-
do y tomar decisiones durante su ejecución.

En Java, se manipulan objetos y datos haciendo uso de operadores, y se toman decisiones con la eje-
cución de sentencias de control. Java se derivó de C++, por lo que la mayoría de esas sentencias y
operadores resultarán familiares a los programadores de C y C++. Java también ha añadido algunas
mejoras y simplificaciones.

Si uno se encuentra un poco confuso durante este capítulo, acuda al CD ROM multimedia adjunto
al libro: Thinking in C: Foundations for Java and C++. Contiene conferencias sonoras, diapositivas,
ejercicios y soluciones diseñadas específicamente para ayudarle a adquirir familiaridad con la sinta-
xis de C necesaria para aprender Java.

Utilizar operadores

Java

Un operador toma uno o más parámetros y produce un nuevo valor. Los parámebos se presentan de
distinta manera que en las llamadas ordinarias a métodos, pero el efecto es el mismo. Uno debería es-
tar razonablemente cómodo con el concepto general de operador con su experiencia de programación
previa. La suma (+) , la resta y el menos unario (-) , la multiplicación (*), la división (/), y la asignación
(=) funcionan todos exactamente igual que en el resto de lenguajes de programación.

Todos los operadores producen un valor a partir de sus operandos. Además, un operador puede va-
riar el valor de un operando. A esto se le llama efecto lateral. El uso más común de los operadores
que modifican sus operandos es generar el efecto lateral, pero uno debería tener en cuenta que el
valor producido solamente podrá ser utilizado en operadores sin efectos laterales.

Casi todos los operadores funcionan únicamente con datos primitivos. Las excepciones las constitu-
yen “=" , "==" y "!=", que funcionan con todos los objetos (y son una fuente de confusión para los ob-
jetos). Además, la clase String soporta "+" y "+=".

Precedencia

La precedencia de los operadores define cómo se evalúa una expresión cuando hay varios operado-
res en la misma. Java tiene reglas específicas que determinan el orden de evaluación. La más fácil
de recordar es que la multiplicación y la división siempre se dan tras la suma y la resta. Los pro-
gramadores suelen olvidar el resto de reglas de precedencia a menudo, por lo que se deberían usar
paréntesis para establecer explícitamente el orden de evaluación. Por ejemplo:

80

Piensa en Java

tiene un significado diferente que la misma sentencia con una agrupación particular de paréntesis:

Asignación
La asignación se lleva a cabo con el operador =. Significa "toma el valor de la parte derecha (deno-
minado a menudo dvalor) y cópialo a la parte izquierda (a menudo denominada ivalor"). Un ivalor
es cualquier constante, variable o expresión que pueda producir un valor, pero un ivalor debe ser
una variable única con nombre. (Es decir, debe haber un espacio físico en el que almacenar un va-
lor.) Por ejemplo, es posible asignar un valor constante a una variable (A = 4;), pero no se puede
asignar nada a un valor constante -no puede ser un ivalor. (No se puede decir 4 = A,.)
La asignación de tipos primitivos de datos es bastante sencilla y directa. Dado que el dato primitivo
alberga el valor actual y no una referencia a un objeto, cuando se asignan primitivas se copian los
contenidos de un sitio a otro. Por ejemplo, si se dice A = B para datos primitivos, los contenidos de
B se copian a A. Si después se intenta modificar A, lógicamente B no se verá alterado por esta mo-
dificación. Como programador, esto es lo que debería esperarse en la mayoría de situaciones.

Sin embargo, cuando se asignan objetos, las cosas cambian. Siempre que se manipula un objeto, lo
que se está manipulando es la referencia, por lo que al hacer una asignación "de un objeto a otro"
se está, de hecho, copiando una referencia de un sitio a otro. Esto significa que si se escribe C = D
siendo ambos objetos, se acaba con que tanto C como D apuntan al objeto al que originalmente sólo
apuntaba D. El siguiente ejemplo demuestra esta afirmación.

He aquí el ejemplo:

/ / : c03:Asignacion.java
/ / La asignación con objetos tiene su truco.

class Numero {

int i;

public class Asignacion {

public static void main (String[] args) {

Numero nl = new Numero();
Numero n2 = new Numero ( ) ;
n1.i = 9;
n2.i = 47;
System.out.println("1:nl.i: " + n1.i + ", n2.i: " + n2.i);
nl = n2;
System.out.println("2: n1.i: " t n1.i t ", n2.i: " + n2.i);
n1.i = 27;
System.out .println ("3: nl. i: " + n1.i + ", n2.i: " + n2.i);

3: Controlar el flujo del programa

81

La clase Número es sencilla, y sus dos instancias ( n l y n2) se crean dentro del método main().
Al valor i de cada Número se le asigna un valor distinto, y posteriormente se asigna n 2 a n l , y se
varía n l . En muchos lenguajes de programación se esperaría que n l y n 2 fuesen independientes,
pero dado que se ha asignado una referencia, he aquí la salida que se obtendrá:

Al cambiar el objeto n l parece que se cambia el objeto n 2 también. Esto ocurre porque, tanto n l ,
como n 2 contienen la misma referencia, que apunta al mismo objeto. (La referencia original que es-
taba en n l que apuntaba al objeto que albergaba el valor 9 fue sobreescrita durante la asignación y,
en consecuencia, se perdió; su objeto será eliminado por el recolector de basura.)

A este fenómeno se le suele denominar uso de alias y es una manera fundamental que tiene Java de
trabajar con los objetos. Pero, ¿qué ocurre si uno no desea que se dé dicho uso de alias en este caso?
Uno podría ir más allá con la asignación y decir:

Esto mantiene los dos objetos separados en vez de desechar uno y vincular n l y n 2 al mismo ob-
jeto, pero pronto nos damos cuenta que manipular los campos de dentro de los objetos es compli-
cado y atenta contra los buenos principios de diseño orientado a objetos. Este asunto no es trivial,
por lo que se deja para el Apéndice A, dedicado al uso de alias. Mientras tanto, se debe recordar
que la asignación de objetos puede traer sorpresas.

Uso d e alias durante llamadas a métodos

También puede darse uso de alias cuando se pasa un objeto a un método:

/ / : c03:PasarObjeto.java
/ / Pasar objetos a métodos puede no ser aquello a lo que uno está
/ / acostumbrado.
class Carta {

char c;

1

public class PasarObjecto {
static void f(Carta y) {

'

y . c =

1 .

z ,

1
public static void main (String[] args) {

Carta x = new Carta();
X.C = 'a';
System.out.println("I: x.c: " + x.c);
f (x) ;
System.out.printl("2:x.c: " + x.c);

82

Piensa en Java

En muchos lenguajes de programación el método f( ) parecería estar haciendo una copia de su ar-
gumento Carta y dentro del ámbito del método. Pero una vez más, se está pasando una referencia,
por lo que la línea:

y.c = ' z ' ;

está, de hecho, cambiando el objeto fuera de f( ). La salida tiene el aspecto siguiente:

El uso de alias y su solución son un aspecto complejo, y aunque uno debe esperar al Apéndice A
para tener todas las respuestas, hay que ser consciente de este problema desde este momento, de
forma que podamos estar atentos y no caer en la trampa.

Operadores matemáticos

Los operadores matemáticos básicos son los mismos que los disponibles en la mayoría de lengua-
jes de programación: suma (+), resta (-), división (/), multiplicación (*) y módulo (%, que devuelve
el resto de una división entera). La división entera trunca, en vez de redondear, el resultado.

Java también utiliza una notación abreviada para realizar una operación y llevar a cabo una asigna-
ción simultáneamente. Este conjunto de operaciones se representa mediante un operador seguido
del signo igual, y es consistente con todos los operadores del lenguaje (cuando tenga sentido). Por
ejemplo, para añadir 4 a la variable x y asignar el resultado a x puede usarse: x+=4.

El siguiente ejemplo muestra el uso de los operadores matemáticos:

/ / : c03:OperadoresMatematicos.java
/ / Demuestra los operadores matemáticos
import java.uti1. *;

public class OperadoresMatematicos {

/ / Crear un atajo para ahorrar teclear:
static void visualizar(String S) {

System. out .println (S) ;

1
/ / Atajo para visualizar un string y un entero:
static void p I n t (

i n t . i) {

t

i

S ,

visualizar(s +

" = " + i);

1
/ / Atajo para visualizar una cadena de caracteres y u n float:
static void pFlt (String S, float f) {

visualizar(s +

" =

" + f);

3: Controlar el flujo del programa

83

public static void main(String [ ] args) {

/ / Crear un generador de números aleatorios
/ / El generador se alimentará por defecto de la hora actual:
Random aleatorio = new Random() ;
int i, j, k;
/ / '%' limita el valor a 99:
j = aleatorio. nextInt ( ) % 100;
k = aleatorio.nextInt ( ) %100;
pInt ("jl',j); pñt("k",k);
i = j t k; p ~ n t ( " j + k", i);
i = j - k; pInt("j - k " , i);
i = k / j; pInt("k / j " , i);
i = k *j; pInt("k * j", i);
i = k % j; pInt("k % j", i);
j o-- o- k; p ~ n t ( " j %= k", j) ;
/ / Pruebas de números de coma flotante:
float u,v,w; / / Se aplica también a doubles
v = aleatorio. nextFloat ( ) ;
w = aleatorio. nextFloat ( ) ;
pFlt("v", v); pFlt("w", w);
u = v t w; pFlt("v + w " , u);
U = v - w; pFlt(I1v - w " , u);
U = v * w; pFlt("v * w " , u);
u = v / w; pFlt("v / w", u);
/ / Lo siguiente funciona también para char, byte
/ / short, int, long, y double:
u += v; pFlt("u += v", u);
u -= v; pFlt("u -= v", u) ;
u *= v; pFlt("u