FUNDAMENTOS DE INFORMÁTICA GESTIÓN DE TIENDA ON-LINE Miguel Gómez Morón Grado en Ingeniería Mecánica Curso 2013/2014 Centro asociado de Cádiz

INDICE ENUNCIADO DE LA PRÁCTICA: ....................................................................2 ETAPA 1.1. ..................................................................................................2 ETAPA 1.2. ..................................................................................................2 ETAPA 2.1. ..................................................................................................3 ETAPA 2.2. ..................................................................................................4 ETAPA 3.1. ..................................................................................................5

1

ENUNCIADO DE LA PRÁCTICA: El objetivo de la práctica es implementar una aplicación capaz de gestionar una tienda on-line de componentes informáticos, para simplificarla se han pasado por alto algunos detalles del sistema de gestión, centrándose en la creación de un sistema de stock para la tienda, los componentes que en ella se comercializan, las ventas en proceso, las ventas completadas y el control sobre estas. La aplicación se realizara usando lenguaje java y con el editor bluej, una vez completada cada etapa de la práctica, esta debe ser ejecutable desde símbolo de sistema.

ETAPA 1.1. En esta primera parte se crea la clase Componente, esta clase simboliza los productos que se venderán en la tienda virtual, y el resto de clases de la aplicación están orientadas a gestionar esta clase o agrupaciones de ella. La clase Componente posee los campos: Nombre del fabricante Código del fabricante Código del producto Descripción del producto Precio

Tipo String ej. (“HP”) Tipo int ej. (123) Tipo int ej. (321) Tipo String ej. (“Impresora”) Tipo doublé (125.65)

El constructor de esta clase obliga a introducir todos estos campos al crear el objeto. Componente dispone de 2 métodos por cada uno de estos campos, el primero un “set” para poder modificarlo y el segundo un “get” para obtener el campo como valor de retorno previendo su uso más adelante, además de un método adicional que muestra en la consola el valor adjudicado a cada campo con un texto descriptivo de este.

ETAPA 1.2. Se confecciona la clase Lanzador, que está dirigida a ser la que permita que la aplicación pueda ser ejecutada por java fuera del editor bluej, para esto se dota con un método main, que en esta etapa de la práctica se limita a la creación de algunos componentes que puedan servir de muestra, introducir cada uno de los valores de sus campos y una vez creados hacer uso de sus métodos para mostrar los valores de sus campos. 2

ETAPA 2.1. Se crea la clase CarroCompra, la cual simboliza el carro de la compra que un cliente usa para incluir los componentes que desea comprar, para la creación de esta clase se importan desde java.util las clases ArrayList y Calendar, CarroCompra dispone de los campos: carroCompra fecha cliente total metodoDePago

Es un ArrayList de objetos de la clase Componente. De la clase Calendar importada, deja constancia de la fecha y hora en la que se crea el objeto carroCompra. Tipo String con el código del cliente al cual pertenece el carroCompra Tipo doublé, es la suma de todos los atributos precio de los componentes que se almacenen en el carro Representa el tipo de pago que el cliente elije para formalizar la compra, puede ser tarjeta de crédito o transferencia bancaria, para este fin se ha usado una clase enum que tan solo permite estas dos opciones

El constructor de la clase necesita que le aporten el identificador de cliente e incorpora por sí misma la fecha de la creación del carro. Los métodos permiten agregar y quitar componentes de la lista distinguiendo cada objeto componente por su campo codigoDelProducto y actualizando el total cada vez, también posee métodos para presentar en pantalla el listado de los productos contenidos en la lista, mostrando también el identificador de cliente, el número de objetos contenidos en la lista y el total, un método similar ejerce la misma función mostrando complementariamente todos los campos de cada producto contenido en la lista. El método comprar simula la formalización de la compra, para esto al hacer la llamada a este método se debe introducir el tipo de pago elegido, este método crea un nuevo objeto de la clase Venta el cual se detalla a continuación y el eliminado del carroCompra. Clase Venta, las instancias de ventas poseen los mismos atributos que carroCompra, el campo fecha no contendrá la fecha de creación del carro, este contendrá la fecha de formalización de la compra (creación del objeto de la clase Venta), aunque se desde bluej podemos crear una instancia de Venta, está dirigida a que sean creadas desde el método comprar de los objetos carroCompra, a los campos mencionados se añade el campo metodoDePago, destinado a almacenar el tipo de pago elegido en carroCompra para formalizar la compra. En la realización de todas las clases se tiene en cuenta aportar toda la documentación necesaria para poder ser usadas con javadoc y así hacer accesible nuestra aplicación a personas ajenas al proyecto de una manera fácil. La clase Lanzador es modificada para que cree una instancia de la clase CarroCompra y añada dos componentes, a continuación elimina uno de ellos, muestra el contenido del carro por pantalla, después formaliza la compra creando un objeto venta.

3

ETAPA 2.2. Se crea la clase ComponenteEnStock, los objetos creados por esta clase son simplemente la combinación de un objeto componente con un nuevo atributo cantidad, que simboliza la cantidad de este componente que tenemos en nuestra tienda. Cuenta con dos constructores, uno de ellos requiere que le aportemos un componente y una cantidad, mientras que el otro hace una llamada al constructor de la clase componente, de este modo crea el objeto componente y después lo usa para crear el objeto componenteEnStock, sus método principales aumentan y disminuyen el campo cantidad y consultan su valor. Se crea Stock, esta clase importa de java.util la clase HashMap, la cual crea una lista de componenteEnStock, adjudicando a cada uno una etiqueta para ser llamado por esta, para esta etiqueta usamos el atributo códigoDelProducto, esta clase relaciona varias clases, entre ellas CarroCompra y ComponenteEnStock , su constructor solamente crea una HashMap vacío. Sus métodos incorporan componenteEnStock a la lista y también consultan su cantidad en stock. Se crean dos clases de características similares, ListaCarro, que es una lista de los objetos carroCompra existentes, la cual permite consultar los atributos de cada objeto añadido a la lista; y la clase ListaVenta que contiene una lista de los objetos de la clase Venta existentes, igualmente permite consultar los atributos de cada objeto añadido a la lista, así como hacer una búsqueda por atributo fecha de objetos que coincidan con los márgenes indicados. Por ultimo para esta etapa se crea la clase Tienda, mediante su constructor esta clase asocia a todas las anteriores para que interactúen entre ellas y consiguiendo mediante llamadas a constructores y métodos de todas las demás controlar toda las funciones tanto de un administrador de la tienda como de un cliente, estos métodos pueden crear componentes, añadirlos al stock, manipular este, hacer todas las consultas y búsquedas, gestionar devoluciones, crear carros de la compra, añadir y eliminar componentes de estos y formalizar las compras. El método main de la clase Lanzador es nuevamente actualizada para desde símbolo de sistema, crear una tienda virtual y generar un pequeño stock inicial, una vez generado muestra un sistema de menús que nos permiten acceder a la aplicación como administrador o como cliente, así como a todos los métodos que a cada uno de ellos corresponde.

4

ETAPA 3.1. En esta etapa se crean dos niveles de subclases de la ahora superclase Componente, cada una de ellas heredando los atributos de la anterior y añadiendo los propios, así como el método para mostrar en la consola sus atributos, la nueva estructura de subtipos de componente es la siguiente:

1. Periférico: subclase de componente, el nuevo atributo que contiene es “tipo de conexión”, de tipo String. 1.1. Teclado: subclase de periférico, el nuevo atributo que contiene es “idioma del teclado”, de tipo String. 1.2. Ratón: subclase de periférico, el nuevo atributo que contiene es “número de botones”, de tipo int. 1.3. Impresora: subclase de periférico, el nuevo atributo que contiene es “tipo de impresora”, de tipo enum que permite seleccionar “tinta” o “laser”. 2. Placa base: subclase de componente, sus nuevos atributos son: “ancho” de tipo int, “alto” de tipo int, “tipo de procesador” de tipo String y “tipo de ranura de memoria” de tipo String. 3. Memoria: subclase de componente, su nuevo atributo es “tamaño” que es de tipo int. 3.1. Flash: subclase de memoria, su nuevo atributo es “velocidad de lectura” de tipo int. 3.2. DiscoDuro: subclase de memoria, su nuevo atributo es “tipo de disco duro” de tipo enum permite distinguir entre “externo” e “interno”. 3.3. Ram: subclase de memoria, su nuevo atributo es “tipo de Ram” de tipo enum permite distinguir entre “DDR”, “DDR2” y “DDR3”. Gracias al polimorfismo las modificaciones en otras clases son mínimas y van dirigidas a poder crear estos subcomponentes, el resto de funciones como stock o carro de la compra interactúan con ellos como lo hacían con los objetos componente. Se modifica el método main de la clase Lanzador para que desde este se puedan crear subcomponentes de todos los tipos anteriormente contemplados de igual manera que hacía con la superclase Componente. Finalmente se modifican las clases CarroCompra y Venta para que muestren los componentes diferenciando por subclases, también la clase stock es modificada para incluir la posibilidad de poder mostrar por separado en la consola las diferentes subclases de Componente.

5

El diagrama de clases queda del siguiente modo: