05/04/2004

3.3 Conceptos Conjunto de Caracteres

Básicos del Lenguaje
l Java utiliza Unicode, un conjunto de
Java caracteres de 16 bits
l Java permite leer ASCII de 7-bit o Latin-1,
conviertiéndolo a Unicode
l Son pocos los editores actuales que soportan
Unicode
l Se puede usar su código en formato \udddd,
donde d es un dígito hexadecimal

Identificadores Palabras Resevadas

l abstract l double int super
l Deben comenzar con una letra, incluido _ o l boolean l else interface switch
$, seguido de letras o dígitos l break l extends long synchronized
l byte l final native this
l Letras en Unicode es un concepto más amplio
l case l finally new throw
l Son válidos: Árbol, Hähnchen, etc. l catch l float package throws
private transient
l Se diferencia mayúscula de minúscula l char l for
protected try
class goto
l árbol es diferente a Árbol l l
public void
l const l if return volatile
l Java define algunas palabras reservadas que l continue l implements short while
no pueden ser usadas como identificador l default l import static
l do l instanceof

Variable
Variables, Constantes
l Una variable es un item de datos nombrado
y Tipos Primitivos por un identificador
l Una variable tiene un tipo, que debe ser
declarado antes de su uso (como en C)
l tipo variable
l Una variable tiene un ámbito (scope),
definido por la visibilidad que tiene la variable
en el programa

1
 05/04/2004

Tipos de Datos Tipos de Datos Primitivos

l Un tipo define los posibles valores para una variable Tipo Descripción Largo/Formato
l Java define dos categorías de tipos de datos: byte Entero de un byte 8 bits, C-2
l Primitivos. Contiene un único valor de tamaño y formato short Entero corto 16 bits, C-2
apropiado (e.g. Entero, real, booleano, etc.) int Entero 32 bits, C-2
l Referencias. Es una dirección a un conjunto de valores
(e.g. Arreglo, clase e interfaz)
long Entro largo 64 bits, C-2
l Las direcciones son implícitas, dado que Java no float Punto flotante de 32 bits, IEEE 754
soporta punteros precisión simple
double Punto flotante de 64 bits, IEEE 754
precisión doble
char Caracter 16 bits, Unicode
boolean Booleano (true y false)

Constantes de Datos
Más sobre Datos Primitivos Primitivos
l Cada tipo primitivo (excepto short y byte) l 178 Entero
tiene una clase declarada en el paquete l 178L Largo
java.lang l 345.125 doble prec.
l Constantes declaradas: l 234.12D doble prec.
l MIN_VALUE y MAX_VALUE l 234.12F simple prec.
l NEGATIVE_INFINITY y POSITIVE_INFINITY l 23.7e-4 doble prec.
l NaN (Not a Number) l ´c´ caracter
l true booleano

Constantes Literales Declaración de Variables

l 178 Entero l [modificador] tipo variable {, variable}*
l 178L Largo l ´c´ carácter l Modificador es opcional
l 045 octal l \n nueva línea l Posibles modificadores: static o final
l 0X45df Hexadecimal l static sólo se puede usar en campos (fields)
l \u8f4d Unicode
l Ejemplo: float[] x, y;
l true booleano
l 345.125 doble prec. l Declaraciones pueden aparecer en cualquier parte
l 234.12D doble prec. del código
l 234.12F simple prec. l La visibilidad de una variable se limita al bloque en
l 23.7e-4 doble prec. que se declara

2
 05/04/2004

Orden de Resolución de
Nombres Valores Iniciales
l Declaración local a un bloque (e.g. Loop) l Una variable se puede inicializar en su declaración
l Parámetro de un constructor o método l Ejemplo:
l final double π = 3.14159;
l Un miembro de una clase o interfaz
l Java asigna valores por omisión a los campos de
l Tipos explícitamente importados una clase si no se especifica
l Otros tipos declarados en el mismo paquete l Corresponde a valor 0 o null
l Tipos importados implícitamente nombrados l Variables locales de un método, constructor o
inicializador estático no se inicializan
l Paquetes disponibles en el sistema host
l Una variable se inicializa cada vez que se ejecuta
su declaración

Precedencia y Asociatividad
de Operadores
l A igual precedencia, se asocia por la izquierda,
Operadores excepto asignación que es por la derecha
l La precedencia se pueda cambiar usando
paréntesis
l Para legibilidad se recomienda usar paréntesis,
cuando sea posible, de manera de hacer explícita la
precedencia, sin exagerar
l Ejemplo:
while ((v = stream.next()) != null)
procesar(v);

Precedencia de Operadores Precedencia de Operadores

(1/2) (2/2)

Unario posfijo [] . (param) ++ -- l AND al bit &

Menor precedencia

Menor precedencia

Unario prefijo ++ -- + ~ ! l OR exclusivo al bit ^

Creación y cast new (tipo) exp l OR inclusivo al bit |
Multiplicativo * / % l AND lógico &&
Aditivo + - l OR lógico ||
Shift << >> >>> l Condicional ?:
Relacional < > >= <= instanceof l Asignación = += -= *= /= %=
>>= <<= >>>= &=
Igualdad == !=
^= |=

3
 05/04/2004

Expresiones Conversión de Tipo: Implícita

l Una expresión se evalúa de izquierda a derecha
l Orden puede ser importante cuando existen efectos
laterales o corto-circuito
l En general, cada operando se evalúa antes de
realizar la operación
l Cada expresión tiene un tipo
l En general domina el operando de mayor rango de valores
(e.g. double + long → double)
l Conversión implícita. ¡Es automática!
l Valores Primitivos. Se permite entre valores primitivos
cuando se soporta un mayor rango de valores
l No se permite de punto flotante a entero
l En la conversión se puede perder precisión
l Referencias. Una referencia a un objeto de una clase
incluye una instancia de cada supertipo
l Se puede usar una referencia a un objeto de un tipo
cuando se requiera una referencia a un supertipo

Conversión de Tipo: Explícita Operadores Aritméticos

l Se requiere cuando un tipo no se puede asignar l Se soporta para todos los tipos de números
a otro por conversión implícita
l Suma +
l La conversión explícita se denomina cast
l Resta -
l Ejemplo:
double d = 7.99; long l = (long) d; l Multiplicación *
l Se puede usar para referencias a objetos con l División /
conversión no segura l Residuo o módulo %
l Operador instanceof permite verificar se se l Además cambio de signo -
puede aplicar cast a un objeto
if (obj instanceof clase) ....
l null instanceof tipo es siempre falso

Operadores de Incremento y
Decremento Operadores Relacionales
l Operador de incremento l Mayor que >
l a++ equivale a a = a+1
l Mayor o igual que >=
l Operador de decremento
l a-- equivale a a = a-1
l Menor que <
l Ambos operadores existen en forma prefija y l Menor o igual que <=
postfija l Igual que ==
l Prefijo calcula primero la operación y luego se aplica;
postfijo es al revés l Diferente !=
l Ejemplo: arreglo[i++]

4
 05/04/2004

Operadores al Bit Operador Condicional

l AND al bit & l La forma
l OR inclusivo al bit | valor = test ? exp1 : exp2;
l OR exclusivo al bit ^ l Es equivalente a:
l Corrimiento a la izquierda << if (test)
(rellenando con 0) valor = exp1;
l Corrrimiento a la derecha >> else valor = exp2;
(rellenando con el signo) l La diferencia es que el operador condicional define
Corrimiento a la derecha >>> valor y permite expresiones más compactas
(rellenando con 0)

Operador de Asignación
l El operador = corresponde a la asignación,
operador de menor precedencia Control de Flujo
l Java soporta otras formas de asignación
l += -= *= /= %= >>= <<= >>>= &=
^= |=
l Ejemplo:
l arreglo[indice()] += 12 es casi equivalente a
arreglo[indice()] = arreglo[indice()] + 12
l Segundo caso llama dos veces a indice()

Sentencias y Bloques Sentencia if-else

l Un bloque básicamente se compone de: l Forma básica de flujo de control
l Sentencias de expresión condicional
l Asignación
l Formas de prefijo o postfijo de ++ y -- if (exp-booleana)
l Llamadas a métodos ( objeto.metodo(...) ) sent1
l Creación de objetos (con new) else sent2
l Sentencias de declaración
l Variables requieren de inicialización l El else se parea con el if más cercano
l Toda sentencia se termina con ;
l Un bloque se forma con { y } if (valor >= 0) Mal asociado
if ( valor < MAX) el else
process(valor);
else System.out.println (“valor negativo ”)

5
 05/04/2004

Sentencia switch Sentencia while y do-while

l Evalúa una expresión entera cuyo valor se usa l Permite repetición controlada por expresión
para seleccionar caso mediante etiqueta boolena
l Si no se encuentra etiqueta se salta a default
l Las dos formas son:
l Si no existe default, no se hace nada
switch (valor) {
case 0: case 2: case 4: case 6: case 8: while (exp-boolena ) do
System.out.println (“es par”); sentencia sentencia
break; while (exp-boolena );
case 1: case 3: case 5: case 7: case 9:
System.out.println (“es impar”);
break;
default: System.out.println (“es impar”);
}

Sentencia for Sentencia break

l Permite controlar una repetición para un l Permite salir desde
rango de valores cualquier bloque, no buscar:
for(y=0; y<MAX; y++) {
l La forma es la siguiente: sólo switch
for (x=0; x<MAX, x++) {
l Se usa para terminar if (Matriz[x][y] == valor) {
for (exp-inicial; exp-boolena; exp-incremento)
una repetición como encontrado = true;
sentencia break buscar;
for, while o do }
l Esta forma equivale a: l Se puede usar una }
exp-inicial; }
etiqueta para salir de
while (exp-boolena ) { if (! encontrado)
un anidamiento de System.out.println (“no está”);
sentencia bloques
exp-incremento;
}

Sentencia continue Sentencia return

l La sentencia continue permite saltar al final l Permite terminar la ejecución de un método y
del cuerpo de una repetición y evaluar la retorna al invocador.
condición de término l Si no retorno valor: return;
l Se usa para ignorar una elemento de l Si retorna valor: return valor;
proceso
while (! stream.eof ()) {
elem = stream.next();
if (elem == “ “ || elem == “ \n”)
continue;
procesar(elem);
}