% Activate the following line by filling in the right side. If for example the name of the root file is Main.tex, write
% "...root = Main.tex" if the chapter file is in the same directory, and "...root = ../Main.tex" if the chapter is in a subdirectory.
 
%!TEX root =  ../notas_java.tex

\chapter[Modelado de Objetos]{Modelado de Objetos}

\section{Modelos de especificación del Dominio: La técnica CRC}

En la fase de diseño del desarrollo de software, una de las tareas es descubrir las estructuras que hacen posible la implementación de un conjunto de tareas en una computadora. Cuando se utiliza el proceso de diseño orientado a objetos, se tienen llevar a cabo las siguientes tareas:

1. Descubrir clases.

2. Determinar las responsabilidades de cada clase.

3. Describir las relaciones entre las clases.

Una clase representa un concepto útil. Por ejemplo, suponga que su trabajo consiste en imprimir una factura, como la que se muestra enseguida

\begin{verbatim}
                        F A C T U R A 

Sam
Calle Principal #100
Algun pueblo, Mexico 98765

Descripcion                     Precio  Cda   Total
Tostador                         29,95    3   89,85
Secador de Cabello               24,95    1   24,95
Aspiradora                       19,99    2   39,98

CANTIDAD A PAGAR: $  154,78
\end{verbatim}

Las clases obvias que vienen a la mente son de factura, partida, y el Cliente. Es una buena idea tener una lista de clases de candidatos en una pizarra o una hoja de papel. Como una lluvia de ideas, sólo tiene que poner todas las ideas para las clases en la lista. Siempre se puede tachar los que no eran útiles.

Cuando estemos buscando clases, debemos tener los siguientes puntos en mente:

• Una clase representa un conjunto de objetos con el mismo comportamiento. Entidades con varias apariciones en la descripción del problema, tales como clientes o productos, serán buenos candidatos para definirlos como objetos. Descubre lo que tienen en común, y diseñe clases que capturen esos puntos en común.

• Algunas entidades deben ser representadas como objetos, otros como tipos primitivos. Por ejemplo,  ¿Una dirección debe ser un objeto de una clase de agenda, o deberá ser simplemente una cadena? No hay una respuesta-que sea perfecta depende de la tarea que desea resolver. Si el software tiene que analizar las direcciones (por ejemplo, para determinar los gastos de envío), entonces, la clase que represente al objeto dirección será apropiado. Sin embargo, si su software nunca necesitará esa capacidad, no debe perder el tiempo en un diseño excesivamente complejo. Es su trabajo encontrar un diseño equilibrado, que no esté demasiado limitado ni excesivamente general.

• No todas las clases se pueden descubrir en la fase de análisis. Los programas más complejos necesitan clases para fines tácticos, tales como archivo o base de datos de acceso, interfaces de usuario, mecanismos de control, y otras más.

• Algunas de las clases que usted necesita ya existen, ya sea en la biblioteca estándar o en un programa que ha desarrollado previamente. También puede ser capaz de utilizar la herencia para extender las clases existentes en clases que coincidan con sus necesidades.

Una vez que se ha identificado un conjunto de clases, es necesario definir el comportamiento de cada clase. Es decir, usted necesita saber qué métodos tiene cada objeto tiene y qué hacer para resolver el problema de programación. Una regla sencilla para encontrar estos métodos es la búsqueda de verbos en la descripción de la tarea y, a continuación verificar si los verbos coinciden con los objetos apropiados. Por ejemplo, en el programa de factura, la clase necesita calcular la cantidad total debida. Ahora hay que averiguar qué clase es responsable de este método. ¿Los clientes calculan lo que deben? ¿Los facturas la cantidad debida? ¿Los elementos el total?  La mejor opción es calcular la cantidad debida como responsabilidad de la clase Factura.

Una excelente manera de llevar a cabo esta tarea es el método de tarjetas CRC. CRC es sinónimo de Clases, Responsabilidad, Colaboradores, y en su forma más simple, el método funciona de la siguiente manera: Use una tarjeta para cada clase u objeto, al pensar en los verbos recuerde que describen la tareas que deben ser implementadas por los métodos y al elegir la tarjeta de la clase que usted cree que debería ser responsable y escribir la responsabilidad en la tarjeta. A continuación se presenta un ejemplo de tarjeta CRC 

\begin{center}
\begin{tabular}{|c|c|}
\hline
 \multicolumn{2}{|c|} { C l a s e s  }\\
\hline
R e s p o s a b i l i d a d e s  & C o l a b o r a d o r e s  \\
\hline
&\\
\hline
&\\
\hline
&\\
\hline
&\\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

Para cada responsabilidad, se requieren otras clases para cumplir tal cometido. Estas clases son los colaboradores.

Por ejemplo, supongamos que usted decide que una factura se debe calcular la cantidad debida. A continuación, se escribe calcular cantidad debida en el lado izquierdo de una ficha con la Factura título.

Si una clase se puede llevar a cabo esa responsabilidad por sí mismo, no hacer nada más. Pero si la clase necesita la ayuda de otras clases, escribir los nombres de estos colaboradores en el lado derecho de la tarjeta.
Para calcular el total de la factura tiene que pedir a cada elemento de línea sobre el precio total. Por lo tanto, la clase partida es un colaborador.

A continuación se muestra la Tarjeta CRC con esta información para la clase Factura.

\begin{center}
\begin{tabular}{|c|c|}
\hline
 \multicolumn{2}{|c|} { F a c t u r a  }\\
\hline
Calcular el total a pagar   & Partida \\
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

\section{Diagrama de Clases (modelo conceptual)}

En el diseño de un programa, es útil documentar las relaciones entre las clases. Esto le ayudará de muchas maneras. Por ejemplo, si usted encuentra clases con comportamiento común, puede ahorrar esfuerzo, colocando el comportamiento común en una superclase. Si usted sabe que algunas clases no están relacionados entre sí, se pueden asignar diferentes programadores para implementar cada uno de ellas, sin tener que preocuparse de que uno de ellos tiene que esperar a que el otro.

La herencia es una relación muy importante, pero resulta,  que no es la única relación útil, y puede ser usado en exceso.

La herencia es una relación entre una clase general (a la que se denomina superclase) y una clase más especializada (la subclase). Esta relación se describe a menudo como la relación ``... es un ..." por ejemplo ``Cada camión es un vehículo". Cada cuenta de ahorros es una cuenta bancaria. Cada círculo es una elipse (con la misma anchura y altura).

A veces se abusa de la Herencia, sin embargo. Por ejemplo, considere una clase neumático que describe un neumático de coche. ¿Pero  la clase neumático debe ser una subclase de la clase Círculo? Suena conveniente. Hay un buen número de métodos útiles en  la clase Círculo por ejemplo, la clase de neumático puede heredar métodos que calculan el área, el perímetro, y el punto central, que debería ser útil en la elaboración de formas de neumático. Aunque puede ser conveniente para él programador, esta disposición no tiene sentido conceptualmente. No es cierto que todos los neumáticos son un círculos. Los neumáticos son piezas de automóviles, mientras que los círculos son objetos geométricos. Existe una relación entre los neumáticos y círculos, sin embargo un neumático tiene un círculo como perímetro. Java nos permite modelar este tipo de relación  utilizando variables de instancia:

\begin{verbatim}
public class Neumatico {
	private String rating;
	private Circulo [ ] limite;
}
\end{verbatim}

El término técnico para esta relación es la agregación. Por lo tanto decimos que un agregado de la clase  neumático son los objetos Circulo. En general, decimos que una clase tiene agregados de otra clase, si tiene objetos de la otra clase.

Aquí hay otro ejemplo. Cada coche es un vehículo. Cada coche tiene un neumático (de hecho, tiene normalmente cuatro o, si se cuenta el de repuesto, cinco). Por lo tanto, debe utilizar la herencia del vehículo y usar la agregación de los objetos del neumático:

\begin{verbatim}
public class Carro extends Vehicle {
	private Neumatico[ ] neumaticos;
. .. }
\end{verbatim}

En este capitulo utilizaremos la notación UML para los diagramas de clases. En la notación UML utilizaremos para la herencia, una flecha con un Triángulo abierto  que apunta a la superclase. En la notación UML, la agregación se denota por una línea sólida con un símbolo en forma de diamante siguiendo a la clase de agregación. La Figura \ref{fig:Carro} muestra un diagrama de clases con una herencia y una relación de agregación.


\begin{figure}[!htp]
   \centering
   \centerline{\psfig{figure=Capitulo_5/figuras/Carro.eps, width=4.0cm}}
   \caption{Diagrama UML para un vehículo}
   \label{fig:Carro}
\end{figure}

La relación de agregación se refiere a la relación de dependencia, recordemos que una clase depende de otro si uno de sus métodos utiliza un objeto de la otra clase de alguna manera. Por ejemplo, muchas de nuestras aplicaciones dependen de la clase de escáner, ya que utilizan un objeto escáner para leer la entrada.

Utilizaremos la notación UML para los diagramas de clases. Por ejemplo, una clase puede utilizar la clase escáner sin tener que declarar una variable de instancia del explorador de clases. La clase puede simplemente construir una variable local del tipo de escáner, o sus métodos puede recibir objetos de escáner como parámetros. 

En general, es necesario agregación cuando un objeto tiene que recordar otro objeto entre llamadas a métodos. La notación UML para la dependencia es una línea discontinua con una flecha abierta que apunta a la clase dependiente.

En La siguiente Tabla muestra un resumen de los cuatro símbolos de relación UML que utilizamos para el desarrollo de Programas orientados a objetos.

\begin{center}
\begin{tabular}{|c|c|c|c|}
\hline
Relación                        & Símbolo & Estilo de linea & Tipo de flecha\\
\hline
Herencia                        & ---------------$\triangleright$ & Solida &  Triángulo\\ 
Interface implementada & - - - - - - - $\triangleright$ & Punteada & Triángulo \\ 
Agregación & $\diamond$--------------- & Solida & Diamante \\ 
Dependencia                 & - - - - - - -$\rightarrow$ & Punteada &  Abierta\\
\hline
\end{tabular}
\end{center}

\section[Ejemplos prácticos]{Ejemplos prácticos para descubrir Clases y Métodos utilizando la Técnica CRC}

Como ejemplo de aplicación consideraremos el caso de una Factura. Una vez desarrollado el proceso de lluvia de ideas, para este ejemplo tomemos en cuenta que tiene 4 clases y los diagramas CRC son:

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{F a c t u r a}  }\\
\hline
Formato de la Factura   & Partida \\
\hline
Agregar un producto y cantidad & Cliente\\
\hline
 Calcular el total  & \\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
   & \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{P a r t i d a} }\\
\hline
Formato de la Partida   & Producto \\
\hline
 Calcular el precio total & \\
\hline
  & \\
\hline
   & \\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{C l i e n t e} }\\
\hline
Formato para desplegar clientes  &  \\
\hline
  & \\
\hline
  & \\
\hline
   & \\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{P r o d u c t o}}\\
\hline
Obtener la descripción del producto &  \\
\hline
Obtener el precio del producto  & \\
\hline
  & \\
\hline
   & \\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

Después de haber descubierto las clases y sus relaciones con tarjetas CRC, se deben registrar en los diagramas UML. Las relaciones de dependencia estarán en la columna de la colaboración de las tarjetas CRC. Cada clase depende de las clases con las que colabora. 

En nuestro ejemplo, la clase Factura colabora con la Cliente, Partida, y las clases de productos. La clase Partida colabora con la clase Producto. Por lo tanto, los agregados de la clase de Factura a las clases de Dirección y Partida. Los agregados de clase Partida la clase de Productos. Sin embargo, no hay una relación entre una Factura y un Producto. Una Factura no almacena productos directamente se almacenan en los objetos Partida. Finalmente No hay herencia en este ejemplo. En la Figura \ref{fig:Factura} se presenta el diagrama UML con todas sus dependencias.

\begin{figure}[!htp]
   \centering
   \centerline{\psfig{figure=Capitulo_5/figuras/Factura.eps, width=10.0cm}}
   \caption{Diagrama UML para generar una Factura}
   \label{fig:Factura}
\end{figure}

La implementación en Java queda como:

\begin{verbatim}
package Factura;

/**
 * Metodo Imprime la Factura
 * @author felix
 */

public class ImprimeFactura{
    public static void main(String[] args) {
        Cliente samsDomicilio = new Cliente("Sam", 
                "Calle Principal #100", "Algun pueblo", "Mexico", "98765");
        
        Factura samsFactura = new Factura(samsDomicilio); 
        
        samsFactura.agrega(new Producto("Tostador", 29.95), 3); 
        samsFactura.agrega(new Producto("Secador de Cabello", 24.95), 1); 
        samsFactura.agrega(new Producto("Aspiradora", 19.99), 2);
        
        System.out.println(samsFactura.formato()); }
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

package Factura;

import java.util.ArrayList;

/**
 * Clase para manejar el Objeto Factura
 * @author felix
 */
        
public class Factura {
    private Cliente datosCliente;
    private ArrayList<Partida> items;
    
    /**
     * Constructor de Factura
     * @param unDomicilio
     */
    
    public Factura(Cliente unCliente) {
        items = new ArrayList<Partida>();
        datosCliente = unCliente; 
    }
    
    /**
     * Agraga un producto y su cantidad a la Factura
     * @param unProducto
     * @param unaCantidad
     */
    
    public void agrega(Producto unProducto, int unaCantidad) {
        Partida unItem = new Partida(unProducto, unaCantidad);
        items.add(unItem); 
    }
    
    /**
     * Da formato a la cadena de salida a la Factura
     * @return Regresa la Factura en formato establecido
     */
    
    public String formato() {
        String r = "                        F A C T U R A \n\n" 
                 + datosCliente.formato()
                 + String.format("\n\n%-30s%8s%5s%8s\n", 
                 "Descripcion", "Precio", "Cda", "Total"); 
        for (Partida item : items) {
            r = r + item.formato() + "\n"; 
        }
        
        r = r + String.format("\nCANTIDAD A PAGAR: $%8.2f", obtenCantidadDebida()); 
                return r;
    }
    
    /**
     * Obtiene la Cantidad total a pagar por la factura
     * @return Calcula el total a pagar por la Factura
     */
    
    public double obtenCantidadDebida() {
        double cantidadDebida = 0;
        
        for (Partida item : items) 
            cantidadDebida = cantidadDebida + item.obtenPrecioTotal(); 
        return cantidadDebida; 
    }
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

package Factura;

/**
 * Clase para manejar el Domicilio de Facturacion
 * @author felix
 */

public class Cliente {
    private String nombre;
    private String domicilio;
    private String ciudad;
    private String estado;
    private String CP;
    
    /**
     * Constructor para el domicilio de la Factura
     * @param unNombre Nombre a quien se factura
     * @param unaCalle Domicilio de Facturacion
     * @param unaCiudad Ciudad de Facturacion
     * @param unEstado Estado
     * @param unCP Codigo Postal
     */

    public Cliente(String unNombre, String unDomicilio, String unaCiudad, 
            String unEstado, String unCP) {
        nombre    = unNombre; 
        domicilio = unDomicilio; 
        ciudad    = unaCiudad; 
        estado    = unEstado; 
        CP = unCP;
    }
    
    /**
     * Formato del Domicilio de Facturacion
     * @return Domicilio en formato de la Factura
     */

    public String formato() {
        return nombre + "\n" + domicilio + "\n"
                + ciudad + ", " + estado + " " + CP;
    }

}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

package Factura;

/**
 * Clase para representar una partida de la factura. 
 * La partida es renglon con la descripcion del articulo, cantidad y total
 * @author felix
 */

public class Partida {
    private Producto elProducto;
    private int cantidad;
    
    /**
     * Contructor de una partida
     * @param unProducto Un producto
     * @param unaCantidad Una cantidad
     */
    
    public Partida(Producto unProducto, int unaCantidad) {
        elProducto = unProducto;
        cantidad = unaCantidad; 
    }
    
    /**
     * Calcula el precio total de la partida
     * @return Calcula el precio total de la partida
     */
    
    public double obtenPrecioTotal() {
        return elProducto.obtenPrecio() * cantidad; 
    }
    
    /**
     * Da formato a una partida de la Factura
     * @return Regresa una cadena con la información de un articulo
     */
    
    public String formato() {
        return String.format("%-30s%8.2f%5d%8.2f", 
                elProducto.obtenDescripcion(), 
                elProducto.obtenPrecio(), cantidad, obtenPrecioTotal());
    }
}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

package Factura;

/**
 * Esta clase almacena la información
 * @author felix
 */

public class Producto {
    private String descripcion;
    private double precio;
    
    /**
     * Constructor para un producto
     * @param aDescription descripcion del producto
     * @param aPrice
     */
    
    public Producto(String unaDescripcion, double unPrecio) {
        descripcion = unaDescripcion;
        precio = unPrecio; 
    }
    
    /**
     * Obtiene la Descripción de un producto
     * @return Regresa la descripcion de un Producto
     */
    
    public String obtenDescripcion() {
        return descripcion; 
    }
    
    /**
     * Obtiene el precio de un producto
     * @return Regresa el precio de un Producto
     */
    
    public double obtenPrecio() {
        return precio; 
    }
}
\end{verbatim}

\subsection{Documentación}
La manera en que Java permite documentar un programa o conjunto de programas en un paquete utilizando la instrucción javadoc. En el caso de nuestro paquete de Factura, podemos crear la documentación haciendo

\begin{verbatim}
javadoc Factura
\end{verbatim} 

donde Factura es el directorio donde se encuentran todos los archivos del paquete a los que se les adiciono la leyenda package Factura. La instrucción generará una archivo índex.html con la información referente a las clases tal como se muestra en la Figura \ref{fig:Factura_index}

\begin{figure}[!htp]
   \centering
   \centerline{\psfig{figure=Capitulo_5/figuras/Factura_index.eps, width=14.0cm}}
   \caption{Documentación en Java del paquete Factura}
   \label{fig:Factura_index}
\end{figure}


\section[Utilizando la Técnica CRC]{Utilizando la Técnica CRC, encontrar responsabilidades para las Clases y Colaboraciones}

Para mostrar esta técnica, se muestran la simulación de dos procesos, el primero es el relacionado con una Escuela y el segundo con un Cajero. En ambos casos se muestran los diagramas CRC, UML y el código Java Correspondiente.

\subsection{Ejemplo Escuela}

Como ejemplo haremos los diagramas CRC y UML para una escuela así como el código correspondiente. Se detectan los objetos 

\begin{itemize}
\item Alumno
\item Curso
\item Escuela
\item Fecha
\item Materia
\item Persona
\item Profesor
\end{itemize}


\begin{figure}[!htp]
  \centering
  \centerline{\psfig{figure=Capitulo_5/figuras/Escuela.eps, width=14.0cm}}
  \caption{Interconexion de clase para modelar Escuela}
  \label{fig:Escuela}
\end{figure}

En la figura \ref{fig:Escuela}, se muestran las interconexiones entre las clases para modelar la Escuela

\textbf{Fecha}

Comenzaremos por ver aquellos objetos que no tienen colaboradores. La fecha la utilizaremos para dar la fecha de nacimiento de una persona y calcular su edad

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{Fecha}  }\\
\hline
\textbf{Responsabilidad} & \textbf{Colaborador} \\
\hline
<<costructor>> Fecha	 & \\
\hline
formato  &  \\
\hline
getAnio & \\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|c|}
\hline
 \textbf{Fecha}  \\
\hline
- dia : Entero  \\
- mes : Entero\\
- anio : Entero\\
\hline
<<costructor>> Fecha(unDia: Entero, unMes :Entero, unAnio : Entero)\\
formato() : String \\
getAnio() : Entero\\
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}

%\begin{verbatim}
%package Escuela;
%
%/**
% * Clase para manejar fechas, requiere dia, mes y anio
% * @author felix
% */
%
%public class Fecha {
%    private int dia;
%    private int mes;
%    private int anio;
%    
%    /**
%     * Constructor de una fecha
%     * @param unDia Dia del mes protegido entre 1 y 31
%     * @param unMes Mes numero relacionado con alguno de los 12 meses del anio
%     * @param unAnio Año 
%     */
%    public Fecha(int unDia, int unMes, int unAnio) {
%        dia = (unDia > 0 && unDia <32) ? unDia : 1;
%        mes = (unMes>0 && unMes <13) ? unMes : 1;
%        anio = unAnio > 0 ? unAnio : 1;
%    }
%    
%    /**
%     * determina la fecha en formato dd/mm/aaaa
%     * @return regresa una cadena con la fecha en formato dd/mm/aaaa
%     */
%    
%    public String formato() {
%        return String.format("%02d/%02d/%04d", dia, mes, anio);
%    }
%    
%    /**
%     * Determina el anio relacionado con una fecha
%     * @return anio de la fecha dada en formato dd/mm/aaaa
%     */
%    
%    public int getAnio() {
%        return anio;
%    }
%}
%\end{verbatim}

\textbf{Curso}

Definimos un Curso como una materia que cursa el alumno, dicha materia tiene una clave, descripción, calificación y sección donde el alumno la tomo.

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{Curso}  }\\
\hline
\textbf{Responsabilidad} & \textbf{Colaborador} \\
\hline
<<costructor>> Curso & \\
\hline
getClave  &  \\
\hline
getDescripcion & \\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|c|}
\hline
 \textbf{Curso}  \\
\hline
- clave\_materia : String  \\
- Descripcion : String\\
- Calificacion : Entero\\
- sección : String\\
\hline
<<costructor>> curso(unaClave: String, unaDescripcion : String,\\
    unaCalificacion : Entero, unaSeccion : String)\\
getClave() : String \\
getDescripcion() : Entero\\
informacion() : String\\
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}

%\begin{verbatim}
%package Escuela;
%
%/**
% * Un curso lo definimos con una clave de materia, descripcion o nombre, 
% * calificacion y la seccion en que se impate
% * @author felix
% */
%
%public class Curso {
%    private String clave_materia;
%    private String Descripcion;
%    private int calificacion;
%    private String seccion;
%    
%    /**
%     * Constructor de un curso
%     * @param unaClave Clave de la materia
%     * @param unaDescripcion Descripcion o nombre de la materia
%     * @param unaCalificacion Calificacion del alumno
%     * @param unaSeccion Seccion donde se impartio el curso
%     */
%    
%    public Curso(String unaClave, String unaDescripcion, int unaCalificacion, 
%            String unaSeccion) {
%        clave_materia = unaClave;
%        Descripcion = unaDescripcion;
%        calificacion = unaCalificacion;
%        seccion = unaSeccion;
%    }
%    
%    /**
%     * obtiene la clave de un curso
%     * @return regresa la clave con la cual se registro el curso
%     */
%    
%    public String getClave() {
%        return clave_materia;
%    }
%    
%    /**
%     * obtiene la descripcion de la materia asociada al curso
%     * @return Regresa una cadena con el nombre del curso
%     */
%    
%    public String getDescripcion() {
%        return Descripcion;
%    }
%    
%    /**
%     * Informacion con el nombre del curso y calificacion obtenida
%     * @return Cadena de texto con la Descripcion y calificacion
%     */
%    
%    public String informacion() {
%        return Descripcion + " " + calificacion;
%    }
%}
%\end{verbatim}

\textbf{Materia}

Cada una de las Materias que se imparten en la escuela la intentaremos modelar utilizando una clave, Descripción o nombre de la materia, Horas a la semana que se dedican para esta materia y el Grado en el cual se imparte la materia.

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{Materia}  }\\
\hline
\textbf{Responsabilidad} & \textbf{Colaborador} \\
\hline
<<costructor>> Materia & \\
\hline
informacion  &  \\
\hline
getDescripcion & \\
\hline
getClave & \\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|c|}
\hline
 \textbf{Materia}  \\
\hline
- clave\_materia : String  \\
- Descripcion : String\\
- Horas : Entero\\
- Grado : Entero\\
\hline
<<costructor>> Materia(unaClave: String, unaDescripcion : String,\\
    unaHora : Entero, unGrado : Entero)\\
informacion() : String \\
getdescripcion() : String\\
getClave() : String\\
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}

%\begin{verbatim}
%package Escuela;
%
%/**
% * Modela las materias de una Escuela, agraga informacion de 
% * clave, nombre o descripcion, horas a la semana y grado en
% * el que se imparte
% * @author felix
% */
%public class Materia {
%    private String clave_materia;
%    private String descripcion;
%    private int horas;
%    private int grado;
%    
%    /**
%     * Inicializa el objeto Escuela
%     * @param unaClave Clave de la Materia
%     * @param unaDescripcion Nombre o descripcion de la Materia
%     * @param unaHora Horas a la semana que se imparte
%     * @param unGrado Grado en el cual se imparte la materua
%     */
%    
%    public Materia(String unaClave, String unaDescripcion, int unaHora, int unGrado) {
%        clave_materia = unaClave;
%        descripcion = unaDescripcion;
%        horas = unaHora;
%        grado = unGrado;
%    }
%    
%    /**
%     * Informacuon de clave y descripcion de una Materia
%     * @return una cadena con la informacion concatenada de clave y descripcion
%     */
%    
%    public String informacion() {
%        String aux;
%        
%        aux = clave_materia + " " + descripcion;
%        return aux;
%    }    
%    
%    /**
%     * Obtiene la descripcion de la Materia
%     * @return Regresa la descripcion o nombre de la materia  
%     */
%    
%    public String getdescripcion() {
%        return descripcion;
%    }
%    
%    /**
%     * Obtiene la clave de una materia 
%     * @return regresa la clave de la materia
%     */
%    
%    public String getClave() {
%        return clave_materia;
%    }
%}
%\end{verbatim}

\textbf{Persona}

Una Persona dentro de la Escuela puede tomar diferentes roles, pude ser alumno, maestro o empleado. Para nuestro caso solamente consideraremos Alumnos y Profesores. Las clase Alumno y Profesor las haremos descendientes de esta clase, por lo tal debemos poner especial cuidado.

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{Persona}  }\\
\hline
\textbf{Responsabilidad} & \textbf{Colaborador} \\
\hline
<<costructor>> Persona & Fecha\\
\hline
informacion   & \\
\hline
Edad & \\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|c|}
\hline
 \textbf{Persona}  \\
\hline
- Nombre : String  \\
- Parterno : String\\
- Materno : String\\
- Domicilio : String\\
- fecha\_nacimiento : Fecha\\
\hline
<<costructor>> Persona (unNombre:String, unPaterno:String, \\
unMaterno:String, unDomicilio : String, unaFecha : Fecha) \\
informacion() : String \\
Edad(unAño : Entero) : String\\
\hline
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}

%\begin{verbatim}
%package Escuela;
%
%/**
% * Codigo para manejar la informacion de una Persona
% * @author felix
% */
%
%public class Persona {
%    private String Nombre;
%    private String Paterno;
%    private String Materno;
%    private String Domicilio;
%    private Fecha fecha_nacimiento;
%    
%    /**
%     * Constructor de la clase Persona
%     * @param unNombre Nombre
%     * @param unPaterno Apellido Paterno
%     * @param unMaterno Apellido Materno
%     * @param unDomicilio Domicilio Completo
%     * @param unaFecha Fecha de nacimiento
%     */
%    
%    public Persona(String unNombre, String unPaterno, String unMaterno,
%            String unDomicilio, Fecha unaFecha) {
%        Nombre = unNombre;
%        Paterno = unPaterno;
%        Materno = unMaterno;
%        Domicilio = unDomicilio;
%        fecha_nacimiento = unaFecha;      
%    }
%    
%    /**
%     * Da el nombre completo de la Persona
%     * @return Apellido Paterno, Apellido Materno y Nombre
%     */
%    
%    public String informacion() {
%        return Paterno + " " + Materno + " " + Nombre;
%    }
%    
%    /**
%     * Calcula la edad de una persona apartir de un anio dado
%     * @param unAnio Anio para calcular la edad
%     * @return regresa la edad de la persona
%     */
%    
%    public int Edad(int unAnio) {        
%        return unAnio - fecha_nacimiento.getAnio();
%    }
%}\end{verbatim}

\textbf{Alumno}

En el caso del objeto Alumno adicionalmente a la información para una Persona, agregamos una matricula y una lista de cursos a los que llamaremos kardex.

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{Alumno}  }\\
\hline
\textbf{Responsabilidad} & \textbf{Colaborador} \\
\hline
<<costructor>> Alumno & Persona\\
\hline
agrega\_curso & Curso\\
\hline
cursos & \\
\hline
informacion  & \\
\hline
cursa & \\
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|c|}
\hline
 \textbf{Alumno}  \\
\hline
- Nombre : String  (heredada)\\
- Parterno : String (heredada)\\
- Materno : String (heredada)\\
- Domicilio : String (heredada)\\
- fecha\_nacimiento : Fecha (heredada)\\
- Matricula : String\\
- kardex : Arreglo de Cursos\\
\hline
<<costructor>> Alumno (unNombre:String, unPaterno:String, \\
unMaterno:String, unDomicilio : String, unaFecha : Fecha ,\\
unaClave :String) \\
agregacurso(unCurso:Curso)  \\
cursos() : String\\
informacion() : String\\
cursa(unaMateria : String) : Boolean\\
\hline
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}

%\begin{verbatim}
%package Escuela;
%
%import java.util.ArrayList;
%
%/**
% * Clase que modela un alumno el cual es desendiente de persona.
% * Adicionalmente se agraga matricula y una lista de materias llamado
% * kardex
% * @author felix
% */
%
%public class Alumno extends Persona{
%    private String Matricula;
%    private ArrayList <Curso> Kardex;
%    
%    /**
%     * Constructor para alumno
%     * @param unNombre Nombre del alumno
%     * @param unPaterno Apellido Paterno
%     * @param unMaterno Apellido Materno
%     * @param unDomicilio Domicilio Completo
%     * @param unaFecha Fecha de Nacimiento
%     * @param unaClave Matricula con la que se registra al alumno
%     */
%    
%    public Alumno(String unNombre, String unPaterno, String unMaterno,
%            String unDomicilio, Fecha unaFecha, String unaClave) {
%        super(unNombre, unPaterno, unMaterno, unDomicilio, unaFecha);
%        Matricula = unaClave;
%        Kardex = new ArrayList <Curso> ();     
%    }
%    
%    /**
%     * Metodo responsable de agragarle a un alumno un curso cualquiera
%     * @param unCurso Recibe el curso que se desea agragar
%     */
%    
%    public void agrega_Curso(Curso unCurso) {
%        Kardex.add(unCurso);
%    }
%    
%    /**
%     * Metodo resposnsable de dar una lista de los curso que un alumno tiene
%     * registrados
%     * @return Regresa una cadena de texto con la lista de los cursos numerados 
%     */
%    
%    public String cursos() {
%        String aux = "";
%        int k=1;
%        
%        for(Curso a: Kardex) {
%           aux += "\t"+ k + ".- " +  a.informacion() + "\n";   
%           k++;
%        }
%        
%        return aux;
%    }
%    
%    /**
%     * Metodo para determinar le nombre de un alumno
%     * @return Regresa la matricula y el nombre 
%     */
%    
%    @Override   
%    public String informacion() {
%        String aux;
%        
%        aux  = String.format("%-8s %-32s \n", Matricula, super.informacion()); 
%        
%        return aux;
%    }
%    
%    /**
%     * Verifica si un alumno cursa unaMateria
%     * @param unaMateria Materia a verificar
%     * @return falso o verdadero si es que el alumno cursa la materia
%     */
%    
%    public boolean cursa(String unaMateria) {
%
%        for(Curso i: Kardex) {
%            if(unaMateria.equals(i.getDescripcion())) return true;
%        }
%        
%        return false;
%    }
%}
%\end{verbatim}

\textbf{Profesor}

La otra Persona que involucramos en nuestra escuela es Profesor, adicionalmente a la información como persona agregamos una clave de Profesor y una lista de Materias que imparte.

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{Profesor}  }\\
\hline
\textbf{Responsabilidad} & \textbf{Colaborador} \\
\hline
<<costructor>> Profesor & Persona\\
\hline
agrega\_materia & Materia\\
\hline
informacion  & \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|c|}
\hline
 \textbf{Profesor}  \\
\hline
- Nombre : String  (heredada)\\
- Parterno : String (heredada)\\
- Materno : String (heredada)\\
- Domicilio : String (heredada)\\
- fecha\_nacimiento : Fecha (heredada)\\
- Clave\_Profesor : String\\
- Lista\_Materias : Arreglo de Materias\\
\hline
<<costructor>> Alumno (unNombre:String, unPaterno:String, \\
unMaterno:String, unDomicilio : String, unaFecha : Fecha ,\\
unaClave :String) \\
agrega\_materia(unaMateria:Materia)  \\
informacion() : String\\
\hline
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}

\begin{verbatim}
\end{verbatim}

\textbf{Escuela}

En el caso del objeto Escuela tenemos:

\begin{center}
\begin{tabular}{|l|l|}
\hline
 \multicolumn{2}{|c|} { \textbf{Escuela}  }\\
\hline
\textbf{Responsabilidad} & \textbf{Colaborador} \\
\hline
<<costructor>> Escuela & Alumno\\
\hline
agrega\_alumno & Profesor\\
\hline
agrega\_materia & Materias\\
\hline
Nuevo  & \\
\hline
existeMateria & \\
\hline
Lista\_Alumnos &\\
\hline
Lee\_Materias &\\
\hline
Lista\_Alumnos\_por\_materia &\\
\hline
Lista\_Materias\_por\_Alumno &\\
\hline
Lee\_Alumnos &\\
\hline
\hspace{5cm}   & \hspace{5cm} \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|c|}
\hline
 \textbf{Escuela}  \\
\hline
- Nombre : String  \\
- Alumnos : Arreglo de Alumno \\
- Profesores : Arreglo de Profesor\\
- Materias : Arreglo de Materia\\
\hline
<<costructor>> Escuela (unNombre:String) \\
agrega\_alumno(unAlumno : Alumno) \\
agrega\_materia(unaMateria : Materia)\\
Nuevo(unaClave : String, unaCalificacion :Entero, unaSeccion : String) :  Curso \\
existeMateria(unaClave : String) : Entero  \\
Lista\_Alumnos(unaMateria : String) \\
Lee\_Materias()\\
Lista\_Alumnos\_por\_materia()\\
Lista\_Materias\_por\_Alumno()\\
Lee\_Alumnos()\\
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}



\subsection{Ejemplo Cajero}
Para ver la utilización de la técnica CRC haremos la simulación de un cajero automático de banco. El Cajero manejará un conjunto de clientes de un Banco y cada cliente tendrá dos cuentas una de ahorros y otra de cheques. En el cajero se podrán hacer las operaciones de deposito y retiro de una cuenta que se seleccione. El ingreso al cajero será a través de un número de cliente y una clave de acceso de cuatro dígitos.

Los objetos que podemos modelar para simplificar el problema son:

\begin{itemize}
\item Cuenta\\
\item Cliente \\
\item Banco \\
\item Cajero \\
\end{itemize}

En la figura \ref{fig:Cajero} se muestra el diagrama de interconexión de objetos 
\begin{figure}[!htp]
   \centering
   \centerline{\psfig{figure=Capitulo_5/figuras/Cajero.eps, width=14.0cm}}
   \caption{Interconexion de clase para modelar un Cajero}
   \label{fig:Cajero}
\end{figure}

\begin{center}
\begin{tabular}{|c|}
\hline
\textbf{Cuenta}  \\
\hline
- saldo : doble  \\
\hline
<<costructor>> Cuenta () \\
<<costructor>> Cuenta (saldoInicial : doble) \\
deposito(cantidad : doble)\\
retiro(cantidad : doble)\\
obtenSaldo() : double\\
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|c|}
\hline
 \textbf{Banco}  \\
\hline
- clientes : Arreglo de Cliente  \\
\hline
<<costructor>> Banco () \\
leeClientes() \\
agregaCliente(unCliente : Cliente)\\
buscaCliente(unNumero: Entero)\\
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}


\begin{center}
\begin{tabular}{|c|}
\hline
\textbf{Cliente}  \\
\hline
- NumeroCliente : Entero  \\
- clave : Entero\\
- cuenta\_de\_Cheque : Cuenta\\
- cuenta\_de\_Ahorros : Cuenta\\
\hline
<<costructor>> Cliente (unNumero : Entero, unaClave : Entero) \\
empata(unNumero: Entero, unaClave: Entero)\\
obten\_cuenta\_de\_Cheques() : Cuenta\\
obten\_cuenta\_de\_Ahorros() : Cuenta\\
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}


\begin{center}
\begin{tabular}{|c|}
\hline
\textbf{Cajero}  \\
\hline
- estado : Entero  \\
- NumeroCliente : Entero\\
- ClienteActual : Cliente\\
- CuentaActual : Cuenta\\
- elBanco : Banco\\
\hline
<<costructor>> Cajero () \\
verEstado() : Entero\\
muestraEstado(estadoNuevo : Entero) \\
ponNumeroCliente(unCliente : Entero) \\
seleccionaCliente(unaClave : Entero)\\
seleccionaCuenta(unaCuenta : Entero)\\
retiro(miRetiro: doble)\\
deposito(miDeposito: doble)\\
muestraSaldo() : doble\\
salir()\\
\hspace{10cm}  \\
\hline
\end{tabular}
\end{center}


%\section[Introducción a especificación de modelos]{Introducción a especificación de modelos con el  Lenguaje de Modelado Unificado (UML). Tipos de Diagramas UML Diagramas de clases. Elementos del Diagrama de Clases. Relaciones entre clases: Asociación, Composición, Agregación, Dependencia, Herencia, Ejemplos de relaciones entre clases}
