Modelos Enterprise Java Beans (EJB)

Un Bean es un componente software que tiene la particularidad de ser reutilizable y así evitar la tediosa tarea de programar los distintos componentes de nuevo. Se puede decir que existen con la finalidad de ahorrarnos tiempo al programar.

Un Bean se puede representar desde un botón, un grid de resultados, un panel contenedor o un simple campo de texto, hasta otras soluciones mucho más complejas como conexiones a bases de datos, etc.

Las EJB ofrecen numerosos Beans para Java.
Enterprise Java Beans (EJB) es una plataforma para construir aplicaciones de negocio portables, reutilizables y escalables usando el lenguaje de programación Java.

El contenedor EJB es un programa Java que trabaja en el servidor y que contiene todas las clases y objetos necesarios para el correcto funcionamiento de los EJBs.

El contenedor de componentes EJB está formado tanto por los beans como por los descriptores de despliegue que comunican nuestro trabajo con el contenedor. 
Un descriptor de despliegue se define mediante un fichero XML (descriptor del despliegue, deployment descriptor) en el que se definen todas las características del bean o con anotaciones.
Un descriptor de despliegue ofrece la información del componente a nuestro contenedor EJB y a nuestro entorno de trabajo (bases de datos, arquitectura de la aplicación, etc.).
 
Ejemplo de descriptor de despliegue web.xml:

 

Existen tres tipos de beans definidos, cada uno implementa unas características diferentes y permiten ser combinados entre si:

- Beans de Sesión (Session Beans)

En una aplicación típica, dividida en grandes capas (presentación, lógica de negocio, persistencia y base de datos), los Beans de Sesión viven en la lógica de negocio.
Hay dos grandes tipos de Beans de Sesión:

• Stateless (sin estado)
  
• Stateful (con estado)
  

Stateless no conserva el estado de ninguno de sus atributos de la invocación de un método a otro.
Stateful conserva el estado a lo largo de toda una sesión. Los Beans de Sesión Stateless son los únicos que pueden exponerse como servicios web.
 

- Message-Driven Beans (MDBs)

Viven en la lógica de negocio y los servicios que proveen son parecidos a los Beans de Sesión, con la diferencia de que los MDBs son usados para invocar métodos de forma asincrónica.
Cuando se produce la invocación de un método de un MDB desde un cliente, la llamada no bloquea el código del cliente y el mismo puede seguir con su ejecución, sin tener que esperar indefinidamente por la respuesta del servidor.
El sistema de mensajería asincrónica propone la utilización de una capa intermedia en la comunicación entre el creador y el consumidor del mensaje. En EJB 3, esta capa se llama MOM (Message-oriented Middleware). Básicamente, MOM es un software que permite funcionar como servidor de mensajería, reteniendo los mensajes del productor y enviándolos posteriormente al consumidor en el momento en que esté disponible para recibirlo.

- Beans de Entidad (Entities)

Existen dos tipos BMP y CMP según se gestione la persistencia por parte del bean o del contenedor. Los EJB de entidad están directamente relacionados con los datos de la aplicación, son objetos que mantienen en memoria los datos que maneja la aplicación, las entidades que disponen de persistencia. Los Beans de Entidad normalmente mapean (mantienen una relación en memoria) las tablas de una base de datos relacional, aunque también es posible que mantengan la persistencia de los datos en ficheros, como por ejemplo un xml.

Para poder configurar correctamente un Bean, debemos indicar al contenedor de EJB qué servicios debe proveer a nuestro Bean, y para ello disponemos de los descriptores de despliegue o de las anotaciones en las clases bean. 
 

Anotaciones básicas para los Session Beans

Vamos a visualizar las anotaciones básicas para los Session Beans.

@Stateful

Indica que el Bean de Sesión es con estado. Sus atributos son:
name: por defecto es el nombre de la clase pero se puede especificar otro nombre diferente.
mappedName: Indica si deseamos que el contenedor maneje el objeto de forma específica. Si incluimos esta opción nuestra aplicación podría no ser portable y no funcione en otro servidor de aplicaciones.
description: Indica la descripción de la anotación.

@Stateless

Indica que el Bean de Sesión es sin estado. Sus atributos son:
name: Por defecto el nombre de la clase pero se puede especificar otra diferente.
mappedName: Si deseamos que el contenedor maneje el objeto de manera específica. Al igual que @StateFul esta opción podría hacer que nuestra aplicación no sea portable y no funcione en otro servidor de aplicaciones.
Description: descripción de la anotación.

@Init

Especifica que el método se corresponde con un método create de un EJBHome o EJBLocalHome de EJB 2.1.
Sólo se podrá llamar una única vez a este método. Sus atributos son:
Value: indica el nombre del correspondiente método create de la interfaz home adaptada. Sólo se debe utilizar cuando se utiliza el bean anotado con un bean con estado de la especificación 2.1 o anterior y que disponga de más de un método create.

@Remove

Indica que el contenedor debe llamar al método cuando quiera destruir la instancia del Bean. Sus atributos son:
retainIfException: indica si el Bean debe mantenerse activo si se produce una excepción. Por defecto su valor es false.
@Local
Indica que la interfaz es local.

@Remote

Indica que la interfaz es remota.

@PostActivate

Invocado después de que el Bean sea activado por el contenedor.

@PrePassivate

Invocado antes de que el Bean esté en estado passivate.

Normalmente las anotaciones más empleadas en las aplicaciones serán @Stateless y @Stateful, para indicar el tipo de EJB que estemos utilizando. El resto de anotaciones se utilizarán en casos más particulares.

Roles de EJB dentro de las aplicaciones JEE

La especificación Enterprise JavaBeans está escrita para diferentes públicos, pero podría resumirse en dos niveles diferentes:

El desarrollador del cliente

Un cliente es cualquier usuario de un Enterprise JavaBean y podría ser cualquier aplicación Java del lado del cliente, un servlet o incluso otro EJB.
El desarrollador EJB
La principal responsabilidad del programador de un bean será escribir la lógica de empresa y acciones o propiedades:
  - Deben crearse archivos de clase primarios y un descriptor xml o bien, incluir anotaciones en las clases del bean. Todos estos archivos estarían empaquetados en un JAR.
  - Podríamos tener muchos beans dentro de un único archivo JAR, pero cada archivo JAR contendría únicamente un descriptor del bean xml.
  - El descriptor de implementación debe situarse en un directorio llamado META- INF y no podemos cambiarle el nombre, sigue una especificación estándar.

Estructura de EJB

Todo EJB está compuesto por dos capas.

• Capa Interfaz
  

La capa Interfaz es un contrato que indica a las clases que consuman en el EJB los métodos y características de dicho EJB.

• Capa Implementación
  

La capa de implementación es una clase que implementa la capa de Interfaz.
Una clase que hereda directamente de la interfaz del EJB e implementa los métodos que se hayan incluido en el contrato.

Custom Tags

Un Custom Tag es una etiqueta propia, personalizada, cuyo objetivo será no utilizar código java en las páginas JSP. Se necesitan múltiples ficheros para trabajar: XML y JSP
Definición de etiquetas:

• Archivo tld es el archivo de definición de las etiquetas Custom Tags
  
• Debemos indicar las características de etiquetas que habrá en todo mi proyecto.
  
• El fichero Xml es la descripción de nuestro sitio web
  
• El fichero class es la clase con la lógica java
  
• El fichero JSP es la página para mostrar las etiquetas Custom tags.
  

Necesitamos un fichero descriptor de la estructura de etiquetas que contenga una serie de argumentos obligatorios para trabajar:

• Tlibversion: Versión de la librería
  
• Jspversion: Versión del jsp
  
• Shortname: El nombre del programador
  
• Tagclass: Nombre del paquete, nombre de la clase
  
• Bodycontent: Contenido del cuerpo, si no existe contenido, se pondrá Empty

Ejemplo de tld:

<taglib>
        <tlibversion>1.0</tlibversion>
        <jspversion>2.0<jspversion>
        <shortname>Programeitor<shortname>
        <tag>
                <name>nombreetiqueta</name>
                <tagclass>nombre del paquete y de la clase</tagclass>
                <bodycontent>Es el contenido del cuerpo</bodycontent>
        </tag>
</taglib>

EJEMPLO 1: 

1.Abrimos NetBeans y creamos un nuevo proyecto Java Web llamado ProyectoCustomTags y eligiendo el servidor Apache Tomcat
2.Sobre la carpeta WEB-INF nos crearemos una nueva carpeta que llamaremos FolderTLD
3.Sobre la carpeta FolderTLD agregamos un objeto Tag Library Descriptor y lo llamaremos mensaje
  NewFile > Other > Web >TagLibraryDescriptor
  Escribiremos el siguiente código dentro del fichero mensaje.tld:
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib PUBLIC 
  "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" 
  "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd"> 
<taglib>
 <tlibversion>1.0</tlibversion>
 <jspversion>2.0</jspversion>
 <shortname>mensaje</shortname>
 <tag>   
  <name>primera</name>
  <tagclass>paquetecustomtags.PrimeraEtiqueta</tagclass>
                <bodycontent>empty</bodycontent>
 </tag>
</taglib>
4.Crearemos una clase llamada PrimeraEtiqueta dentro de un paquete que se llamará paquetecustomtags
  Implementamos el siguiente código dentro de la clase para, posteriormente, representarlo en una página JSP:
package paquetecustomtags;

import java.io.IOException;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.TagSupport;
import java.util.*;
import java.text.*;

public class PrimeraEtiqueta extends TagSupport  {
    
    @Override
    public int doStartTag() throws JspTagException
    {
        return SKIP_BODY;
    }

    @Override
    public int doEndTag() throws JspTagException
    {
        String horaactual = this.GetHora();
        try
        {
            JspWriter out = pageContext.getOut();
            out.write("<h1>Bienvenido a mi pagina Custom Tags</h1>");
            out.write("El nombre de mi clase es: ");
            out.write(getClass().getName());
            out.write("<br> y la hora es " + horaactual + "<p/>");
        }catch (IOException ex)
        {
throw new JspTagException("Excepcion al cargar el fichero TLD " +ex.toString());      
}
        return  EVAL_PAGE;
    }

    private String GetHora()
    {
            Date horaactual;
            DateFormat formato;
            String cadhora;
            horaactual= Calendar.getInstance().getTime();
            formato= DateFormat.getTimeInstance();
            cadhora=formato.format(horaactual);
            return cadhora;
    }
}
5.Ahora debemos irnos al descriptor de la aplicación web y seleccionamos el fichero web.xml dentro de la 
  carpeta WEB-INF:
  Si no existe puede crearse en NewFile > Other > Web > StandardDeploymentDescriptor
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web
Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
 <welcome-file-list>
  <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>
 <taglib>
            <taglib-uri>mietiquetacustomtag</taglib-uri>
            <taglib-location>/WEB-INF/FolderTLD/mensaje.tld</taglib-location>
   </taglib>
</web-app>
6.Escribiremos el siguiente código en la página index.jsp para realizar la llamada a la librería Custom Tags 
  que hemos creado:
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<%@taglib uri="mietiquetacustomtag" prefix="MiEtiqueta" %>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <h1>Pagina realizada con Custom Tags</h1>
        <MiEtiqueta:primera/>
    </body>
</html>
-------------------------------------------------------------------------------------------------------------
------------Realizar una página JSP que mostrará una tabla con los datos de los departamentos----------------
1.Creamos un nuevo proyecto Web Application llamado AplicacionCustomTags con servidor Apache Tomcat
2.Sobre la carpeta WEB-INF, nos crearemos una nueva carpeta que llamaremos EtiquetasDEPT.
4.Sobre la carpeta EtiquetasDEPT vamos a agregar un objeto Tag Library Descriptor de la carpeta Web y lo 
  llamaremos etiquetadepartamentos
5.Escribiremos el siguiente código dentro del fichero etiquetadepartamentos.tld:
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib PUBLIC 
  "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.1//EN" 
  "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd"> 
<taglib>
 <tlibversion>1.0</tlibversion>
 <jspversion>2.0</jspversion>
 <shortname>etiquetadepartamentos</shortname>
 <tag>   
  <name>tabladepartamentos</name>
  <tagclass>paquetecustomtags.EtiquetaTablaDept</tagclass>
                <bodycontent>empty</bodycontent>
 </tag>
</taglib>
6.Nos crearemos una clase para poder implementar el código de la etiqueta que acabamos de realizar.

Crearemos la clase en un paquete llamado paquetecustomtags y le pondremos de nombre EtiquetaTablaDept.

Lo que debemos realizar ahora es el acceso mediante JDBC a la tabla EMP de Oracle. Para ello, debemos agregar dentro de la carpeta Libraries el conector JDBC para Oracle.

A continuación, implementaremos el código de la clase EtiquetaTablaDept

 
package paquetecustomtags;
import java.io.IOException;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.TagSupport;
import java.util.*;
import java.text.*;
import java.sql.*;


public class EtiquetaTablaDept extends TagSupport   {
    @Override
    public int doStartTag() throws JspTagException
    {
        return SKIP_BODY;
    }

    @Override
    public int doEndTag() throws JspTagException
    {
        try
        {
            JspWriter out = pageContext.getOut();
            DriverManager.registerDriver(new oracle.jdbc.OracleDriver());
            Connection cn = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE", "SYSTEM", "12345");
            Statement sentencia = cn.createStatement(); //(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
            ResultSet rs = sentencia.executeQuery("SELECT * FROM DEPT");
            out.write("<h1>Datos de los departamentos</h1>");
            String tabla = "<table border='1'>";
            tabla += "<tr><th>Numero</th><th>Nombre</th><th>Localidad</th></tr>";
            while (rs.next())
            {
                tabla += "<tr>";
                tabla += "<td>"+rs.getString(1)+"</td>";
                tabla += "<td>"+rs.getString(2)+"</td>";
                tabla += "<td>"+rs.getString(3)+"</td>";
                tabla += "</tr>";
            }
            tabla += "</table>";
            out.write(tabla);
        }catch (Exception ex)
        {
            throw new JspTagException("Excepcion al cargar el fichero TLD " +ex.toString());
        }
        return  EVAL_PAGE;
    }
}
Ahora debemos irnos al descriptor de la aplicación web.  
Seleccionamos el fichero web.xml dentro de la carpeta WEB-INF y escribimos lo siguiente:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web
Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <taglib>
        <taglib-uri>mietiquetacustomtag</taglib-uri>
        <taglib-location>/WEB-INF/EtiquetasDEPT/etiquetadepartamentos.tld</taglib-location>
    </taglib>
</web-app>
 

Ahora vamos a agregar una pagina JSP que dibujará los empleados que tenemos en la etiqueta Custom Tag.

Le daremos el nombre tabladepartamentos

Implementamos el código para dibujar los departamentos.

 
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<%@taglib uri="mietiquetacustomtag" prefix="tagdept" %>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
        <tagdept:tabladepartamentos/>
    </body>
</html> 

Action Tags

Los Action Tags son etiquetas con formato XML que se incluyen dentro de las páginas JSP y que se pueden utilizar dentro de dichas páginas JSP para llevar a cabo distintas acciones en tiempo de ejecución. Su propósito es tratar de reducir la cantidad de código Java necesario dentro de una página JSP, así como permitir que sea posible crear páginas JSP compuestas (idealmente) de un modo completo por etiquetas.

Los principales action tags son:

• jsp:useBean
• jsp:getProperty
• jsp:setProperty
• jsp:include
• jsp:forward
• jsp:param

<jsp:useBean id="nomBean" scope="scope" class = "clase" />
<jsp:useBean id="nomBean" scope="scope" class = "clase" >
<% código para inicialización  %>
</jsp:useBean>

Ejemplo:

//Utilizo un bean llamado test con las propiedades de class

<jsp:useBean id="test" class="hall.SimpleBean" /> 

//Pongo propiedades a test
<jsp:setProperty name="test" property="message" value="Hello WWW" />
   <H1>Message: <I>
<jsp:getProperty name="test" property="message" />//Regojo propiedades

Los tipos de Scope de la etiqueta useBean son:

• page: La instancia se mantiene solamente para la página
  
• request: La instancia se utiliza en la petición
  
• sesión: La instancia se mantiene dentro del objeto session y puede ser utilizan en otras páginas.
  
• application: La instancia se mantiene dentro del objeto application y tiene el mismo valor para todos los usuarios.
  

Por ejemplo, un Bean que se recupera a partir de un request de session:

 
<jsp:useBean id="mibean" scope="session" class="MiBean" >
<% mibean.init(request.getSession()); %> 
</jsp:useBean>
 

Obtiene el valor de una propiedad de un Bean definido previamente con el tag

 
<jsp:useBean id="mibean" scope="page" class="MiBean" >
<jsp:getProperty name="mibean"  property="MiPropiedad" />
 

Establece el valor de una propiedad de un Bean definido previamente con

 
<jsp:setProperty property="NombrePropiedad" [param="NombreParametro"|value="ValorPropiedad"]>
 
<jsp:setProperty property="Apellidos"  param="txtapellidos" >
 

Si no escribimos el nombre del parámetro y el valor, se asume que el nombre del parámetro es el mismo que el nombre de la propiedad.

 
<input type="text" name="Apellidos">
<jsp:setProperty property="Apellidos">
 

Si se especifica property = "*" todas las propiedades del bean adquieren los valores correspondientes de los parámetros del request.

 
<input type="text" name="Apellidos">
<input type="text" name="Nombre">
 

Presuponemos que en el Bean hemos declarado dos propiedades, llamadas Apellidos y Nombre.

 
<jsp:setProperty property="*">
 

Incluyen recursos dinámicamente en el momento de ejecución de la página JSP.

 
<jsp:include page="url" /> 

Incluimos un recurso en nuestra página y enviamos información en forma de parámetro a dicho recurso.

<jsp:include page="url" >
<jsp:param name="nombre" value="valor" />
</jsp:include>

Pasa el control a otro recurso en forma incondicional.

<jsp:forward> 

redirecciona la página actual a otra página que hayamos escrito en su propiedad page.

<jsp:forward page="url" /> 

Podemos enviar información a la página que estamos redireccionando en forma de parámetro con la etiqueta

<jsp:param>
<jsp:forward page="url" />
<jsp:param name="nombre" value="valor" />
</jsp:forward>

Existen otras etiquetas action tag, pero no se suelen utilizar.

• jsp:plugin genera información para Applets.
  
• jsp:fallback genera texto alterno si no hay soporte Java en el browser (usado con jsp:plugin).
  
• jsp:text transmite datos de patrones.
  
• jsp:output modifica las propiedades del objeto output.
  
• jsp:root

Ejemplo 1: <jsp:include> sin parameters

En este ejemplo usaremos <jsp:include> action tag sin parameters.
index.jsp

<html> 
<head>
<title>JSP Include example</title>
</head>
<body> 
<b>index.jsp Page</b><br>
<jsp:include page="Page2.jsp" /> 
</body> 
</html>

Page2.jsp

<b>Page2.jsp</b><br>
<i> This is the content of Page2.jsp page</i>

Ejemplo 2: Uso de <jsp:include> con  <jsp:param>

index.jsp

<html> 
<head>
<title>JSP Include example with parameters</title>
</head>
<body> 
<h2>This is index.jsp Page</h2>
<jsp:include page="display.jsp"> 
<jsp:param name="userid" value="Chaitanya" /> 
<jsp:param name="password" value="Chaitanya" /> 
<jsp:param name="name" value="Chaitanya Pratap Singh" /> 
<jsp:param name="age" value="27" /> 
</jsp:include> 
</body> 
</html>

display.jsp

<html>
<head>
<title>Display Page</title>
</head>
<body>
<h2>Hello this is a display.jsp Page</h2>
UserID: <%=request.getParameter("userid") %><br>
Password is: <%=request.getParameter("password") %><br>
User Name: <%=request.getParameter("name") %><br>
Age: <%=request.getParameter("age") %>
</body>
</html>

UML - Diagramas en Java

Introducción

El Lenguaje de Modelamiento Unificado UML es un lenguaje gráfico para visualizar, especificar y documentar cada una de las partes que comprende el desarrollo de software.

Análisis Orientado a Objetos (AOO) es un método de análisis que examina los requisitos desde la perspectiva de las clases y objetos.

Diseño Orientado a Objetos (DOO) es el método que crea software desde la perspectiva de las clases y objetos.

Existen diagramas de representación que se dividen según sea:

1.- La Programación Orientada a Objetos (POO) aparece como un método en el que los programas se organizan como colecciones de objetos.

Se representa gráficamente mediante dos diagramas básicos: 

a) Diagrama de Objetos: Representan una vista estructurada de los objetos de un sistema. 

b) Diagrama de Clases: Se utilizan para la estructura de las clases.

2.- El modelo físico es la descripción del hardware o software que componen el sistema. Para representar gráficamente el modelo físico existen dos diagramas: 

 a) Diagrama de Procesos o Actividad: Se usan para indicar la colección física de procesadores y dispositivos que sirven como plataforma de ejecución del sistema.

b) Diagrama de Módulos o Componentes: Se usan para indicar la disposición en capas y la participación física de la arquitectura.

Diagrama de Objetos

Diagrama de Objetos representa a los objetos y sus relaciones. Un objeto se puede definir como un sustantivo que integra una estructura de datos (atributos) y un comportamiento (operaciones).
Hay que identificar las clases, interfaces y otros elementos que participan y las relaciones entre estos elementos.

Diagrama de Clases

Relaciones entre las clases que involucran el sistema, las cuales pueden ser asociativas, de herencia, de uso y de contenido. 
El analista se entrevista con el cliente y se deben tomar apuntes. Se buscarán las clases para los objetos del modelo buscando los sustantivos (ej: proveedor, pedido, factura, etc.). Después se verá que algunos de estos sustantivos pueden ser atributos de otros en vez de entidades por si mismas. También se buscarán los métodos para estas clases buscando los verbos (ej: Calcular, imprimir, Agregar,..). 
Un diagrama de clases esta compuesto por los siguientes elementos: Clase: atributos, métodos y visibilidad. Relaciones: Herencia, Asociación, Ensamblado y Uso.

Diagramas de Actividades

Se define como un proceso en el los objetos realizan una serie de acciones, donde los objetos pueden ser personas, componentes de software o equipos.Es usado para especificar un método o un caso de uso.

Diagramas de Interaccion

Los diagramas de interacción son modelos que describen la manera en que colaboran diferentes grupos de objetos.
Hay dos tipos de diagramas de interacción:
1.- Diagramas de secuencia describe las interacciones entre un grupo de objetos mostrando de forma secuencial los envíos de mensajes.
2.- Diagramas de colaboración es una forma de representar interacción entre objetos.

Diagramas de Estados

Los diagramas de estados muestran el comportamiento de un objeto durante su vida, junto con los cambios que permiten pasar de un estado a otro.
Se dibujan para una sola clase, mostrando el comportamiento de un solo objeto durante todo su ciclo de vida.
Queda representado principalmente por los siguientes elementos: estado, elemento y transición.

Casos de Uso

Los casos de uso son una secuencia de interacciones entre un sistema y alguien o algo que usa alguno de sus servicios. 

Para definir secuencias de transacciones en los casos de uso hay que seguir los siguientes pasos:

1.- Identificación de los actores que se comunicarán con el sistema.

2.- Tareas del actor.

3.- Accesos de lectura o escritura del actor.

3.- Cambios fuera o dentro del sistema relacionados con el actor.

4.- Identificar que eventos debe responder el sistema y hacer una la lista.

5.- Asociar una secuencia de transacciones o interacciones para cada evento identificada.

Modelo CRC (Clase-Responsabilidad-Colaborador)

Un Modelo CRC es un conjunto de tarjetas  que representan las Abstracciones Clave, verbos o sustantivos de un caso de uso no referidos a un objeto real. Es una colección de tarjetas cada cual representa una clase.

Patron de Diseño

 Los patrones de diseño son la base para la búsqueda de soluciones a problemas comunes en el desarrollo de software y otros ámbitos referentes al diseño de interacción o interfaces.

Clase Math

La clase Math tiene como función redondear al alza o a la baja el valor de un número decimal. Sus tres posibles casos son:

1. Math.ceil: su redondeo será siempre eligiendo el número entero mas alto respecto al decimal.
Ejemplo:
System.out.println(Math.ceil(2.2);// muestra por consola 3.0

2. Math.floor: cuyo redondeo será siempre eligiendo el número entero mas bajo respecto al decimal.
Ejemplo:
System.out.println(Math.floor(2.2);// muestra por consola 2.0

3. Math.rint: su redondeo será siguiendo los criterios habituales del redondeo en matemáticas, pudiendo redondear igualmente eligiendo números decimales pero en base a 10.
Ejemplo:
Math.rint(1.82);// muestra por consola 2
Math.rint(1.48);// muestra por consola 1
Math.rint(1.823*100/100);//muestra por consola 1.82
Math.rint(1.873*10/10);//muestra por consola 1.9

RandomAccessFile

La clase RandomAccessFile tiene como función leer o escribir en un archivo con acceso aleatorio. Es bastante similar a la clase File.

Uso: 

1. Creamos un acceso aleatorio a un archivo en c: con acceso únicamente de lectura r:

   RandomAccessFile nombre = new RandomAccessFile("c://archivo", "r"); 

2. Creamos un acceso aleatorio a un archivo en c: con acceso únicamente de lectura y escritura rw:

   RandomAccessFile nombre = new RandomAccessFile("c://archivo", "rw"); 

Ejemplo:

import java.io.*;
import java.util.Scanner;
public class NewClass {
    public static void main(String args[]) {
        int numero = 5;
        try {
           // Creamos un nuevo RandomAccessFile de nombre raf en modo lectura escritura
           RandomAccessFile raf = new RandomAccessFile("c:/test.txt", "rw");
            // Escribimos algo en el archivo
           raf.writeUTF("Hola Gente");
           // Ponemos el puntero en el inicio 0
           raf.seek(0);
           // Leemos e imprimimos el contenido en pantalla
           System.out.println("" + raf.readUTF());
           //nos situamos con el puntero al final del archivo
           raf.seek(raf.length());
           //Escribimos un numero 5 al final del archivo
           raf.writeInt(numero);
           // Cerramos raf para liberar recursos
           raf.close();
           } catch (IOException ex) {
                ex.printStackTrace();
           }
       }
}