Definición.
El Lenguaje Unificado de Modelado (UML por sus siglas en inglés) es un lenguaje para la visualización, especificación y documentación de software, por lo que resulta independiente del método que se utilice para el desarrollo. No es un método sino una notación, pues no especifica un proceso; lo que se hace es describir el resultado de alguna etapa del desarrollo de un sistema mediante una serie de diagramas.
La idea general de UML, así como de todas las notaciones de modelado orientados a objetos, es centrarse más en los objetos que en los procesos o algoritmos.
Historia.
UML fue desarrollado a mediado de los 90s por Grady Boch, James Rumbaugh e Ivar Jacobson, en la Rational Software Corp., que ahora forma parte de IBM. Actualmente UML es mantenido por el la Object Management Group (OMG) organización sin fines lucro que promueve la estandarización de las tecnologías orientadas a objetos emitiendo lineamientos y especificaciones como UML.
Aspectos generales.
En términos muy generales UML define una notación que se expresa con diagramas. Para mostrar las diferentes perspectivas del modelado, UML define 9 tipos de diagramas:
Versión estandarizada del lenguaje de programación C, desarrollada por un comité afiliado al Instituto Estadounidense de Estándares Nacionales (ANSI). La opinión general es que este estándar es necesario para eliminar las incompatibilidades introducidas por los desarrolladores de compiladores C propietarios. Por otro lado, la adopción de este estándar es muy amplia por lo que, si los programas creados lo siguen, el código es portátil entre plataformas y/o arquitecturas.
Bibliografía consultada:
Diccionario de términos de computación, Bryan Pfaffenberger, pág. 27, Séptima Edición 1999, Editorial Prentice Hall.
Unidad de aritmética y lógica. Parte de la unidad central de procesamiento (CPU) que toma todas las decisiones del microprocesador, con base en la ejecución de operaciones aritméticas y funciones lógicas.
El lenguaje de programación Ada se desarrolló bajo el patrocinio del Departamento de Defensa de los Estados Unidos durante la década de los setenta y los primeros años de la década de los ochenta. Cientos de lenguajes independientes se utilizaron para producir los sistemas de software masivos de comando y control del departamento de defensa. Éste quería un solo lenguaje que pudiera satisfacer la mayoría de sus necesidades.
El nombre del lenguaje es en honor de Lady Ada Lovelace, hija del poeta Lord Byron. A Lady Lovelace se le atribuye el haber escrito el primer programa para computadoras en el mundo, a principios de la década de 1800 (para la Máquina Analítica, un dispositivo de cómputo mecánico diseñado por Charles Babagge). Una de las características importantes de Ada se conoce como multitarea, la cual permite a los programadores especificar que muchas actividades ocurren en paralelo. Java, a través de una técnica que se conoce como subprocesamiento múltiple, también permite a los programadores escribir programas con actividades paralelas.
Bibliografía consultada:
Como programar en Java, Deitel & Deitel, pág. 10, Séptima Edición 2008, Editorial Pearson Education.
Es el proceso de simplificar un problema complejo enfocándose tan sólo en los aspectos relevantes para la solución. En el desarrollo de software esto significa centrarse en lo que es y hace un objeto antes de decidir cómo debería ser implementado.
En Java, un paquete (package) es un contenedor para un grupo de clases relacionadas que un programador puede importar.
Una clase puede definirse como perteneciente a un paquete (package) y puede usar otras clases definidas en ese o en otros paquetes. Si una clase no se define en un paquete se dice que esa clase se encuentra en un paquete por omisión (default). Por ejemplo podemos definir a una clase Perro en el paquete Mascotas y a una clase Animal y Elefante en otro paquete denominado Zoológico:
El nombre de una clase debe ser único dentro del paquete donde se define, de tal forma que no válido declarar dos veces la clase Perro en el paquete Mascotas. Por ejemplo:
Sin embargo dos clases con el mismo nombre en dos paquetes distintos pueden coexistir. Esto nos permite reusar el mismo nombre de una clase dada en diversos contextos. Por ejemplo:
Para declarar un paquete utilizamos la palabra clave package seguida del nombre del paquete. Por convención el nombre de los paquetes se escriben en minúsculas.
package nombrePaquete;
Por convención los nombres de los paquetes utilizan el nombre de dominio de Internet con orden inverso. Por ejemplo para el dominio www.profesorjava.com el nombre del paquete quedaría como com.profesorjava. Una vez que se invierte el nombre del dominio, el nombre de la clase quedaría almacenado en com.profesorJava.MiClase. Finalmente cuando se compila un archivo de Java que contiene una declaración package, el archivo de clase resultante se coloca en el directorio especificado por la declaración. Por ejemplo:
Ejemplo:
/**
* Ilustra el uso de los paquetes.
*/
Package miPaquete;
public class MiPaqueteClass
{
public static String imprimir()
{
return "MiPaqueteClass";
} //fin del método imprimir
public static void main( String[] args )
{
System.out.println( "En el interior de " + imprimir() );
} //fin del método main
} //fin de la clase MiPaqueteClass
/**
* Ilustra el uso de los paquetes.
*/
package tuPaquete;
public class TuPaqueteClass
{
public static String imprimir()
{
return "TuPaqueteClass";
} //fin del método imprimir
public static void main( String[] args )
{
System.out.println( "En el interior de " + imprimir() );
} //fin del método main
} //fin de la clase TuPaqueteClass
/**
* Ilustra el uso de los paquetes.
*/
package tuPaquete;
public class NuestroPaqueteClass
{
public static String imprimir()
{
return "NuestroPaqueteClass";
} //fin del método imprimir
public static void main( String[] args )
{
System.out.println( "En el interior de " + imprimir() );
} //fin del método main
} //fin de la clase NuestroPaqueteClass
Las enumeraciones nos permiten declarar un conjunto de constantes representadas por identificadores. Una enumeración es un tipo especial de clase, que se introduce mediante la palabra clave enum y un nombre para el tipo. Al igual que con una clase, las llaves ({ y }) delimitan el cuerpo de una declaración de enum. Dentro de las llaves hay una lista, separada por comas, de constantes de enumeración, cada una de las cuales representa un valor único.
Ejemplo.
Veamos un ejemplo que implementa el juego de Craps e ilustra el uso de las enumeraciones.
/**
* La clase Craps simula el juego de dados Craps
*/
import java.util.Random;
public class Craps
{
//crea un generador de número aleatorios
private Random numerosAleatorios = new Random();
//enumeración con constantes que representan el estado del juego
private enum Estado { CONTINUA, GANO, PERDIO };
private final static int DOS_UNOS = 2;
private final static int TRES = 3;
private final static int SIETE = 7;
private final static int ONCE = 11;
private final static int DOCE = 12;
public void jugar() {
int miPunto = 0; //punto si no gana o pierde en el primer tiro
Estado estadoJuego; //puede contener CONTINUA, GANO o PERDIO
int sumaDeDados = tirarDados(); //primer tiro de los dados
switch( sumaDeDados ) {
case SIETE: //gana con 7 en el primer tiro
case ONCE: //gane con 11 en el primer tiro
estadoJuego = Estado.GANO;
break;
case DOS_UNOS: //pierde con 2 en el primer tiro
case TRES: //pierde con 3 en el primer tiro
case DOCE: //pierde con 12 en el segundo tiro
estadoJuego = Estado.PERDIO;
break;
default: //no ganó ni perdio por lo guarda el punto
estadoJuego = Estado.CONTINUA;
miPunto = sumaDeDados; //guarda el punto
System.out.printf( "El punto es %d \n", miPunto );
break;
} //fin de la estructura switch
//mientras el juego no esté terminado
while( estadoJuego == Estado.CONTINUA ) { //no Gano ni Perdio
sumaDeDados = tirarDados(); //tira los dados de nuevo
//determinar el estado del juego
if( sumaDeDados == miPunto ) //gana haciendo un punto
estadoJuego = Estado.GANO;
else
if( sumaDeDados == SIETE ) //pierde al tirar 7
estadoJuego = Estado.PERDIO;
} //fin de la estructura while
//muestra mensaje de que gano o perdio
if( estadoJuego == Estado.GANO )
System.out.println( "¡Ganaste!" );
else
System.out.println( "¡Perdiste!" );
} //fin del método jugar
//tira los dados, calcula la suma y muestra los resultados
public int tirarDados() {
//selecciona valores aleatorios para los dados
int dado1 = 1 + numerosAleatorios.nextInt( 6 ); //1..6
int dado2 = 1 + numerosAleatorios.nextInt( 6 ); //1..6
int suma = dado1 + dado2;
System.out.printf( "El jugador tiro %d + %d = %d \n",
dado1, dado2, suma );
return suma;
} //fin del método tirarDados
} //Fin de la clase Craps
Observa que por convención las constantes de enumeración se escriben en mayúsculas. Es importante que tengas en cuenta lo siguiente: Java no proporciona una manera fácil de convertir un valor int en una constante enum específica. La aplicación para probar la clase Craps se muestra a continuación:
public class PruebaCraps
{
public static void main( String[] args )
{
Craps app = new Craps();
app.jugar();
} //fin de main
} //fin de la clase PruebaCraps
Al igual que las clases, todos los tipos enum son tipos por referencia. Un tipo enum se declara con una declaración enum, la cual es una lista separada por comas de constantes enum; la declaración puede incluir, de manera opcional, otros componentes de las clases tradicionales, como constructores, campos y métodos. Cada declaración enum declara a una clase enum con las siguientes restricciones:
1. Los tipos enum son implícitamente final, ya que declaran constantes que no deben modificarse.
2. Las constantes enum son implícitamente static.
3. Cualquier intento por crear un objeto de un tipo enum con el operador new produce un error de compilación.
Las constantes enum pueden usarse en cualquier parte en donde puedan usarse las constantes, como en las etiquetas case de las instrucciones switch, y para controlar las instrucciones for mejoradas.
Ejemplo.
Veamos otro ejemplo sobre enum.
/**
* Declara un tipo enum con constructor y variables de instancia,
* junto con métodos de acceso para los
* factores de conversión de pies a pulgadas, pies, yardas,
* centímetros y metros
*/
public enum ConversionPies
{
//Declara constantes tipo enum
PULGADA( 12.0 ),
YARDA( 1.0/3.0 ),
CENTIMETRO( 30.48 ),
METRO( 30.48 / 100.0 );
//variables de instancia
private final double valor;
ConversionPies( double v )
{
valor = v;
} //fin del constructor ConversionPies
public double getValor()
{
return valor;
} //fin del método getValor
} //fin enum ConversionPies
Observa que cada constante enum va seguida opcionalmente por los argumentos que se pasan al constructor de enum. Al igual que los constructores de una clase, un constructor enum puede especificar cualquier número de parámetros, y puede sobrecargarse. Veámos a continuación la aplicación que prueba a la enum ConversionPies.
/**
* Dado un número n de pies calcula su equivalente en pulgadas,
* yardas, centimetros y metros
*/
import java.util.Scanner;
public class LongitudEnPies
{
public static void main( String[] args )
{
Scanner entrada = new Scanner( System.in );
System.out.println( "<<--Calcula la longitud equivalente-->>" );
System.out.print( "Número de pies? " );
double nPies = entrada.nextDouble();
//calcula e imprime las equivalencias
for( ConversionPies pies: ConversionPies.values() )
System.out.printf( "%s = %f\n", pies, nPies * pies.getValor() );
}
} //fin de la clase LongitudEnPies
Para cada enum, el compilador genera el método estátic values que devuelve un arreglo de constantes de enum en el orden que se declararon. Observa que cuando se convierte una constante enum en un objeto String, el identificador de la constante se utiliza como la representación String.
Ejemplo.
El siguiente ejemplo ilustra cómo utilizar el método static range de la clase EnumSet (declarada en el paquete java.util) para mostrar un rango de las constantes de una enum. El método recibe dos parámetros (la primera y la última constantes enum en el rango) y devuelve un objeto EnumSet que contiene todas las constantes entre estas dos constantes.
/**
* Ilustra el uso de los enums.
*/
import java.util.EnumSet;
public class TipoCambio
{
//crea una Enumeración
enum Moneda { PESO, EURO, DOLAR, YEN, LIBRA_ESTERLINA }
public static void main( String[] args )
{
Moneda tipoMoneda = Moneda.PESO;
System.out.printf( "La moneda es %s\n", tipoMoneda );
System.out.println( "Las monedas disponibles:" );
//imprime todas las monedas
for( Moneda m : Moneda.values() )
{
System.out.println( m );
}
System.out.println( "\nMostrar un rango de constantes" );
//imprime las primeras cuatro monedas
for( Moneda m : EnumSet.range( Moneda.PESO,Moneda.YEN ) )
{
System.out.println( m );
}
} //fin del método main
} //fin de la clase TipoCambio
Definición.
