Introducción al Lenguaje Java | |||||
Anterior | Siguiente | Cap.Anterior | Cap.Siguiente |
En el aprendizaje de todo lenguaje de programación, el
primer paso suele ser entrar en conocimiento de los conceptos fundamentales,
como son las variables, los tipos de datos, expresiones, flujo de control, etc.
Por ello, en este capítulo se tratarán estos conceptos. Los programadores con
experiencia en otros lenguajes procedurales reconocerán la mayor parte de las
construcciones. Este capítulo no resulta muy intenso, no obstante, sí debe
estar presente, porque más de una vez habrá que recurrir a él como referencia.
En posteriores capítulos se profundizará sobre algunos aspectos que aquí se
revisan de manera introductoria y se presentarán ejemplos de código de cada uno
de esos aspectos de la programación en Java.
Cuando se programa en Java, se coloca todo el código en
métodos.
En Java hay tres tipos de comentarios:
// comentarios para una sola línea /* comentarios de una o más líneas */ /** comentario de documentación, de una o más líneas */
Los dos primeros tipos de comentarios son los que todo
programador conoce y se utilizan del mismo modo. Los comentarios de
documentación, colocados inmediatamente antes de una declaración (de variable
o función), indican que ese comentario ha de ser colocado en la documentación
que se genera automáticamente cuando se utiliza la herramienta de Java, javadoc, no disponible en otros lenguajes
de programación. Dichos comentarios sirven como descripción del elemento
declarado permitiendo generar una documentación de las clases que se va
construyendo al mismo tiempo que se genera el código de la aplicación.
La plataforma Java 2 permite la creación de doclets,
que son pequeñas aplicaciones que la herramienta javadoc, se puede
ejecutar para generar cualquier tipo de documentación especial que se desee. A
pesar de la posible complejidad de los doclets, la salida estándar es un
fichero HTML con el mismo formato que el resto de la documentación de Java, por
lo que resulta muy fácil navegar a través de las clases.
Los identificadores nombran variables, funciones,
clases y objetos; cualquier cosa que el programador necesite identificar o
usar.
En Java, un identificador comienza con una letra, un
subrayado (_) o un símbolo de dólar ($). Los siguientes caracteres pueden ser letras o
dígitos. Se distinguen las mayúsculas de las minúsculas y no hay una longitud
máxima establecida para el identificador. La forma básica de una declaración de
variable, por ejemplo, sería:
tipo identificador [ = valor][,identificador [= valor] ...];
Serían identificadores válidos:
identificador nombre_usuario Nombre_Usuario _variable_del_sistema $transaccion
y su uso sería, por ejemplo:
int contador_principal; char _lista_de_ficheros; float $cantidad_en_pesos;
Las siguientes son las palabras clave que están
definidas en Java y que no se pueden utilizar como identificadores:
|
|||||||||||||||||||||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||||||||||||||||||||
Además, el lenguaje se reserva unas cuantas
palabras más, pero que hasta ahora no tienen un cometido específico. Son:
|
|||||||||||||||||||||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||||||||||||||||||||
Un valor constante en Java se crea utilizando una
representación literal de él. Java utiliza cinco tipos de elementos:
enteros, reales de punto flotante, booleanos,
caracteres y cadenas, que se pueden poner en cualquier lugar del
código fuente de Java. Cada uno de estos literales tiene un tipo
correspondiente asociado con él.
La sintaxis general de los elementos básicos muestra las capacidades de los distintos tipos de datos primitivos, así como ejemplos breves de uso y declaración.
Cuando se inserta un literal en un programa, el
compilador normalmente sabe exactamente de qué tipo se trata. Sin embargo, hay
ocasiones en la que el tipo es ambiguo y hay que guiar al compilador
proporcionándole información adicional para indicarle exactamente de qué tipo
son los caracteres que componen el literal que se va a encontrar. En el
ejemplo siguiente se muestran algunos casos en que resulta imprescindible
indicar al compilador el tipo de información que se le está
proporcionando:
class literales { char c = 0xffff; // mayor valor para un char en hexadecimal byte b = 0x7f; // mayor valor para un byte en hexadecimal short s = 0x7fff; // mayor valor para un short en hexadecimal int i1 = 0x2f; // hexadecimal en minúsculas int i2 = 0X2F; // hexadecimal en mayúsculas int i3 = 0177; // octal (un cero al principio) long l1 = 100L; long l2 = 100l; long l3 = 200; // long l4(200); // no está permitido float f1 = 1; float f2 = 1F; float f3 = 1f; float f4 = 1e-45f; // en base 10 float f5 = 1e+9f; double d1 = 1d; double d2 = 1D; double d3 = 47e47d; // en base 10 }
Un valor hexadecimal (base 16), que funciona con todos
los tipos enteros de datos, se indica mediante un 0x o
0X seguido por 0-9 y
a-f, bien en
mayúsculas o minúsculas. Los números octales (base 8), se indican colocando un
cero a la izquierda del número que se desee. No hay representación para
números binarios. Si se intenta inicializar una variable con un valor mayor
que que puede almacenar, el compilador generará un error.
Se puede colocar un carácter al final del literal para
indicar su tipo, ya sea una letra mayúscula o minúscula. L se usa para
indicar un long, F significa float y una D mayúscula o minúscula es
lo que se emplea para indicar que el literal es un double.
La exponenciación se indica con la letra e, tomando como referente la base 10. Es decir, hay que
realizar una traslación mental al ver estos números de tal forma que
1.3e-45f en Java, en la realidad es 1.3 x 10-45.
No es necesario indicarle nada al compilador cuando se
puede conocer el tipo sin ambiguedades. Por ejemplo, en
long l3 = 200;
no es necesario colocar la L después de 200 porque
resultaría superflua. Sin embargo, en el caso:
float f4 = 1e-45f; // en base 10
sí es necesario indicar el tipo, porque el compilador
trata normalmente los números exponenciales como double, por lo tanto, si no se coloca la f final, el
compilador generará un error indicando que se debe colocar un moldeador para
convertir el double en float.
Cuando se realizan operaciones matemáticas o a nivel
de bits con tipos de datos básicos más pequeños que
int (
char,
byte o
short), esos valores son promocionados a
int antes de realizar las operaciones y el resultado es de
tipo
int. Si se quiere seguir teniendo el
tipo de dato original, hay que colocar un moldeo, teniendo en cuenta que al
pasar de un tipo de dato mayor a uno menor, es decir, al hacer un moldeo
estrecho, se puede perder información. En general, el tipo más grande en una
expresión es el que determina el tamaño del resultado de la expresión; si se
multiplica un
float por un
double, el resultado será un
double, y si se suma un
int y un
long, el resultado será un
long.
Sólo hay un par de secuencias con otros caracteres que
pueden aparecer en el código Java; son los separadores simples, que van a
definir la forma y función del código. Los separadores admitidos en Java
son:
|
Home | Anterior | Siguiente | Indice | Correo |
No hay comentarios:
Publicar un comentario