Contenido

Introduccin................................................................................................................................... 1 Los Operadores Aritmticos .......................................................................................................... 2 Los Operadores de Asignacin....................................................................................................... 3 Los Operadores Lgicos ................................................................................................................. 3 Los Operadores Relacionales ..................................................................................................... 3 Operadores booleanos .............................................................................................................. 4 Negacin Lgica (, NOT) ....................................................................................................... 4 Conjuncin Lgica ( , AND) .................................................................................................. 5 Disyuncin Lgica ( , OR) ...................................................................................................... 5 Disyuncin Lgica exclusiva ( , XOR) .................................................................................... 5 Los Operadores Lgicos de Java ............................................................................................ 5 Qu es eso de la evaluacin condicional? ........................................................................... 6 La Precedencia de los Operadores ................................................................................................ 8 El Operador Cast ............................................................................................................................ 9

Introduccin
En nuestro camino para obtener todos los elementos necesarios para ser buenos programadores en Java, debemos a estas alturas formalizar el significado y la precedencia de cada uno de los operadores sobre los tipos de dato primitivos que ya conocemos. Una vez hecho esto, estaremos mucho ms cerca de nuestra meta, que es la de convertirnos en buenos programadores en Java y de paso, aprobar con altas notas este curso.

Pgina 1

Los Operadores Aritmticos

El lenguaje Java soporta varios operadores aritmticos para los nmeros enteros y de punto flotante. Se incluye + (suma), - (resta), * (multiplicacin), / (divisin), y % (mdulo, es decir, resto de una divisin entera). La siguiente tabla muestras estos operadores y su uso: Operador + * / % Uso + op2 - op2 * op2 / op2 % op2 Descripcin Suma op1 y op2 Resta op2 de op1 Multiplica op1 por op2 Divide op1 por op2 Calcula el resto de dividir op1 entre op2

op1 op1 op1 op1 op1

El tipo de los datos devueltos por una operacin aritmtica depende del tipo de sus operandos; si se suman dos enteros, se obtiene un entero como tipo devuelto con el valor de la suma de los dos enteros. Estos operadores se deben utilizar con operandos del mismo tipo, o si no realizar una conversin de tipos de uno de los dos operandos al tipo del otro. El lenguaje Java sobrecarga la definicin del operador + para incluir la concatenacin de cadenas. El siguiente ejemplo utiliza + para concatenar la cadena "Contados ", con el valor de la variable contador y la cadena " caracteres.":
System.out.print("Contados " + contador + " caracteres.");

Esta operacin automticamente convierte el valor de contador a una cadena de caracteres. Existen dos operadores aritmticos que funcionan como atajo de la combinacin de otros: ++ que incrementa su operando en 1, y -- que hace el decremento de su operando en 1. Ambos operadores (++ y --), tienen una versin prefija, y otra posfija. La correcta utilizacin de cada versin es crtica en situaciones donde el valor de la sentencia es utilizado en mitad de un clculo ms complejo, por ejemplo para control de flujos. Las operaciones con ++ y -- son: Operador ++ ++ --Uso op++ ++op op---op Descripcin Incrementa op en 1; se evala al valor anterior al incremento. Incrementa op en 1; se evala al valor posterior al incremento. Decremento de op en 1; se evala al valor anterior al decremento. Decremento de op en 1; se evala al valor posterior al decremento.

Los operadores + y - tienen versiones unarias que realizan las siguientes operaciones: Operador + Uso +op -op Descripcin Convierte op a entero si es un byte, short o char Niega aritmticamente op

Pgina 2

Estos operadores difcilmente los usaremos en este curso; pero es conveniente saber que existen en el lenguaje.

Los Operadores de Asignacin

El operador de asignacin bsico es el =, que se utiliza para asignar un valor de una variable a otra, o asignar un literal a una variable. Por ejemplo:
int contador = 0; //Inicia la variable contador con un valor de 0

Java adems proporciona varios operadores de asignacin que permiten realizar un atajo en la escritura de cdigo. Permiten realizar operaciones aritmticas, lgicas, de bit y de asignacin con un nico operador. Supongamos que necesitamos sumar un nmero a una variable y almacenar el resultado en la misma variable, como a continuacin:
i = i + 2;

Se puede abreviar esta sentencia con el operador de atajo +=, de la siguiente manera:
i += 2;

La siguiente tabla muestra los operadores de atajo de asignacin y sus equivalentes largos: Operador
+= -= *= /= %= &= op1 op1 op1 op1 op1 op1

Uso
+= -= *= /= %= &= op2 op2 op2 op2 op2 op2

Equivalente a
op1 op1 op1 op1 op1 op1 = = = = = = op1 op1 op1 op1 op1 op1 + * / % & op2 op2 op2 op2 op2 op2

Los Operadores Lgicos

Los operadores lgicos son fundamentales en la algoritmia programacin. Gracias a ellos, podemos controlar el flujo de ejecucin de nuestros programas. El saber manejarlos es primordial para escribir algoritmos correctos en cualquier lenguaje de programacin.

Los Operadores Relacionales

Un operador relacional compara dos valores y determina la relacin existente entre ambos. Revisando algunas definiciones matemticas, nos enteramos que los nmeros conforman un conjunto ordenado. Cada uno tiene una posicin relativa. Sabemos que el 2 "es menor que" el 4 y que el 6 "es ms grande que" el 1. Al comparar dos nmeros, realizamos una funcin de relacin. En Java disponemos de los operadores relacionales para verificar si se cumple una relacin. Estas operaciones comparan dos valores numricos y retornan con un valor booleano.

Pgina 3

Los operadores relacionales y su significado se muestran en la tabla presentada a continuacin; Ambos operandos son variables de tipo entero o de punto flotante (byte, short, int, long, float o double). : Operador Forma de Uso en Java A>B A >= B A<B A <= B A == B A != B Expresin Matemtica Equivalente Resultado

> >= < <= == !=

Verdadero si A es mayor que B. Verdadero si A es mayor o igual que B. Verdadero si A es menor que B. Verdadero si A es menor o igual que B. Verdadero si A es igual a B. Verdadero si A es diferente de B.

Veamos un ejemplo en Java sobre el uso de estos operadores.

public class Relaciones { public static void main(String args[]){ int i = -3; byte b = 5; float f = 1e-10f; double d = 3.14; boolean b1 = i > i; boolean b2 = i < b; boolean b3 = b <= f; boolean b4 = f >= d; boolean b5 = d != 0; boolean b6 = 1 == f; System.out.println( System.out.println( System.out.println( System.out.println( System.out.println( System.out.println( i i b f d 1 + + + + + + " " " " " " > " + i + " = " + b1); < " + b + " = " + b2); <= " + f + " = " + b3); >= " + d + " = " + b4); != " + 0 + " = " + b5); == " + f + " = " + b6);

} }

Operadores booleanos
Cuando necesitamos evaluar la condicin de verdad de una o ms expresiones lgicas en una sola sentencia, las podemos unir en una sola construccin del lenguaje. Esto lo podemos llamar azcar sintctico, ya que no aporta mayor poder al lenguaje, pero s nos hace la vida ms fcil. Antes de ver cules son estos operadores hablemos primero de las tablas de verdad lgica para las proposiciones compuestas de negacin, conjuncin y disyuncin. Negacin Lgica (, NOT) El operador de negacin lgica opera sobre un nico valor de verdad (es un operador unario), devolviendo el valor contradictorio de la proposicin considerada. El literal de este operador es !. Veamos su tabla de verdad, que es la ms simple: A true false A false true

Pgina 4

Conjuncin Lgica ( , AND) El operador de conjuncin lgica funciona sobre dos operandos de tipo booleano, devolviendo verdadero si y solo si ambos operandos son verdaderos. Su tabla de verdad es la siguiente: A true
true false false

B true
false true false

true
false false false

Disyuncin Lgica ( , OR) El operador de disyuncin lgica funciona sobre dos operandos de tipo booleano, devolviendo verdadero si alguno de los operandos es verdadero. Su tabla de verdad es la siguiente: A true true false
false

B true false true

false

true true true

false

Disyuncin Lgica exclusiva ( , XOR) El operador disyuncin lgica exclusiva funciona sobre dos operandos de tipo booleano, devolviendo verdadero si y solo si nicamente uno de los operandos es verdadero. Si ambos operandos son verdaderos o ambos son falsos devolver falso. Su tabla de verdad es la siguiente: A
true

B
true false

true false
false

false true
false

true true
false

Con estas tablas sencillas y fciles de recordar podemos hablar ahora de nuestros operadores booleanos en Java. Los Operadores Lgicos de Java La siguiente tabla muestra los literales y el uso de los operadores lgicos de Java: Nombre Operador
AND OR NOT AND OR XOR && || ! & | ^

Utilizacin Resultado
A && B A || B !A A & B A|B A^B Verdadero cuando A y B son verdaderos. Evaluacin condicional. Verdadero cuando A o B son verdaderos. Evaluacin condicional. Verdadero si A es falso. Verdadero cuando A y B son verdaderos. Siempre evala ambos operandos. Verdadero cuando A o B son verdaderos. Siempre evala ambos operandos Verdadero cuando A y B son diferentes.

Pgina 5

Adems Java soporta un operador ternario, el ?:, que se comporta como una versin reducida de la sentencia if-else: expresin ? operacion1 : operacion2; El operador ?: evala la expresin y devuelve (ejecuta) operacin1 si expresin es cierta, o devuelve operacin2 si expresin es falsa. La expresin anterior es equivalente a:
if (expresin){ operacion1; else{ operacion2; }

Qu es eso de la evaluacin condicional? A pesar de tener dos operadores lgicos para AND y para OR, Seguimos teniendo las mismas tablas de verdad y los resultados que arrojan estas operaciones en Java se rigen por ellas. Sin embargo, el comportamiento de Java es distinto si usamos && en vez de & o si usamos || en vez de |. El resultado de la expresin lgica SIEMPRE ser el mismo, pero internamente tienen un comportamiento diferente lo que puede afectar el valor de nuestros operandos si construimos expresiones complicadas que alteran los valores de tales operandos en la expresin. Cuando estamos en presencia de un operador AND u OR con un solo smbolo, siempre se evalan ambos operandos. En cambio para el operador con el smbolo repetido, su evaluacin cambia segn el valor del primer operando. Por ejemplo, tenemos la siguiente operacin:
boolean x = true && false; //evala ambos operandos

El resultado es falso, pero la JVM tiene que evaluar el segundo operando para saberlo. En cambio con la siguiente expresin:
boolean x = false && true; //solo evala el primer operando

La JVM no se molesta en evaluar el ltimo operando, porque la operacin AND es verdadera solamente cuando ambos operandos son verdaderos. En el caso del operador ||, se evala el segundo operando si el primero es falso. Cuando el primero es verdadero, no tiene en cuenta el otro operando: el resultado es verdadero sin importar el valor del segundo operando. Por qu esto es importante? Pensemos en las siguientes expresiones lgicas: boolean b; int a = 3, x = 8; A. b = (++a > (x a) 1) || (++a != 3); B. b = (x < 0) && ((--x a ) >= 3);

Pgina 6

C. b = (++a > (x a) 1) | (++a != 3); D. b = (x < 0) & ((--x a ) >= 3); Para nuestra fortuna en condiciones normales solo nos preguntarn por el valor de b que es un booleano; pero qu tal si alguien en su mente retorcida pregunta por los valores finales de a y de x despus de efectuar la operacin lgica indicada? Nos enfrentamos entonces a un problema que es sencillo pero sumamente engaoso, y no est de ms decir que es una autntica aberracin de la programacin. Note que en cada caso usamos operadores ++ y -prefijos de modo que el valor de b, x y a solo se ve afectado por el uso de AND y OR en sus dos tipos respectivos. Note que a las variables se les hace el incremento o decremento correspondiente y luego se evalan en la expresin. El siguiente programa en Java nos calcula el resultado de b y nos indica en cada caso cul es el valor final de de a y de x:
public class Expresiones{ public static void main (String args[]){ boolean b ; int a = 3, x = 8; System.out.println ("Para cada expresin a=" + a + " y x="+x); b = (++a > (x - a) -1) || (++a != 3); System.out.println ("\n------------\nPUNTO A\n------------"); System.out.println ("b = (++a > (x - a) -1) || (++a != 3);"); System.out.println ("b=" + b + "\na=" + a + "\nx=" + x); a=3; x=8; b = (x < 0) && ((--x - a ) >= 3); System.out.println ("\n------------\nPUNTO B\n------------"); System.out.println ("b = (x < 0) && ((--x - a ) >= 3);"); System.out.println ("b=" + b + "\na=" + a + "\nx=" + x); a=3; x=8; b = (++a > (x - a) -1) | (++a != 3); System.out.println ("\n------------\nPUNTO C\n------------"); System.out.println ("b = (++a > (x - a) -1) | (++a != 3)"); System.out.println ("b=" + b + "\na=" + a + "\nx=" + x); a=3; x=8; b = (x < 0) & ((--x - a ) >= 3); System.out.println ("\n------------\nPUNTO D\n------------"); System.out.println ("b = (x < 0) & ((--x - a ) >= 3"); System.out.println ("b=" + b + "\na=" + a + "\nx=" + x); } }

La salida de este programa es:

Para cada expresin a=3 y x=8

Pgina 7

-----------PUNTO A -----------b = (++a > (x - a) -1) || (++a != 3); b=true a=4 x=8 -----------PUNTO B -----------b = (x < 0) && ((--x - a ) >= 3); b=false a=3 x=8 -----------PUNTO C -----------b = (++a > (x - a) -1) | (++a != 3) b=true a=5 x=8 -----------PUNTO D -----------b = (x < 0) & ((--x - a ) >= 3 b=false a=3 x=7

Note que en los puntos A. y C. el valor de b es true. Y en los puntos B. y D. el valor de b es false. Como ve, el valor de la expresin lgica se mantiene pero los valores finales de a y de x cambian dependiendo de si se usa AND u OR de uno o de dos smbolos. El anterior ejemplo ilustra lo retorcido que puede llegar a ser un lenguaje de programacin si el programador se propone hacer sus programas de esa forma. Como recomendacin no use expresiones como estas en sus expresiones lgicas ya que son fuente de errores y confusiones. Finalmente, si se tienen dudas sobre el orden de evaluacin de los operadores y por qu se obtuvieron estos resultados lea detenidamente la siguiente seccin sobre la precedencia de operadores, y despus revise nuevamente el ejemplo anterior.

La Precedencia de los Operadores

Cuando en una sentencia aparecen varios operadores el compilador deber de elegir en qu orden aplica los operadores. A esto se le llama precedencia. Los operadores con mayor precedencia son evaluados antes que los operadores con una precedencia relativa menor. Cuando en una sentencia aparecen operadores con la misma precedencia: Los operadores de asignacin son evaluados de derecha a izquierda. Los operadores binarios, (menos los de asignacin), son evaluados de izquierda a derecha.

Pgina 8

Se puede indicar explcitamente al compilador de Java cmo se desea que se evale la expresin con parntesis balanceados ( ). Para hacer que el cdigo sea ms fcil de leer y mantener, es preferible ser explcito e indicar con parntesis qu operadores deben ser evaluados primero. Si no se indica explcitamente al compilador el orden en que se quiere que se realicen las operaciones, entonces el compilador decide basndose en la precedencia asignada a los operadores. La siguiente tabla muestra la precedencia asignada a los operadores de Java. Los operadores de la tabla estn listados en orden de precedencia: cuanto ms arriba aparezca un operador, mayor es su precedencia. Los operadores en la misma lnea tienen la misma precedencia:

Tipo de operadores Operadores posfijos Operadores unarios Creacin o conversin Multiplicacin Suma Desplazamiento Relacionales Igualdad AND a nivel de bit OR a nivel de bit XOR a nivel de bit AND lgico OR lgico Condicional Asignacin

Operadores de este tipo [ ] . (parametros) expr++ expr-++expr --expr +expr -expr ~ ! new (tipo) expr * / % + << >> >>> < <= > >= instanceof == != & ^ | && || ?: = += -= *= /= %= &= ^= |= >>= >>>==

Existe una palabra clave llamada instanceof que puede ser interpretada como un operador encargado de comprobar si un objeto es una instancia de una determinada clase, por ejemplo:
String cad = "unTexto"; Bolean resultado = cad instanceof String;

El Operador Cast
Cada vez que realizamos una operacin obtenemos un resultado. Este resultado podr tener un tipo de dato diferente de los operandos. Veamos el siguiente ejemplo: public class CambioTipo { public static void main(String args[]){ byte unByte = 2; byte otroByte = 3; byte result = unByte + otroByte; } } Al compilarlo, Java nos dice lo siguiente:

Pgina 9

----jGRASP exec: javac -g /home/cmartinez/CambioTipo.java CambioTipo.java:5: possible loss of precision found : int required: byte byte result = unByte + otroByte; ^ 1 error ----jGRASP wedge: exit code for process is 1.

El error en la compilacin se debe a que se produjo un cambio de tipo en el resultado: en vez de obtener un byte se obtuvo un int. Este es un cambio de tipo implcito. Si no queremos que quede as, podemos forzar al compilador que nos entregue un byte. Lo haremos de la siguiente forma:
byte result = (byte)(unByte + otroByte);

Aqu estamos realizando un cambio explcito de tipo con un operador cast. Este operador aparece como el nombre del tipo a obtener entre parntesis siempre antepuesto al resultado que se desea modificar. Veamos la siguiente definicin que es un error comn de programacin: float f = 3.14; Sabemos ya que nos dar un error debido a que es un literal double que trata de disfrazarse de float. Si usamos cast lo transformamos en float: float f = (float)3.14; Con esta nueva sentencia el compilador no tendr ningn problema. El operador cast se ocup de convertir un double en un float. Existe un cierto peligro en la utilizacin indiscriminada de este operador. Observemos el siguiente programa: public class Int2Byte { public static void main(String args[]){ int unInt = 5000; byte unByte = (byte)unInt; System.out.println("El resultado es: " + unByte); } } Aqu intentamos meter a forzadamente un valor int cuyo valor es ms grande de lo soportado por un byte. Java ignora este tipo de error y contina como si no hubiese ocurrido nada extrao. Si ejecutamos el programa la salida ser la siguiente: El resultado es: -120 El resultado dista mucho del valor original. El operador cast se comport como una picadora de bits. Si miramos con lupa ambos valores, nos damos cuenta que ocurri:

Pgina 10

00000000000000000001001110001000 : un int de 32bits cuyo valor es 5000 10001000 : un byte de 8bits de valor -120, complemento a 2 Resulta que al aplicar el cast "cortamos" la variable int en los primeros 8 bits que corresponden al tamao de una variable tipo byte.

Pgina 11