Categoría: Programación

1. Wrapper classes (clases envoltura).

• Clases que proveen métodos de objeto a los 8 tipos de datos primitivos de java. Se encuentran el el paquete java.lang.
• Clases wrapper, su constructor y su correspondiente tipo primitivo: Byte(byte ó String) – byte, Short(short ó String) – short, Integer(inst ó String) – int, Long(long ó String) – long, Float(float, double ó String) – float, Double(double ó String) – double, Character(char) – char, Boolena (boolean ó String) – boolean.
• “Encajonamos o envolvemos” (box) tipos primitivos en las clases wrapper, y “sacamos o desenvolvemos” (unbox) los primitivos de la clase wrapper. Autoboxing es la conversión automática del tipo primitivo al wrapper (ej. int a Integer), unboxing es la conversión automática de la clase wrapper a su primitivo correpondiente (ej. Integer a int). Autoboxing (y unboxing) sólo pueden hacerse entre los datos primitivos y sus correspondientes wrappers, es decir entre un Integer y un int, un Float y un float, etc.; no se puede entre un Integer y un short, un Double y un float, etc.

2. String, StringBuilder y StringBuffer.

• La clase String una vez que toma un valor es inmutable. Su contenido no cambia. Las literales String no se repiten, el compilador solo hace una copia, es decir si existe la literal “Version” varias veces en el código, el compilador sólo guardará una. Sin embargo, varios objetos String pueden contener la misma cadena de caracteres, por ejemplo:
  String s1 = new (“Version”);
  String s2 = new(“Version”);  s
  Métodos importantes de String: charAt() , concat(), equalsIgnoreCase(), length(), replace(), substring(), toLowerCase(), toString(), toUpperCase() y trim().
  
• La clase StringBuffer, al contrario, su valor puede cambiar. Métodos importantes: append(), reverse(), toString()
• La clase StringBuilder es idéntica a StringBuffer con la diferéncia que la primera los metodos no son sincronizados, es decir no es segura en multihilos o concurrencia. Métodos importantes: delete(), insert(), toString().

1. Estatuto if.

• Sintaxis:
  a) if ( expresión_boolena ) sentencia_a_ejecutar;
  b) if ( expresión_booleana ) { sentencias_a_ejecutar }
  c) if ( expresión_booleana ) { sentencias_a_ejecutar } else { sentencias_a_ejecutar }
  d) if ( expresión_booleana_1 ) { sentencias_a_ejecutar } else if ( expresion_boolena_2 ) { sentencias_a_ejecutar } else if ( expresion_boolena_3 ) { sentencias_a_ejecutar } ….
• Notas:
  En la estructura if..else if.. sólo ejecutará el bloque de sentencias de la primera condición o expresión que de verdadera, el resto de las condiciones y sentencias serán ignoradas. 

2. Estatuto switch.

• Sintaxis:
  switch (expresión) { case constante1: sentencias_a_ejecutar; [break;] case constante2: …; default: sentencias_a_ejecutar; }
• Notas:
  expresión debe ser una variable, expresión o literal (número) entera: byte, short, char, int, enumeración (enum), excepto long. La constante debe ser una literal o variable final. El bloque default no necesariamente debe ir al final. La sentencia break envía el flujo del programa hasta la siguiente línea después del término de la sentencia switch. Si la expresión coincide con una constante case las sentencias en este bloque case se ejecutarán, si no existe una sentencia break en este bloque de sentencias el flujo pasará por el resto de las sentencias de los bloques case o bloque default siguientes sin importar si la expresión coincide con la constante. Esto también aplica para el bloque default. Sólo puede haber un bloque default en una sentencia switch. Los valores en los case deben ser únicos, si no se marcará error al compilar.

3. Estatuto for.

• Sintaxis:
  for ( estatuto ; condición ; expresión ) { sentencias_a_ejecutar; [break; ] }
  for ( tipo variable  : colección ) { sentencias_a_ejecutar; [break;] }
• Notas:
  estatuto se ejecuta solo una vez y al inicio del ciclo, si la condición es verdadera se ejecutan las sentencias del bloque for y por último se ejecuta expresión. Si existe una sentencia break el flujo del programa continúa en la siguiente línea despues del fin del bloque for. estatuto debe ser una sentencia o código válido y puede contener dos expresiones no declarativas separadas por comas ( i++, y++), pero no se puden combinar sentencias declarativas (int x= 0, int y = 0) ó sentencias declarativas con no declarativas (int i = 0, r = r +1 ). Los tres componentes entre paréntesis pueden ser omitidos, pero los punto y coma no ( for ( ; ; ) { … }  es válido). La segunda forma llamada for-each asigna uno por uno los elementos en colección a variable de la clase o tipo tipo en cada iteración, es decir habrá tantas iteraciones como elementos haya en colección. Colección puede ser un arreglo (array) u otra colección (collection). Debe especificarse forzosamente el tipo (String, int, etc) de la variable dentro del for, si nó el compilador marcará error.

4. Estatuto while.

• Sintaxis:
  while ( expresión ) { sentencias_a_ejecutar; [ break; ] }
• Notas:
  Si expresión es verdadera se ejecutarán las sentencias dentro del bloque. Si existe un sentencia break dentro del bloque while terminará el ciclo y el flujo continuará en la siguiente línea después del término del bloque while.

5. Estatuto do.

• Sintaxis:
  do { sentencias_a_ejecutar [ break; ] } while ( expresión );
• Notas:
  Las sentencias se ejecutarán al menos una vez y hasta que la expresión sea falsa. Si encuentra una sentencia break el ciclo se interrumpe y continúa en la siguiente instrucción después del bloque do.

6. Estatutos break y continue.

• Sintaxis:
  break [identificador];
  continue [identificador];
• Notas:
  Se usan para romper el flujo normal de los ciclos. break termina el ciclo y continua en la linea siguiente del bloque, continue ignora las sentencias siguientes a la instrucción y vuelve al principio del ciclo. Identificador representa el nombre de una etiqueta de un bloque de ciclo exterior, si está presente salta al bloque con esta etiqueta. continue sólo puede estar dentro de un ciclo, si no, el compilador marcará error. break puede encontrarse en un ciclo o en un switch, si no, el compilador marcará error. break con identificador sólo es válido dentro de los ciclos. En caso de break con etiqueta, si salta a un ciclo exterior, termina el ciclo exterior; en el caso de continue, incrementa el ciclo exterior y continua si la expresión de control de este ciclo sigue siendo verdadero.

7. Estatuto assert.

• Sintaxis:
  assert condición [: mensaje ];
  
• Notas:
  Ayuda a saber si los valores de las variables o condición del programa estan entre los parámetros permitidos. Condición debe ser una expresión boolena, que si es verdadera, el flujo del programa continua normalmente, si no, el programa arrojará una excepción del tipo AssertionError. Si mensaje está presente, ésta se pasa al constructor de la excepción y se imprime junto con el mensaje de excepción. Se debe llamar el comando java con el parámetro -enableassertions ó -ea para que el compilador tome en cuenta y compruebe las aserciones. Recomendado su uso sólo para pruebas y depuración. Usando el parámetro -disableassertions ó -da con el comando java desactiva la comprobación de las aserciones. -ea:clase1 -ea:clase2 … habilita sólo la comprobación de aserciones en las clases especificadas; lo mismo aplica para el parámetro -da.

8. Excepciones (Exception).

• Las expeciones son errores que ocurren cuando un programa está corriendo. Se controlan con la sentencia try { sentencias1 } catch (tipo_excepción variable) { sentencias2 }  [ catch …n ] [ finally { sentencias3 } ]. Sentencias1 son las sentencias a ejecutar que probablemente arrojen o arrojan una excepción, tipo_excepción es la clase de excepción que catch controlará, variable el objeto que se inicializará de tipo tipo_excepción, sentencias2 son las sentencias que se ejecutarán si existió la excpeción especificada, sentencias3 son sentencias que se ejecutarán ocurra o no excepción. Checked Exceptions (excepciones revisadas), son excepciones que el compilador exigirá que sean controladas, las Runtime Exceptions (excepciones al momento de ejecución) deben de ser controladas más no las exige el compilador, éstas extienden de la clase java.lang.RunTimeException que a su vez extiende de java.lang.Exception. Para que un método lance excepciones es necesario indicar ésto con el estatuto throws a nivel método y dentro del método colocar la sentencia throw que arrojará la excepción. Todas las excepciones son de la subclase java.lang.Throwable.
• Hay errores que no son controlables, estos son subclases de java.lang.Error.
• Las excepciones más conocidad son:
  ArrayIndexOutOfBoundsException, ClassCastException, IllegalArgumentException, IllegalStateException, NumberFormatException, NullPointerException; todas ellas subclase de RunTimeException. AssertionError, ExceptionInitalizeError, StackOverflowError, NoClassDefFoundError; de la subclase Error.