Rumbo a nuestra Certificación (Sintaxis del lenguaje)

Hola a todos los programadores de esta comunidad.

Mi hermana y yo estamos en vías de nuestra certificación en "Expert Java Programmer", es por eso que abordaremos varios temas para los novatos.

Todos los ejercicios que publicaremos están basados en varios libros de certificación.

Esta entrega contempla los siguientes temas:

a) Sintaxis básica.
b) Secuencias de escape.
c) Tipos de datos primitivos.
d) Variables.
e) Declaración de variables.
f) Asignación.
g) Literales.
h) Ámbito de las variables.
i) Valores por defecto de una variable.
j) Conversiones de tipo.
k) Conversión implícita.
l) Conversión explícita.

Cualquier duda, comentario o aclaración a través del panel de respuestas.

Saludos y felices compilaciones.

---------------------------------------------------------------------------

Sintaxis del Lenguaje Java.

Algunos de los aspectos generales de J2SE son:

a) Lenguaje sensible a mayúsculas y minúsculas.
b) Las sentencias finalizan con punto y coma (;).
c) Los bloques de instrucciones se delimitan con llave ({...}).
d) Comentarios de una línea y multilínea.

Ejemplo:

// Comentario de una sola línea

/* Comentario de
varias lìneas */

Secuencias de escape.

Una secuencia de escapa va siempre precedida del caracter "\" y son utilizadas para la inclusión
de caracteres especiales.

Ejemplos:

\b: Retroceso
\n: Salto de línea.
\t: Tabulación horizontal.
\\: Barra invertida.
\': Comilla simple.
\": Comilla doble.

Por ejemplo, si quisiéramos mostrar:

Java "mañana"
VB "tarde"

Utilizaremos la siguiente instrucción:

System.out.println("Java\t\"mañana\"\nVB\t\"tarde\"");

Tipos de datos primitivos.

Toda información en Java es representada mediante objetos o datos básicos o de tipo primitivo.

Los 8 tipos de datos primitivos utilizados en Java son:

1.- byte (8 bits).
2.- short (16 bits).
3.- int (32 bits).
4.- long (64 btis).
5.- char (16 btis).
6.- float (32 bits).
7.- double (64 bits),
8.- boolean (Depende de la JVM).

Los tipos de datos primitivos se pueden organizar en grupos.

a) Número enteros: Son los tipos byte, short int y long.
b) Carácter: El tipo char representa un carácter codificado en Unicode.
c) Número decimal: Los tipos float y double representan números de coma flotante.
d) Lógicos: Los datos de tipo boolean pueden almacenar valores del tipo "true" y "false".

Declaración de variables.

Una variable en Java se declara de la siguiente forma:

tipo_dato nombre_variable;

Un nombre válido de variable debe cumplir las siguientes reglas:

a) Debe comenzar con un carácter alfanumérico.
b) No puede contener espacios, signos de puntuación o secuencias de escape.
c) No pueden utilizarse las palabra reservadas como nombres de variables.

Es posible declarar en una sola instrucción variables del mismo tipo:

tipo variable1, variable2, variable3;

Enseguida mostraremos algunos ejemplos de declaraciones válidas y no válidas para variables en Java.

Declaraciones válidas:

a) int k, cod;
b) long p1;
c) char cad_2;

Declaraciones no válidas:

a) boolean 7q; // Comienza con un número.
b) int num uno; // Contiene un espacio.
c) long class; // Utiliza la palabra reservada "class".

Asignación.

Una vez que declaramos una variable podemos asignarle un valor siguiendo el formato a continuación descrito:

variable = expresión;

Donde "expresión" puede ser cualquier expresión en Java que devuelva un valor acorde con el tipo de dato de la variable.

Ejemplos:

int p, k, v;
p = 30;
k = p + 20;
v = k * p;

También es posible asignar un valor inicial a una variable en la misma declaración:

Ejemplos:

int num = 5; // Declara la variable y la inicializa.
int p, n = 7; // Declara dos variables e inicializa sólamente la segunda.

Literales.

Un literal es un valor constante que se puede asignar directamente a una variable o puede ser utilizado en una expresión.

Existen cuatro tipos de literales básicos, que coinciden con los cuatro grupos de tipos básicos en Java (Númericos enteros, numéricos decimales, booleanos y carácter). Cuando se utilicen estos literales en una expresión debemos tener en cuenta lo siguiente:

a) Los literales numéricos enteros se consideran de tipo int. (byte b = 10;)
b) Los literales numéricos decimales se consideran de tipo double (float p = 3.14; // Provoca un error de compilación por la ausencia del cracter "f").
c) Los literales boolean son true y false (boolean b = 0; // Provoca un error de compilación debido a que en Java no se permite utilizar valores fuera de true o false).
d) Los literales de tipo char se escriben entre comillas simples (char car = '#'; char p = '\u03AF').

Nota importante: Dado que un carácter es realmente un número entero, también puede asignarse directamente a una variable de tipo char el literal entero correspondiente a la combinación Unicode del carácter deseado.

Ejemplo:

char c = 231; // Se almacena el carácter cuyo código Unicode es 231.

Ámbito de las variables.

Segun dónde esté declarada una variable, ésta puede ser:

a) Campo o atributo: Se les llama así a las variables que se declaran al principio de la clase, fuera de los métodos. Éstas son compartidas por todos los métodos de la clase y suelen declararse como "private" para limitar su uso al interior de clase. Las variables atributo pueden ser utilizadas sin haber sido inicializadas de manera explícita, ya que se inicializan implícitamente cuando se crea un objeto de la clase.

b) Variable local: Son variables que se declaran dentro de un método, su ámbito de utilización está restringido al interior del método y no admite ningún tipo de modificador. Una variable local se crea en el momento en que se hace la llamada al método, destuyéndose cuando finaliza la ejecución de éste. Toda variable local debe ser inicializada explícitamente antes de ser utilizada. Las variables locales también pueden estar declaradas dentro de bloques de código, siendo su ámbito éste mismo.

Valores por defecto de una variable.

Como se mencionó anteriormente las variables de tipo atributo son inicializadas implícitamente antes de su utilización. Los valores por defecto o predeterminados están en función del tipo de dato de cada variable.

a) Para las variables de tipo byte, short, int y long el valor por defecto es "0" (cero).
b) Para las variables de tipo char el valor por defecto es "\u0000" (caracter nulo).
c) Para las variables de tipo double el valor por defecto es "0.0" (cero punto cero).
d) Para las variables de tipo boolean el valor por defecto es "false" (falso).
e) Para las variables de tipo objeto el valor por defecto es "null" (nulo, sin referencia).

Las variables locales no son inicializadas de manera implícita, siendo necesario asignarles un valor antes de que sean utilizadas; de lo contrario se generará un error de compilación al tratar de utilizar una variable sin valor.

Conversiones de tipo.

Java es un lenguaje fuertemente tipificado, lo que significa que es bastante estricto al momento de asignar valores a una variable. El compilador sólo permite asignar un valor del tipo declarado en la variable; no obstante, en ciertas circunstancias es posible realizar conversiones que permiten almacenar en una variable un tipo diferente al declarado.

En Java es posible realizar conversiones en todos los tipos básicos, con excepción de boolean, que es incompatible con el resto de los tipos.

Las conversiones de tipo pueden realizarse de dos maneras: implícitamente y explícitamente.

Conversión implícita.

Las conversiones implícitas se realizan de manera automática, es decir, el valor o expresión que se va a asignar a una variable es convertido automáticamente por el compilador, antes de almacenarlo en la variable.

Ejemplo:

int i;
byte b = 30;
i = b;

En este ejemplo, el dato de tipo byte almacenado en la variable "b" es convertido en "int" antes de asignarlo a la variable "i".

Para que una conversión pueda realizarse de manera automática (implícitamente), el tipo de la variable destino debe ser de tamaño igual o superior al tipo de origen, si bien esta regla tiene dos excepciones:

a) Cuando la variable destino es entera y el origen es decimal (float o double), la conversión no podrá ser automática.
b) Cuando la variable destino es "char" y el origen es numérico; independientemente del tipo específico, la conversión no podrá ser automática.

El siguiente listado contiene ejemplos de conversiones implícitas:

// Declaraciones.
int k = 5, p;
short s = 10;
char c = 'ñ';
float h;

// Conversiones implícitas.
p = c; // Conversión implícita de char a int.
h = k; // Conversión implícita de int a float.
k = s; // Conversión implícita de short a int-

Por otro lado, los siguientes ejemplos de conversión implícita provocarían un error.

// Declaraciones.
int n;
long c = 20;
float ft = 2.4f;
char k;
byte s = 4;

// Conversiones implícitas.
n = c; // Error, el tipo destino es menor al tipo origen.
k = s; // Cuando la variable destino es "char" y el origen es numérico; independientemente del tipo específico, la conversión no podrá ser automática.
n = ft; // Cuando la variable destino es entera y el origen es decimal (float o double), la conversión no podrá ser automática.

Conversiones explícitas.

Cuando no se cumplan las condiciones para una conversión implícita, ésta podrá realizarse de manera explícita utilizando la siguiente expresión:

variable_destino = (tipo_destino) dato_origen;

Con esta expresión obligamos al compilador que convierta "dato_origen" a "tipo_destino" para que pueda ser almacenado en "variable_destino".

A esta operación se le conoce como "casting" o "estrechamiento" ya que al convertir un dato de un tipo definido a otro más pequeño se realiza un estrechamiento que, en algunos casos, puede provocar una pérdida de datos o precisión, aunque ésto no provocará errores de compilación.

Los siguientes son ejemplos de conversiones explícitas:

// Declaraciones.
char c;
byte k;
int p = 400;
double d = 34.6;

// Conversiones explícitas.
c = (char)d; // Se elimina la parte decimal (trunca), no se redondea.
k = (byte)p; // Se provoca una pérdida de datos, pero la conversión es posible.

---------------------------------------------------------------------------
Lunes 11 de mayo del 2mil9.
Jhanno Foulds Gaunt - Km3