Sintaxis del Lenguaje Java. Algunos de los aspectos generales by pharmphresh36

VIEWS: 78 PAGES: 6

									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.


Saber usar bien el “casting” hará que nuestros programas sean mas eficientes en cuanto al uso de la
memoria ademas de ser mas rapidos en la ejecucion, por ejemplo, añado una porcion del codigo de un
sistema que realize hace ya un buen tiempo.
public Object createValue() throws BasicException {


      Object[] cat = new Object[4];


      cat[0] = m_id == null ? UUID.randomUUID().toString() : m_id;
      cat[1] = m_jName.getText();
      cat[2] = m_CategoryModel.getSelectedKey();
      cat[3] = m_jImage.getImage();
      return cat;
  }


Quiero que observen que el metodo retorna un Object y no un arreglo de Object pero gracias a la
herencia es posible asignarle a un Object una referencia a un arreglo de Object ya que los arreglos
heredan de Object, esto lo abordaremos con mas detalles en temas donde tratemos la POO
(Programación Orientada a Objetos)

Ahora quiero que observen otra porcion de codigo
 public void writeValueEdit(Object value) {
//aqui aplico un casting
Object[] cat = (Object[]) value;
     m_id = cat[0];
     m_jName.setText(Formats.STRING.formatValue(cat[1]));
     m_CategoryModel.setSelectedKey(cat[2]);
     m_jImage.setImage((BufferedImage) cat[3]);

  }

en la linea
Object [] cat = (Objec[])value;

estoy aplicando un casting es decir estoy convirtiendo un Object a un Object[], es esto posible ya que
el Object value en algun lugar se le asigno un Object[], el metodo writeValueEdit bien pudo haber
quedado como:
public void writeValueEdit(Object [ ]value)
pero esto haría que nuestra aplicacion consuma mas memoria

								
To top