Anda di halaman 1dari 31

2

Tipos de datos
operadores
Conceptos fundamentales:
Tipos primitivos de Java.
Usar literales.
Conocer las reglas de mbito de las variables de un mtodo.
Usar los operadores aritmticos, relacionales y lgicos.
Comprender los operadores de asignacin.
Usar asignaciones abreviadas.
Conversin de tipos en asignaciones.
Convertir tipos incompatibles.
Conversin de tipos en expresiones.
En la base de todo lenguaje de programacin se encuentran sus tipos de datos y
operadores, como sucede en Java. Estos elementos definen los lmites del lenguaje y
determinan las tareas a las que se puede aplicar. Afortunadamente, Java admite una
amplia variedad de tipos de datos y operadores, por lo que resulta apropiado para todo
tipo de programacin.
Los tipos de datos y operadores son un tema amplio. Comenzaremos con el examen
de los tipos de datos bsicos de Java y de los operadores ms utilizados. Tambin nos
detendremos en las variables y expresiones.
&1 2. Tipos de datos y operadores
Importancia de los tipos de datos
Los tipos de datos son especialmente importantes en Java por tratarse de un lenguaje
de tipos fuertes. Es decir, el compilador comprueba la compatibilidad de los tipos en
todas las operaciones. Las operaciones incompatibles no se compilan. Por tanto, se evitan
errores y se mejora la fiabilidad. Para realizar la comprobacin de tipos, todas las varia-
bles, expresiones y valores tienen un tipo. No existe el concepto de variable sin tipo, por
ejemplo. Es ms, el tipo de un valor determina qu operaciones realizar con el mismo.
Una operacin permitida en un tipo puede no estarlo en otro.
Tipos primitivos de Java
Java contiene dos categoras generales de tipos integrados: orientados a objetos y no
orientados a objetos. Los tipos orientados a objetos se definen en clases, corno veremos
ms adelante. No obstante, en el corazn de Java encontrarnos ocho tipos de datos
primitivos (tambin denominados elementales o simples), mostrados en la tabla 2.1.
El trmino primitivo se usa para indicar que estos tipos no son objetos en un sentido
orientado a objetos, sino valores binarios estndar. Estos tipos primitivos no son objetos
debido a problemas de eficacia. Los dems tipos de datos de Java se crean a partir de
los primitivos.
Tipo
boolean
byte
char
double
float
int
long
short
Tabla 2.1. Tipos de datos primitivos de Java.
Slgnlftcado
Representa valores true/ false.
Entero de 8 bits.
Carcter.
Coma flotante de precisin doble.
Coma flotante de precisin simple.
Entero.
Entero largo.
Entero breve.
Java especifica un intervalo y un comportamiento para cada tipo primitivo, que todas
las implementaciones de la MVJ deben admitir. Debido al requisito de portabilidad de
Java, el lenguaje no se compromete en este aspecto. Por ejemplo, int es el mismo en
todos los entornos de ejecucin, lo que facilita la portabilidad de los programas. No es
necesario cambiar el cdigo para adecuarlo a una plataforma concreta. Aunque la espe-
cificacin estricta del intervalo de los tipos primitivo puede reducir ligeramente el rendi-
miento en algunos entornos, es necesaria para lograr la portabilidad.
] aval SjM
Enteros
Java define cuatro tipos enteros: byte, shor t , i nt y lon g, como se indica a conti-
nuacin.
Tabla 2.2. Tipos enteros de Java.
byte 8
16
32
64
-128 a 127
short -32.768 a 32.767
int -2.147.483.648 a 2.147.483.647
long -9.223.372.036.854. 775.808 a 9.223.372.036.854. 775.807
En la tabla, todos los tipos enteros son valores positivos y negativos con signo. Java
no admite enteros sin signo (slo positivos). Otros lenguajes informticos admiten ambos
formatos. Sin embargo, los diseadores de Java consideraron que los enteros sin signo
no eran necesarios.
Tcnicamente, el sistema de tiempo de ejecucin de Java puede usar cualquier tamao
para almacenar un tipo primitivo. Sin embargo, en todos los casos, los tipos deben
actuar de acuerdo a su especificacin.
El tipo entero ms usado es int. Las variables de tipo int se suelen usar para controlar
bucles, indexar matrices y realizar operaciones matemticas enteras generales.
Si necesita un entero con un intervalo mayor que el de int, use long. Por ejemplo, el
siguiente programa calcula el nmero de pulgadas cuadradas de un cubo de una milla
por una milla:
/*
*/
Calcular el nmero de pulgadas cbicas
en una milla cbica .
class Inches {
public static void main(String args[]) {
long ci;
long im;
im = 5280 * 12;
ci = im * im * im;
i:M 2. Tipos de datos y operadores
System. out . println (" There are " + ci +
" cubi c i nches in cubi c mile ." ) ;
Este programa genera el siguiente resultado:
There are 254358061056000 cubi c inches in cubic mile .
Evidentemente, el resultado no se puede guardar en una variable int.
El tipo entero ms pequeo es byte. Las variables de tipo byte son especialmente
tiles para trabajar con datos binarios sin procesar que pueden no ser compatibles direc-
tamente con los tipos de Java. El tipo short crea un entero breve. Las variables de tipo
short sirven cuando no es necesario el intervalo que ofrece int.
Preguntas al experto
P: Anteriormente se afirm que hay cuatro tipos enteros: int, short, byte y l ong.
Pero he odo que c har tambin se puede categorizar como tipo entero en Java. Es
cierto?
R: La especificacin formal de Java define una categora denominada tipos integrales
que incluye byte , short, int, l ong y c har. Se denominan integrales ya que
contienen nmeros enteros y valores binarios. No obstante, el objetivo de esta
presentacin es representar cantidades enteras numricas. char representa carac-
teres. Por tanto, los usos principales de char y de los dems tipos integrales son
diferentes y, debido a estas diferencias, char se describe de forma independiente
en el libro.
Tipos de coma flotante
Como vimos en el captulo anterior, los tipos de coma flotante pueden representar
nmeros con componentes fraccionales. Hay dos: fl o at y double, que representan
nmeros de precisin simple y doble, respectivamente. El tipo fl oa t es de 32 bits y
double es de 64 bits.
De los dos, double es el ms usado ya que todas las funciones matemticas de la
biblioteca de clases de Java usan valores double. Por ejemplo, el mtodo sqrt () (defi-
nido en la clase estndar Math) devuelve un valor d o ubl e que es la raz cuadrada de
su argumento d o uble. En el siguiente ejemplo, se usa sqrt () para calcular la longitud
de la hipotenusa, dada la longitud de los dos lados opuestos:
/*
Usar el t e orema de Pitgoras para
calcular la longitud de la hipotenusa
d a d as las longitudes de los dos lados
opuesto s.
*/
class Hypot {
public static void main(String args[])
double x , y , z ;
X = 3 ;
y 4 ;
f ava7 SfM
z = Math . sqrt( x *x + y*y) ; // en la invocacin de sqrt() se antepone el
11 nombre de la c l ase
11 de la que es miembro .
System. out . println( " Hypotenuse is " +z) ;
Este programa genera el siguiente resultado:
Hypotenuse is 5.0
Como hemos mencionado, sqrt () es miembro de la clase estndar Mat h. Fjese en
su invocacin; se precede del nombre Math. Es similar a cmo System. out precede a
println ().Aunque no todos los mtodos estndar se invocan especificando primero
el nombre de su clase, algunos s lo hacen.
Caracteres
En Java, los caracteres no son cantidades de 8 bits como en otros lenguajes. En su
lugar, Java usa Unicode. Unicode define un conjunto de caracteres que puede representar
todos los caracteres de los idiomas humanos. En Java, char es un tipo sin signo de 16
bits con un intervalo de O a 65.536. El conjunto de caracteres ASCII estndar de 8 bits es
un subconjunto de Unicode y su intervalo es de O a 127. Por tanto, los caracteres ASCII
son caracteres vlidos de Java.
Se puede asignar un valor a una variable de carcter si se encierra entre comillas
simples. El siguiente ejemplo asigna la letra X a la variable c h:
char ch;
ch = ' X';
Puede representar un valor char con una instruccinprintl n ().La siguiente lnea
muestra el valor de ch:
System. out.println( " This is ch : " +ch) ;
Como char es un tipo sin signo de 16 bits, se puede usar para realizar operaciones
aritmticas. Fjese en el siguiente programa:
// Las variables de caracteres se pueden procesar como enteros .
class CharArithDemo {
public static void main(String args[]) {
char ch;
Mij1M 2. Tipos de datos y operadores
ch = ' X';
System.out.println (" ch contains
11
+ch) ;
ch++ ; // incrementar ch
System. out . println(
11
ch is now
11
+ch) ;
ch= 90 ; 11 asignar el valor Za ch
System. out . println(
11
ch is now
11
+ch);
Este programa genera el siguiente resultado:
ch contains X
ch is now Y
ch is now Z
En el programa, c h recibe inicialmente el valor X. Tras ello, se incrementa para que
contenga Y, el siguiente carcter de la secuencia ASCII (y Unicode). Tras ello, se asigna el
valor 90 a c h, el valor ASCII (y Unicode) correspondiente a la letra Z. Como el conjunto
de caracteres ASCII ocupa los primeros 127 valores del conjunto de caracteres Unicode,
los trucos que haya empleado con caracteres en otros lenguajes tambin funcionarn
en Java.
Preguntas al experto
P: lPor qu se usa Unicode en Java?
R: Java se dise para un uso global. Es decir, debe usar un conjunto de caracteres que
pueda representar todos los idiomas del mundo. Unicode es el conjunto de caracteres
estndar diseado expresamente para ello. Evidentemente, el uso de Unicode no es
eficaz para idiomas como ingls, alemn, espaol o francs, cuyos caracteres pueden
incluirse en 8 bits. Es el precio que hay que pagar por la portabilidad global.
El tipo boolean
El tipo boolean representa valores t r ue/ fal s e. Java define estos valores por medio
de las palabras reservadas t rue y false. Por tanto, una variable o expresin de tipo
bool e a n tendr uno de estos dos valores.
El siguiente programa ilustra el uso del tipo boolean:
11 Demostrar valores boolean .
class BoolDemo {
public static void main(String args[]) {
boolean b ;
b = false ;
System. out . println(
11
b is
11
+ b) ;
b = true ;
System. out . println( "b is " + b);
11 un valor boolean puede controlar la instruccin if
if (b) System. out.println( " This is executed." ) ;
b = false;
if (b ) System. out . println( " This is not executed.");
11 e l resultado de un operador relacional es un valor boolean
System. o ut.println( " lO > 9 is " + (10 > 9) );
Este programa genera el resultado mostrado en la figura 2.1.
Figura 2.1. Resultado del programa BoolDemo.
Java 7 M;jM
En este programa podemos destacar tres aspectos importantes. Por un lado, al repre-
sentar un valor boolean con println (),se muestra "true" o "false". Adems,
el valor de una variable boolean es suficiente para controlar la instruccin if. No es
necesario escribir una instruccin i f como la siguiente:
if (b == true) .. .
Por ltimo, el resultado de un operador relacional como< es un valor boo lean, ya
que la expresin 1 O> 9 muestra el valor true. Es ms, el conjunto adicional de parntesis
alrededor de 1 O > 9 es necesario porque el operador + tiene mayor precedencia que >.
En este ejercicio crearemos un programa que calcule la distancia, en pies, de un indi-
viduo con respecto a un relmpago. El sonido se desplaza aproximadamente a 1.100 pies
por segundo. Por tanto, si sabemos cundo vemos un relmpago y cundo escuchamos
el sonido, podemos calcular la distancia. En este ejercicio, imagine que el intervalo de
tiempo es de 7'2 segundos.
l. Cree un nuevo archivo con el nombre Sound. jav a.
2. Para calcular la distancia, debe usar valores de coma flotante. Por qu? Porque
el intervalo de tiempo, 7'2, tiene un componente fraccional. Aunque se podra
usar un valor de tipo float, usaremos double.
MfW 2. Tipos de datos y operadores
3. Para calcular la distancia, multiplique 7'2por1.100. Asignaremos este valor a una
variable.
4. Por ltimo muestre el resultado.
El cdigo del programa Sound. j ava es el siguiente:
/ *
Ejercicio 2 . 1
Calcular la distancia de un relmpago
que tarda 7 ' 2 segundos
e n per cibir .
*/
class Sound {
public static void rnain (String args[]) {
double dist ;
d i st = 7 . 2 * 11 00 ;
Systern . out . pri nt l n("The ligh t ni ng is " + d i st +
" feet away ." ) ;
5. Compile y ejecute el programa para obtener el siguiente resultado:
The lightning i s 7920 . 0 feet away .
6. Un reto adicional. Puede calcular la distancia de un objeto mayor, como una
pared, si cronometra el eco. Por ejemplo, si da una palmada y anota lo que tarda
en escuchar el eco, sabe el tiempo total. Divida este valor por dos para saber lo
que tarda en una direccin. Puede usar este valor para calcular la distancia al
objeto. Modifique el programa anterior para calcular la distancia, asumiendo que
el intervalo de tiempo es el del eco.
Literales
En Java, un literal es un valor fijo representado en formato legible para los humanos.
Por ejemplo, el nmero 100 es un literal. Tambin suelen denominarse constantes. En
muchos casos, los literales y su uso son intuitivos, y se han utilizado de alguna forma
en los programas anteriores. Ahora los explicaremos formalmente.
Los literales de Java pueden ser cualquiera de sus tipos primitivos. Cada literal se
representa en funcin de su tipo. Como explicamos antes, las constantes de carcter se
incluyen entre comillas simples. Por ejemplo, ' a ' y ' % ' son constantes de carcter.
Los literales enteros se especifican como nmeros sin componentes fraccionales,
como por ejemplo, 1 O y -1 OO. Los literales de coma flotante usan el decimal seguido del
componente fracciona! del nmero, como 11 ' 12 3. Java tambin le permite usar notacin
cientfica para nmeros de coma flotante.
Java 7 M:tCM
De forma predeterminada, los literales enteros son de tipo i nt. Si desea especificar
un literal long, debe adjuntar 1 o L. Por ejemplo, 12 es int, pero 12L es l ong.
De forma predeterminada, los literales de coma flotante son de tipo double. Para
especificar un literal f loa t, debe aadir Fo fa la constante, como en 1O'1 9F.
Aunque los literales enteros crean un valor int de forma predeterminada, pueden
asignarse a variables de tipo char, byte o short siempre que el valor asignado se
pueda representar por el tipo de destino. Un literal entero siempre se puede asignar a
una variable l ong.
Desde el JDK 7, puede aadir guiones bajos a un literal entero o flotante. De este modo
se facilita la lectura de los valores formados por vario dgitos. Al compilar el literal, se
descartan los guiones bajos. Veamos un ejemplo:
123 45 1234
En este caso se especifica el valor 12 3 . 4 5 . 12 3 4. El uso de guiones bajos resulta
especialmente til en cdigo de nmeros de partes, ID de clientes o cdigos de estado
que suelen estar formados por subgrupos de dgitos.
Literales hexadecimales, octales y binarios
Como ya sabr, en programacin puede ser ms sencillo usar un sistema de nmeros
basado en 8 16 que en 10. El sistema numrico de base 8 se denomina octal y usa los
dgitos del 7 al O. En octal, el nmero 10 es igual al nmero 8 decimal. El sistema num-
rico de base 6 se denomina hexadecimal y usa los dgitos del O al 9 ms letras A-F (del
10 al 15). Por ejemplo, el nmero hexadecimal 10 es 16 en el sistema decimal. Debido a
la frecuencia de uso de estos dos sistemas, Java le permite especificar literales enteros
en hexadecimal u octal en lugar de decimal. Un literal hexadecimal debe comenzar
por Ox o OX (un cero y una equis). Un entero octal comienza por cero. Veamos algunos
ejemplos:
hex = OxFF; // 255 en decimal
oct = 011 ; // 9 en decimal
Java tambin permite literales de coma flotante hexadecimales pero apenas se
utilizan.
Desde elJDK 7 se puede especificar un literal entero binario. Para ello, debe preceder
el nmero binario con Ob o OB. Por ejemplo, OblOO especifica el valor 12 en sistema
binario.
Secuencias de escape de caracteres
La inclusin de constantes de carcter entre comillas simples funciona con la mayora
de caracteres impresos pero alguno, como el retomo del carro, suponen un problema al
usar editores de texto. Adems, determinados caracteres, como las comillas simples y
dobles, tiene un significado especial. En Java, no se pueden usar directamente. Por estos
M;f!I 2. Tipos de datos y operadores
motivos, Java cuenta con secuencias de escape especiales, tambin denominadas cons-
tantes de carcter de barra inversa (vase la tabla 2.3). Estas secuencias se usan en lugar
de los caracteres que representan.
Tabla 2.3. Secuencias de escape de caracteres.
Secuencia de escape
\ '
\ 11
\\
\r
\n
\f
\t
\b
\ddd
\uxxxx
Descripcin
Comilla simple.
Comilla doble.
Barra invertida.
Retorno del carro.
Nueva lnea.
Salto de formulario.
Tabulacin horizontal.
Retroceso.
Constante octal (donde ddd es una constante octal).
Constante hexadecimal (donde xxxx es una constante hexa-
decimal).
El siguiente asigna el carcter de tabulacin a ch:
ch= ' \t ';
El siguiente ejemplo asigna una comilla simple a c h:
ch = , \ ,,;
Literales de cadena
Java admite otro tipo de literal: las cadenas. Una cadena es un conjunto de caracteres
incluidos entre comillas dobles. Por ejemplo:
" this is a test "
es una cadena. Ya hemos visto ejemplos en muchas de las instrucciones println ()
de los programas anteriores.
Adems de caracteres normales, un literal de cadena tambin puede contener una
o varias de las secuencias de escape anteriores. Por ejemplo, el siguiente programa usa
las secuencias de escape \n y \ t:
11 Ilustra secuencias de escape en cadenas .
class StrDemo {
public static void main(String args[]) {
Java 7 Md"W
System. out . println( '' First line\nSecond line" }; 11 Se usa \n para generar una
11 nueva lnea .
System. out . println ( "A\tB\tC" } ;
System. out . println( " D\tS\tF" } ;
Este programa genera el resultado mostrado en la figura 2.2.
lit Shnbolo del sistema
Figura 2.2. Resultado de la ejecucin del programa.
La secuencia de escape \n se usa para generar una nueva lnea. No es necesario usar
varias instrucciones print ln () para obtener resultados en varias lneas. Basta con
incluir \ nen una cadena extensa en los puntos donde quiera dividir las lneas.
Preguntas al experto
P: U na cadena con un solo carcter es lo mismo que un literal de cadena? Por ejemplo,

11
k
11
es lo mismo que ' k ' ?
R: No. No debe confundir cadenas con caracteres. Un literal de carcter representa
una sola letra de tipo char. Una cadena con una sola letra sigue siendo una cadena.
Aunque las cadenas estn formadas por caracteres, no son del mismo tipo.
Variables
En el captulo anterior presentamos las variables. A continuacin, las analizaremos con
mayor detalle. Como ya vimos, las variables se declaran con la siguiente instruccin:
tipo nombre-var
donde t i po es el tipo de datos de la variable y nombre- var su nombre. Puede
declarar variables de cualquier tipo, incluidos los descritos anteriormente. Al crear una
variable, se crea una instancia de su tipo. Por tanto, las prestaciones de una variable se
determinan con su tipo. Por ejemplo, una variable de tipo boolea n no se puede usar
para almacenar valores de coma flotante. Es ms, el tipo de una variable no se puede
cambiar mientras exista. Una variable int no se puede convertir en char.
MdW 2. Tipos de datos y operadores
Todas las variables de Java deben declararse antes de poder usarse, ya que el compi-
lador debe saber el tipo de datos que contiene una variable antes de poder compilar
las instrucciones que utilice. Tambin permite a Java realizar la comprobacin de tipos
estrictos.
Inicializar una variable
Por lo general, debe asignar un valor a una variable antes de usarla. Puede hacerlo
a travs de una instruccin de asignacin, como ya hemos visto, o asignarle un valor
inicial al declararla. Para ello, incluya un signo = detrs del nombre de la variable y el
valor asignado. El formato general de inicializacin es el siguiente:
tipo var = valor;
Aqu, valor es el valor asignado a varal crearla. El valor debe ser compatible con
el tipo especificado. Veamos algn ejemplo:
int count = 10 ; // asignar a count el valor inicial 10
char ch= ' X'; //inicializar ch con la letra X
float f = l.2F; // f se inicializa con 1 . 2
Al declarar dos o ms variables del mismo tipo con una lista separada por comas,
puede asignar un valor inicial a una o varias de las mismas:
int a , b = 8, c = 19, d; //by c tiene inicializaciones
En este caso, slo se inicializan by c.
Inicializacin dinmica
Aunque los ejemplos anteriores slo usan constantes como inicializadores, Java
permite inicializar variables de forma dinmica, por medio de expresiones vlidas al
declarar la variable. Por ejemplo, el siguiente programa calcula el volumen de un cilindro
dado el radio de su base y su altura:
11 Ilustra la inicializacin dinmica .
class Dyninit {
public static void main(String args[])
double radius = 4, height = 5 ;
11 inicializar volume de forma dinmica
double volume = 3 . 1416 * radius * radius * height;
System.out . println( " Volume is " + volume);
Se declaran tres variables locales: radius, height y volume. Las dos primeras,
radi us y height, se inicializan con constantes. Sin embargo, vol ume se inicializa
dinmicamente en el volumen del cilindro. La expresin de inicializacin puede usar
cualquier elemento vlido en el momento de la inicializacin, incluyendo invocaciones
de mtodos, otras variables o literales.
fava7 MfM
mbito y duracin de variables
Las variables usadas hasta ahora se han declarado al inicio del mtodo main ().Sin
embargo, Java permite declarar variables en cualquier bloque. Como vimos en el cap-
tulo anterior, un bloque se inicia con una llave de apertura y termina con una llave de
cierre. Un bloque define un mbito. Por ello, cada vez que se inicia un nuevo bloque, se
crea un mbito nuevo. El mbito determina qu objetos son visibles para otras partes del
programa y tambin la duracin de dichos objetos. Otros lenguajes informticos definen
dos categoras generales de mbitos: global y local. Aunque Java los admite, no son la
mejor opcin de categorizar los mbitos de Java. Los ms importantes son los definidos
por clases y mtodos. En un apartado posterior abordaremos el mbito de clase. Por el
momento, nos centraremos en los mbitos definidos en un mtodo.
El mbito definido por un mtodo comienza con la llave de apertura. No obstante, si
ese mtodo tiene parmetros, tambin se incluyen en su mbito.
Como regla general, las variables declaradas en un mbito no son accesibles para el
cdigo definido fuera de dicho mbito. Por ello, al declarar una variable en un mbito, se
localiza y se protege de acceso sin autorizacin y modificaciones. En realidad, las reglas
de mbito constituyen la base de la encapsulacin.
Los mbitos se pueden anidar. Por ejemplo, cada vez que se crea un bloque de cdigo,
se crea un nuevo mbito anidado. El mbito externo contiene al interno, lo que signi-
fica que un objeto declarado en el mbito externo ser visible para el cdigo del mbito
interno. Pero no funciona a la inversa. Los objetos declarados en el mbito interno no
son visibles en el exterior del mismo.
Para comprender el efecto de los mbitos anidados, fjese en el siguiente programa:
// Ilustra el mbito de bloques.
class ScopeDemo {
public static void main(String args[]) {
int x; // conocido para todo el cdigo de main
X = 10;
if (x == 10) { // iniciar nuevo mbito
)
int y= 20; 11 slo es conoci do para este bloque
// x e y se conocen aqu .
System. out . println (" x and y : " + x + " " +y);
X = y * 2 ;
11 y= 100; // Error! y es desconocido aqu
// x sigue siendo conocido .
System.out.println( " x is " + x);
Como indican los comentarios, la variable x se declara al inicio de mbito de ma in ( )
y es accesible para el cdigo posterior de ma in ().En el bloque if se declara y. Como
un bloque define un mbito, y slo es visible para el resto del cdigo de este bloque. Por
Md:M 2. Tipos de datos y operadores
ello, se comenta la lnea y= 1 OO. Si elimina el smbolo inicial del comentario, se produce
un error de compilacin, ya que y no es visible fuera de su bloque. En el bloque i f, se
puede usar x, ya que el cdigo de un bloque (es decir, un mbito anidado), tiene acceso
a las variables declaradas en el mbito contenedor.
En un bloque, se pueden declarar variables en cualquier punto pero solo son vlidas
tras declararse. Por ello, si define una variable al inicio de un mtodo, estar disponible
para el cdigo de ese mtodo. Por el contrario, si declara una variable al final de un
bloque, no servir de nada, ya que ningn cdigo podr acceder a la misma.
Recuerde tambin que las variables se crean al acceder a su mbito y se destruyen
al salir del mismo. Esto significa que una variable no mantiene su valor tras salir de
su mbito. Por tanto, las variables declaradas en un mtodo no conservan sus valores
entre invocaciones del mismo. Adems, una variable declarada en un bloque pierde
su valor al salir del bloque. Por tanto, la duracin de una variable depende de su
mbito.
Si la declaracin de una variable incluye un inicializador, dicha variable se vuelve a
inicializar cada vez que se acceda al bloque en el que se declara. Veamos un ejemplo:
// Ilustra la duracin de una variable .
class VarinitDemo {
public static void main(String args[])
int x ;
for(x = O; x < 3 ; x++) {
int y = - 1 ; // y se inicializa cada vez que se entra al bloque
System. out . println( " y is : " +y) ; //siempre imprime - 1
y = 100;
System. out . printl n (" y is now: " + y) ;
En la figura 2.3 puede ver el resultado generado por este programa.
Figura 2.3. Resultado del programa.
Como puede apreciar, y se vuelve a inicializar en - 1 siempre que se accede al bucle
~ o r interno. Aunque despus se le asigne el valor 1 O O, este valor se pierde.
- reglas de mbito de Java tienen una peculiaridad. Aunque los bloques se pueden
-.__..., .. .....,declaradas en un mbito interior no pueden tener el mismo nombre
mbito contenedor. Por ejemplo, el siguiente programa, que
e. i s m o nombre
1
no se compilar:
/*
*/
Este programa intenta declarar una variable
en un mbito interno con el mismo nombre que otra
defini da en un mbito e x t e r ~ o
* ** Este programa no se compila. ***
class NestVar {
public stati c void main(String args[]) {
int count ;
for(count = O; count < 1) ; count = count+l) {
System. out . println ( " T:lis is count : " + count) ;
int count ; // Incorrecto! Ya se ha declarado count antes .
for(count = O; count < 2 ; count++)
System. out . println( " This program is in error! " ) ;
Java 7 M:t:M
Si proviene de C/C++, sabr que no hay restricciones en cuanto al nombre de las
variables declaradas en un mbito interno. As pues, en C/C++ la declaracin de count
en el bloque del bucle f or externo es totalmente vlida y oculta la variable exterior.
Los diseadores de Java pensaron que esto podra generar errores de programacin y
lo prohibieron.
Operadores
Java cuenta con un completo entorno de operadores. Un operador es un smbolo que
indica al compilador que realice una operacin matemtica o lgica concreta. Java cuenta
con cuatro clases generales de operadores: aritmticos, de orden de bits, relacionales y
lgicos. Tambin define otros para realizar determinadas operaciones especiales. En este
captulo veremos los operadores aritmticos, relacionales y lgicos, adems del de asig-
nacin. Los operadores de orden de bits y los especiales se abordarn ms adelante.
Operadores aritmticos
+
Java define los siguientes operadores aritmticos:
Tabla 2.4. Operadores aritmticos de Java.
Suma (tambin ms unario).
Resta (tambin menos unario).
Wl1M 2. Tipos de datos y operadores
*
Multiplicacin
/ Divisin
% Mdulo
++ Incremento
Decremento
Los operadores +, -, * y / funcionan como en otros lenguajes (o en lgebra). Se
pueden aplicar a cualquier tipo de datos numrico y tambin usar con objetos de tipo
char.
Aunque el lector ya conoce las acciones de los operadores aritmticos, existen situa-
ciones especiales. Por un lado, al aplicar / a un entero, el resto se trunca; por ejemplo,
1 O/ 3 equivale a 3 en una divisin entera.
Puede obtener el resto de esta divisin por medio del operador de mdulo(%), que
funciona como en otros lenguajes de programacin: devuelve el resto de una divisin
entera. Por ejemplo, 1 O % 3 es l. En Java, % se puede aplicar a tipos enteros y de coma
flotante. Por tanto, 1 O ' O % 3 ' O tambin es l. El siguiente programa ilustra el uso del
operador de mdulo:
11 El operador %.
class ModDemo {
public static void main(String args[)) {
int iresult, irem;
double dresult , drem;
iresul t = 1 0 / 3 ;
irem = 10 % 3;
dresult = 10 . 0 / 3 . 0;
drem = 10.0 % 3.0;
System.out.println( " Result and remainder of 10 / 3 : " +
iresult + " " + irem) ;
System. out . println( " Result and remainder of 10 . 0 / 3 . 0: " +
dresult + " "+ drem);
Este programa genera el siguiente resultado:
Result and remainder of 10 / 3: 3 1
Result and remainder of 10 . 0 / 3 . 0 : 3.3333333333333335 1.0
Como puede apreciar, % devuelve el resto 1 tanto para operaciones enteras como de
roma flotante.
Java? WjM
Incremento y decremento
Como vimos en el captulo anterior,++ y -- son los operadores de incremento y decre-
mento de Java. Disponen de propiedades especiales. Primero veremos cmo funcionan. El
operador de incremento suma 1 a su operando y el de decremento resta l. Por tanto:
X = X + 1 ;
es lo mismo que
x++ ;
y
X = X - 1 ;
es lo mismo que
x -- ;
Ambos operadores pueden utilizarse como prefijos o sufijos del operando. Por
ejemplo,
X = X + 1 ;
se puede escribir como
++x ; 11 formato de prefijo .
o como
x++; 11 formato de sufijo .
En el siguiente ejemplo, es irrelevante si el incremento se aplica como prefijo o sufijo.
No obstante, al usar un incremento o decremento como parte de una expresin ms
extensa, hay una diferencia importante. Cuando el operador precede al operando, Java
realiza la operacin correspondiente antes de obtener el valor del operando para usarlo
en el resto de la expresin. Si el operador aparece detrs del operando, Java obtiene el
valor del operando antes de incrementarlo o reducirlo. Veamos un ejemplo:
X = 10;
y = ++x;
En este caso, y se establece en 11. No obstante, si el cdigo se escribiera as:
X = 10;
y = x++;
y se establecera en 1 O. En ambos casos, x se establece en 11; la diferencia es cundo
se produce. La posibilidad de controlar cundo se produce la operacin de incremento
o decremento tiene grandes ventajas.
W#W 2. Tipos de datos y operadores
Operadores relacionales y lgicos
Al hablar de operadores, relacional hace referencia a la relacin que pueden tener los
valores y lgico a las formas de conectar valores true y fa l se. Como los operadores
relacionales generan valores true o false, suelen utilizarse junto a los lgicos.
Los operadores relacionales son los siguientes:
Operador
!=
>
<
>=
<=
Tabla 2.5. Operadores relacionales de Java.
Significado
Igual a
No iguala
Mayor que
Menor que
Mayor o igual que
Menor o igual que
Los operadores lgicos son los siguientes:
Operador
&
1 1
&&
Tabla 2.6. Operadores lgicos de Java.
Significado
ANO
OR
XOR (OR exclusivo)
OR de cortocircuito.
ANO de cortocircuito.
NOT
El resultado de los operadores relacionales y lgicos es un valor bool ean.
En Java, se puede comparar la igualdad o desigualdad de un objeto por medio de ==
y ! =.Sin embargo, los operadores de comparacin <, >, <= o >=, slo se pueden aplicar a
los tipos que admiten una relacin de orden. Por tanto, todos los operadores relacionales
se pueden aplicar a todos los tipos numricos y a char. Sin embargo, los valores de tipo
boolean slo se pueden comparar por igualdad o desigualdad, ya que los valores t rue
y fal se carecen de orden. Por ejemplo, t r ue> false no tiene sentido en Java.
Para los operadores lgicos, los operandos deben ser de tipo boolean y el resultado
de una operacin lgica es del mismo tipo. Los operadores lgicos &, I , " y ! admiten
las operaciones lgicas bsicas ANO, OR, XOR y NOT, de acuerdo a la siguiente tabla:
Java7 MM
False False False False False True
True False False True True False
False True False True True True
True True True True False False
Como puede apreciar, el resultado de una operacin de OR exclusivo es true cuando
slo un operando es true.
Veamos un programa que ilustra algunos de los operadores relacionales y lgicos:
11 Ilustra los operadores relacionales y lgicos.
class RelLogOps {
public static void main(String args[]) {
int i, j ;
boolean bl, b2 ;
i 10;
j 11;
if(i < j) System.out . println( " i < j " ) ;
if(i <= j) System. out.println( " i <= j " );
if(i != j) System. out.println( " i != j ");
if(i j) System. out . println("this won't execute");
if(i >= j) System.out.println( " this won ' t execute");
if(i > j) System. out.prin:ln("this won ' t execute");
bl = true ;
b2 = false;
if(bl & b2) System. out . println( " this won't execute" );
if(!(bl & b2)) System.out.println( "! (bl & b2) is true" );
if(bl 1 b2) System. out . println( " bl 1 b2 is true" );
if(bl A b2) System. out.println( "bl A b2 is true" );
Este programa genera el resultado mostrado en la figura 2.4.
Figura 2.4. Resultado generado por el programa RellogOps.
El 2. Tipos de datos y operadores
Operadores lgicos de cortocircuito
Java cuenta con versiones especiales de cortocircuito de sus operadores lgicos ANO
y OR que se pueden usar para crear cdigo ms eficaz. Para comprender el motivo,
imagine que en una operacin ANO, si el primer operando es false, el resultado ser
false, independientemente del valor del segundo operando. En una operacin OR, si
el primer operando es true, el resultado es true independientemente del valor del
segundo operando. En estos dos casos, no es necesario evaluar el segundo operando,
con lo que se ahorra tiempo y se genera cdigo ms eficaz.
El operador ANO de cortocircuito es & &; en el caso de OR, es 1 1 (que se corresponden a
& y 1 ). La nica diferencia entre ambas versiones es que los operandos normales siempre
evalan los operandos pero las versiones de cortocircuito slo evalan el segundo
operando cuando es necesario.
El siguiente programa ilustra el uso del operador ANO de cortocircuito. Determina si
el valor de des un factor den. Para ello, realiza una operacin de mdulo. Si el resto de
n/ des cero, des un factor. Pero como la operacin de mdulo implica una divisin, se
usa la versin de cortocircuito de ANO para evitar un error de divisin por cero.
11 Ilustra los operadores de cortocircuito .
class SCops {
publ i c static void main(String args[]) {
int n, d , q ;
n = 10;
d = 2 ;
if (d ! =O && (n % d) == 0 )
System. out . println(d + " is a factor of " + n);
d = O; // establecer den cero
// Como des cero, el segundo operando no se evala .
if(d ! =O && (n % d) == 0) // el operador de cortocircuito evita la divisin
11 por cero .
System.out.println(d + " is a factor of " + n);
/* Intentar lo mismo sin el operador de cortocircuito.
Se produce un error de divisin por cero.
*/
if(d ! =O & (n % d) == 0) // evaluar ambas expresiones y permitir divisin
11 por cero
System. out . println(d + "is a factor of " + n);
Para evitar la divisin por cero, la instruccin i f comprueba si d es igual a cero. En
caso afirmativo, ANO se detiene y realiza la divisin de mdulo. Por ello, en la primera
prueba, des 2 y se realiza la operacin de mdulo. La segunda prueba es fallida ya que d
se establece en cero y la operacin de mdulo se ignora, para evitar la divisin por cero.
Por ltimo, se prueba el operador ANO estndar, por lo que se evalan ambos operandos,
Java 7 W'9W
lo que genera un error de tiempo de ejecucin al producirse la divisin por cero. La espe-
cificacin formal de Java se refiere a los operadores de cortocircuito como operadores
AND y OR condicionales pero el trmino cortocircuito es de uso habitual.
El operador de asignacin
Ya usamos este operador en el captulo anterior. Lo analizaremos a continuacin. El
operador de asignacin es el signo = simple y su funcionamiento es similar al de otros
lenguajes informticos. Su formato general es el siguiente:
var = expresin
El tipo de var debe ser compatible con el de expr e s in.
El operador de asignacin tiene un interesante atributo que puede que desconozca:
le permite crear una cadena de asignaciones. Por ejemplo:
int x , y , z ;
x =y= z = 100; // establecer x , y y zen 100
Este fragmento establece las variables x, y y z en 1 O O con una misma instruccin.
Funciona porque = es un operador que devuelve el valor de la expresin de la derecha.
Por tanto, el valor de z = 1 O O es 1 O O, que se asigna a y, que a su vez se asigna a x. Las
cadenas de asignacin son una forma sencilla de establecer un grupo de variables en el
mismo valor.
P: Como los operadores de cortocircuito son, en algunos casos, ms eficaces que los
normales, por qu se mantienen los operadores AND y OR estndar en Java?
R: En algunos casos es necesario evaluar los dos operandos de una operacin AND y
OR por los efectos secundarios que se crean. Por ejemplo:
11 Los efectos secundarios pueden ser importantes .
class SideEffects {
public static void ma:n(String args[]) {
int i;
i = O;
/* Se incrementa i aunque
la instruccin if falle . */
if (false & (++i < 100))
System. out . println( " this won ' t be displayed" ) ;
System. out.println( " if statements executed: "+ i); //muestra 1
/* En este caso, no se incrementa i ya que
WlW 2. Tipos de datos y operadores
el operador de cortocircuito ignora el incremento . */
if (false && (++i < 100 ))
Systern. out . println( " this won ' t be displayed" );
Systern.out.println( " if staternents executed: " + i) ; //sigue siendo 1!
Como indican los comentarios, en la primera instruccin i f , se incrementa i inde-
pendientemente de que i f sea satisfactoria o no. Sin embargo, al usar el operador de
cortocircuito, la variable i no se incrementa cuando el primer operando es f al se.
Si su cdigo espera que se evale el operando derecho de una operacin ANO u OR,
debe usar la versin estndar de estas operaciones.
Asignaciones abreviadas
Java le ofrece operadores de asignacin abreviados que simplifican el cdigo de
determinadas instrucciones de asignacin. Veamos un ejemplo. Esta instruccin de
asignacin
X = X + 10 ;
se puede escribir de esta otra forma con una abreviatura de Java:
X += 10;
El par de operadores+= indica al compilador que asigne ax el valor de x ms 10.
Veamos otro ejemplo. La instruccin
X = X - 100;
equivale a
X -= 100;
Ambas instrucciones asignan a x el valor de x menos 1 OO.
La abreviatura funciona en todos los operadores binarios de Java (es decir, los que
requieren dos operandos). El formato general de la expresin es el siguiente:
var op = expresin;
As pues, los operadores de asignacin abreviados aritmticos y lgicos son:
+= *= /=
%= &=
1
= "=
Como estos operadores combinan una operacin con una asignacin, suelen deno-
minarse operadores de asignacin compuestos.
fava 7 WIM
Le ofrecen dos ventajas. Por un lado, son ms compactos que sus equivalentes "desa-
rrollados". Por otra parte, se implementan con mayor eficacia en el sistema de tiempo
de ejecucin de Java. Por estos motivos suelen usarse en programas profesionales de
Java.
Conversin de tipos en asignaciones
En programacin, es habitual asignar un tipo de variable a otra. Por ejemplo, puede
asignar un valor int a un valor f l oat, como se indica a continuacin:
int i ;
float f ;
i 1 0 ;
f i ; // asignar un int a un :loat
Al mezclar tipos compatibles en una asignacin, el valor de la derecha se convierte
automticamente al tipo de la izquierda. Por tanto, en el ejemplo anterior, el valor de i
se convierte a f loat y se asigna a f . Sin embargo, debido a la comprobacin de tipos
estrictos de Java, no todos los tipos son compatibles y, por ello, no se permiten todas las
conversiones. Por ejemplo, boolean e int no son compatibles.
Al asignar un tipo de datos a otro tipo de variable, se produce la conversin auto-
mtica de tipos si:
Los dos tipos son compatibles.
El tipo de destino es mayor que el de origen.
Si se cumplen estas dos condiciones, se produce la conversin. Por ejemplo, el tipo
int siempre tiene tamao suficiente para almacenar todos los valores b y te vlidos,
y tanto int como byte son tipos enteros, por lo que se puede aplicar una conversin
automtica de b yte a int.
En conversiones ampliadas, los tipos numricos, incluidos los tipos enteros y flotantes,
son compatibles entre s. Por ejemplo, el siguiente programa es vlido, ya que de l ong
a double se produce una conversin ampliada automtica:
//Conversin automtica de long a double .
class LtoD {
public static void main(String args[] ) {
long L;
double D;
L = 100123285L;
D = L; // conversin automtica de long a double
System. out . println( " L and D: " + L + " " + D) ;
E :M 2. Tipos de datos y operadores
Aunque se produzca la conversin automtica de long a double, no se produce de
double a long, ya que no es ampliada. Por tanto, la siguiente versin del programa
anterior no es vlida:
11 *** Este programa no se compila. ***
class LtoD {
public static void main(String args[])
long L;
double D;
D = 100123285 . 0;
L = D; // Incorrecto! No hay conversin automtica de double a long
System. out.println( " L and D: "+ L +" " + D);
No se producen conversiones automticas entre tipos numricos y charo boolean,
que adems son incompatibles entre ellos. Sin embargo, se puede asignar un literal
entero a char.
Convertir tipos incompatibles
Aunque las conversiones automticas de tipos son muy tiles, no satisfacen todas las
necesidades de programacin ya que slo se aplican a conversiones ampliadas entre tipos
compatibles. En los dems casos, debe realizar una conversin explcita, una instruccin
al compilador de que convierta un tipo en otro. Tiene el siguiente formato:
(tipo- destino) expresin
Aqu, tipo-destino especifica el tipo deseado al que convertir expresin. Por
ejemplo, si desea convertir el tipo de la expresin x/y en int, puede usar lo siguiente:
double x , y ;
/ / . ..
(int) (x / y)
Aunque x e y son de tipo double, se convierte el resultado de la expresin a int.
Los parntesis alrededor de x /y son necesarios. En caso contrario, la conversin a int
slo se aplicara ax, no al resultado de la divisin. La conversin es necesaria ya que no
existe conversin automtica de double a int.
Cuando la conversin es de reduccin, se puede perder informacin. Por ejemplo,
al convertir long en short, se pierde informacin si el valor de l ong es mayor que el
de short, ya que se eliminan sus bits de orden superior. Al convertir un valor de coma
flotante a un tipo entero, el componente fracciona! tambin se pierde. Por ejemplo, si el
valor 1 ' 23 se asigna a un entero, el valor resultante ser 1; se pierde O' 23. El siguiente
programa ilustra algunas conversiones de tipos:
// Ejemplo de conversin .
class CastDemo {
publ ic static void main(String args[]) {
double x , y ;
byte b ;
int i ;
char ch;
X = 10.0;
y 3 . 0 ;
i ( int ) (x / y) ; / / convertir double a int . Se produce recorte .
System.out . println( " Integer outcome of x /y: " + i);
i = 100 ;
fava 7 MM
b = (byte ) i ; // no se pierde informacin . byte puede almacenar el valor 100 .
System. out . pri ntln ("Value of b : " + b );
i = 257 ;
b = (byte ) i ; // se pierce informacin . byte no puede almacenar el valor 257 .
Sys t em. out . println( "Value of b: " + b );
b = 88 ; // Cdigo ASCII para X
ch= (char) b ; // conversin entre tipos incompatibles .
System. out . println( " ch : " +ch) ;
Este programa genera el siguiente resultado:
Integer outcome of x / y : 3
Value of b : 100
Value of b : 1
ch : X
En el programa, la conversin de ( x / y) a in t trunca el componente fracciona! y se
pierde informacin. Tras ello, no se pierde informacin al asignar el valor 1 O O a b , ya
que b yte solo puede almacenar el valor 1 O O. Sin embargo, cuando se intenta asignar el
valor 2 5 7 a b, se pierde informacin ya que 2 5 7 supera el valor mximo de b yte. En
el ltimo caso no se pierde informacin, pero se necesita una conversin al asignar un
valor b yte a char.
Precedencia de operadores
La tabla 2.7 muestra el orden de precedencia de los operadores de Java, de mayor a
menor. Se incluyen varios operadores que analizaremos en captulos posteriores. Aunque
tcnicamente son separadores, [ ] , ( ) y . tambin se pueden usar como operadores, con
la mayor precedencia.
l:!eM 2. Tipos de datos y operadores
Tabla 2.7. Precedencia de los operadores de Java.
La ms alta fr
++ (sufijo) - - (sufijo)
+ + (prefijo) - - (prefijo)
+ (unario) - (unario) (conversin de tipo)
*
/ %
+
>> >>> <<
> >= < <= instan::::eof
!=
&
&&
11
? :
op=
La ms b j ~
Ejercicio 2.2. Mostrar una tabla de verdad de los operadores lgicos
En este ejercicio, crearemos un programa que muestra la tabla de verdad de los opera-
dores lgicos de Java. Debe alinear las columnas de la tabla. El ejercicio aplica algunos
de los conceptos analizados en el captulo, como una de las secuencias de escape y los
operadores lgicos.
Tambin ilustra las diferencias de precedencia entre el operador aritmtico +y los
operadores lgicos.
l. Cree un nuevo archivo con el nombre LogicalOpTabl e . java.
2. Para alinear las columnas, use la secuencia de escape \ t para aadir tabulaciones
entre cada cadena. Por ejemplo, la siguiente instruccin p r i nt ln () muestra el
encabezado de la tabla:
System. out.println( " P\tQ\tAND\tOR\tXOR\tNOT" ) ;
3. Cada lnea de la tabla usar tabulaciones para ubicar el resultado de cada opera-
cin bajo su ttulo correspondiente.
4. Introduzca el cdigo del programa.
11 Ejercicio 2 . 2: Tabla de verdad de los operadores lgicos.
class LogicalOpTable {
public static void mai:1 (String args [ J) {
boolean p , q;
System.out.println("P\tQ\tAND\tOR\tXOR\tNOT" );
p = true; q = true;
System. out.print(p + " \t" + q +" \t " );
System. out . print((p&q) + "\t" + (plq) + " \t");
System. out . println((pftq) + "\t" + (
1
p));
p = true; q = false;
System. out . print(p + " \t" + q +" \t " );
System. out . print( (p&q) + " \t" + (plq) + " \t" );
System.out . println((pftq) + " \t " + (!p));
p = false ; q = true;
System.out . print(p + "\t" + q +" \t");
System.out.print((p&q) + " \t" + (plq) + " \t" );
System. out . println((pftq) + "\t" + (!p));
p = false; q = false;
System. out . print(p + "\t" + q +" \t ");
System.out . print( (p&q) + " \t" + (plq) + " \t" );
System.out . println((pAq) + " \t" + (!p));
Java 7 l:IM
Fjese en los parntesis alrededor de las operaciones lgicas de las instrucciones
println ().Son necesarios debido a la precedencia de los operadores de Java.
El operador + tiene mayor precedencia que el resto.
5. Compile y ejecute el programa. Se mostrar la tabla ilustrada en la figura 2.5.
Figura 2.5. Tabla generada por el programa.
6. Pruebe a modificar el programa para que use y muestre unos y ceros en lugar de
true y false. Puede que sea ms complicado de lo que parece.
M:tW 2. Tipos de datos y operadores
Expresiones
Los operadores, variables y literales se usan para formar expresiones. Seguramente
ya conozca el formato general de una expresin, de otros lenguajes de programa-
cin o de sus conocimientos de lgebra. No obstante, analizaremos algunos aspectos
concretos.
Conversin de tipos en expresiones
En una expresin puede mezclar dos o ms tipos diferentes de datos siempre que
sean compatibles entre ellos. Por ejemplo, puede mezclar int y long ya que son tipos
numricos. Si en una expresin se mezclan tipos de datos diferentes, se convierten todos
al mismo tipo, por medio de las reglas de promocin de tipos de Java.
En primer lugar, char, byte y short se cambian a int. Tras ello, si un operando
es long, toda la expresin se convierte a long. Si un operando es floa t , toda la
expresin se convierte a float . Si uno de los operandos es doub le, el resultado es
double.
Sepa que las promociones de tipos slo se aplican a los valores afectados por la
evaluacin de una expresin. Por ejemplo, si el valor de una variable byte se convierte
a i n t dentro de la expresin, fuera de esta la variable seguir siendo de tipo b y t e . La
promocin de tipos solo afecta a la evaluacin de una expresin.
No obstante, puede crear resultados inesperados. Por ejemplo, cuando una opera-
cin aritmtica tiene dos valores b y t e , primero los operandos byte pasan a int. Tras
ello, se realiza la operacin y se devuelve un resultado i n t. Por tanto, el resultado de
una operacin con dos valores byte es int , no lo que habamos imaginado. Fjese en
el siguiente programa:
11 Promocin sorpresa!
class PromDemo {
public static void main(String args[)) (
byte b;
int i;
b = 10;
i = b * b ; // De acuerdo, no se necesita
b 10;
b (byte) (b * b) ; 11 Conversin necesari a !
System. out . println( " i and b: " + i + " " + b) ;
Aunque parezca extrao, no se necesita conversin al asignar b*b a i , ya que b se
pasa a int al evaluar la expresin. Sin embargo, al intentar asignar b*b a b, la conver-
sin es necesaria, de nuevo a byte. Recuerde este aspecto si recibe mensajes de incom-
patibilidad de tipos en expresiones que deberan ser correctas.
Java 7 M:fiM
Lo mismo sucede al realizar operaciones con char. Por ejemplo, en el siguiente
fragmento, se necesita la conversin a char ya que chl y ch2 han pasado a int en la
expresin:
char chl = ' a ', ch2 = ' b ';
chl = (char) (chl + ch2);
Sin la conversin, el resultado de sumar chl a c h 2 sera i nt, que no se puede asignar
a un c har. Las conversiones no slo son tiles entre tipos de una asignacin. El siguiente
programa usa una conversin a doub le para obtener un componente fracciona! de una
divisin entera.
11 Usar conversin .
class UseCast {
public static void main(String args[]) {
int i ;
for(i = O; i < 5; i++) {
System.out . println(i + " / 3: " + i / 3);
System. out.println(i + " / 3 with fractions: "
+ (double) i / 3) ;
System.out.println() ;
Este programa genera el resultado mostrado en la figura 2.6.
Figura 2.6. Resultado generado por el programa.
Espaciado y parntesis
En Java, una expresin puede incluir tabulaciones y espacios para facilitar su lectura.
Por ejemplo, las dos siguientes expresiones son idnticas, pero resulta ms fcil leer la
segunda:
x=10/y*(127/x);
x = 10 I y* (127/x) ;
M:ijl 2. Tipos de datos y operadores
Los parntesis aumentan la precedencia de las operaciones que contienen, corno
sucede en lgebra. El uso de parntesis redundantes no provoca errores ni ralentiza
la ejecucin de la expresin. Le recomendarnos el uso de parntesis para indicar con
claridad del orden de ejecucin. Por ejemplo, de las dos expresiones siguientes, cul
es ms fcil de leer?:
x = y/3- 34*temp+l 27 ;
x = (y/ 3) - (34*temp) + 127;
Evaluacin de conocimientos
l. Por qu especifica Java el mbito y el comportamiento de sus tipos primitivos
de forma tan estricta?
2. Qu es un tipo de carcter de Java y cmo se diferencia del tipo de carcter usado
en otros lenguajes de programacin?
3. Un valor boolean puede tener cualquier valor que desee, ya que un valor que
no sea cero es verdadero. Verdadero o falso?
4. Dado este resultado
One
Two
Three
use una sola cadena y muestre la instruccin println () que lo genera.
5. Qu error detecta en el siguiente fragmento?
for(i = O; i < 10; i++) {
int sum;
sum = sum + i ;
System.out . println( " Sum is : " + sum) ;
6. Explique la diferencia entre las formas de prefijo y sufijo del operador de incre-
mento.
7. Indique cmo se usa un operador AND de cortocircuito para evitar un error de
divisin por cero.
8. En una expresin, a qu tipo se convierten int y s hort?
9. Por lo general, cundo es necesaria una conversin?
10. Cree un programa que busque todos los nmeros primos entre 2 y 100.
11. El uso de parntesis redundantes afecta al rendimiento de un programa?
12. Un bloque define un mbito?