ENUMERADOS
Los enumerados son un tipo especial de datos, que nos permite definir
un conjunto de constantes relacionadas entre sí y que nos asegura que una
variable (atributo) de este tipo en un momento concreto sólo podrá tomar un
valor y que a demás este valor será únicamente uno de los establecidos en el
enumerado. Por ejemplo en la clase Coche tenemos el enumerado Orientación,
este enumerado nos asegura que el atributo orientación de un Coche sólo
podrá valer CENTRO, DERECHA o IZQUIERDA. Para definir un
enumerado se utiliza la palabra enum.
public enum
Orientacion {
CENTRO, IZQUIERDA, DERECHA
}
public class Coche
implements IDesplazable {
private String marca;
private String modelo;
private
int velocidad;
private Orientacion
orientacion; .
.
.
public void girarAlCentro() {
this.orientacion
= Orientacion.CENTRO;
}
PAQUETES
Un paquete permite agrupar clases con características y/o
comportamientos similares o relacionadas. Es un mecanismo de organización de
clases. Cuando
los programas son relativamente grandes o se trabaja en equipo, es recomendable
dividir el código en varios archivos fuente. Las razones son las siguientes:
a)
el tiempo necesario para la compilación de todo el código cada vez que
se haga una modificación mínima en una clase: si cada clase se almacena en un
archivo fuente sólo será necesario la compilación de aquellos archivos que se vayan
modificando y necesiten ser recompilados.
b)
favorece la eficiencia del trabajo en equipo ya que la edición
simultánea de un único archivo fuente por varios programadores es complicada:
es preferible dividir el código fuente en archivos y que cada programador se
responsabilice de uno o varios de ellos.
c)
incrementa la facilidad para localizar y controlar los accesos a las
clases e interfaces y evitar conflictos con identificadores.
Los
paquetes nos permiten realizar todo esto. Por ejemplo podemos agrupar las
clases básicas (Coche y Orientación) de nuestra aplicación en un paquete
llamado entidades y la clase principal (Main) en otro paquete llamado principal.
El
paquete al que pertenece una clase se indica antes definir la clase con la
palabra package. Para utilizar clases de un paquete en otro debemos
importarlas mediante la palabra import. Tal y como hacemos en la clase
Main, para poder utilizar Coche y Orientación).
package principal;
import entidades.Coche;
import entidades.Orientacion;
public class Main {
public static void main(String[]
args) {
Coche coche1 = new Coche("Ferrari", "F430", 0,
Orientacion.CENTRO, 0, 0);
System.out.println(coche1);
coche1.arrancar();
coche1.acelerar();
coche1.acelerar();
coche1.mover();
.
.
.
}
}
ESTRUCTURAS
CONDICIONALES
Nos permite realizar distintas acciones dependiendo de una condición.
Las más importantes son las estructuras if-else y switch.
public class Coche
implements IDesplazable {
private String marca;
.
.
public void frenar()
{
if (velocidad
!= 0)
velocidad--;
else
System.out.println("No se puede ir hacia atrás.");
}
public void mover()
{
switch (orientacion) {
case CENTRO:
posicionY += velocidad;
break;
case IZQUIERDA:
posicionX = posicionX - velocidad;
break;
case DERECHA:
posicionX += velocidad;
break;
default:
break;
}
}
.
.
}
BUCLES
Son estructuras que nos permiten repetir una serie de pasos, un
determinado número de veces. Son muy útiles pues reducen la cantidad de código
que hay que escribir y permiten repetir tareas rutinarias el número de veces
que nos interese. Las más importantes son for, while y do-while.
Por ejemplo los siguientes códigos son equivalentes, muestra los números de 0
al 9.
for (int i = 0; i<10 i="i" o:p="o:p">
System.out.println("Hola
soy el número: " + i);
}
int i = 0;
while (i < 10) {
System.out.println("Hola
soy el número: " + i);
i++;
}
int i = 0;
do {
System.out.println("Hola
soy el número: " + i);
i++;
} while (i < 10);
EXCEPCIONES
Mecanismo proporcionado por Java para notificar errores en tiempo
de ejecución.
- La información del error, excepción, es un objeto que
se propaga a todos los objetos afectados por el error.
- Las excepciones pueden tratarse con el propósito de dar una solución
al error: recuperación de errores.
- Si no se tratan las posibles excepciones el programa podría terminar
de forma repentina.
Para indicar que una clase o método puede producir una excepción se
utiliza la palabra clave throw seguida por un nuevo objeto del tipo de
excepción lanzada. Un ejemplo de excepción podría se controlar que la velocidad
de un coche no pueda ser negativa. Esto se podría comprobar en el método
setVelocidad() en la clase Coche de la siguiente forma:
public class Coche
implements IDesplazable {
private String marca;
.
.
.
public void setVelocidad(int
velocidad) {
if (velocidad < 0) throw
new IllegalArgumentException("No
se permite una velocidad
negativa.");
this.velocidad
= velocidad;
}
Para capturar y tratar una posible excepción Java ofrece la construcción
try-catch. Esta construcción está formada por:
- Bloque try: bloque que encierra código que puede lanzar
excepciones.
- Bloques catch o manejadores: uno o varios bloques
encargados de dar tratamiento a las excepciones.
- Bloque finally: bloque que siempre se ejecuta, se produzca o
no excepción.
Podemos captura la excepción producida en la clase Main de la
siguiente forma:
public class Main {
public static void main(String[] args) {
.
.
int intentos = 0;
while (intentos
< 3) {
try {
// Establece la velocidad a un valor no permitido
coche1.setVelocidad(-5);
}
catch (IllegalArgumentException
e){
intentos++;
System.out.println(e.toString());
}
finally {
//coche1.setVelocidad(0);
}
if (intentos
== 3)
System.out.println("Se han capturado tres
excepciones.");
}
}
Pensad ahora que pasaría si quitamos los comentarios de la línea:
coche1.setVelocidad(0);