Diseño y Creacion de un Gestor de Notas.

Cerrado Publicado Apr 2, 2012 Pagado a la entrega
Cerrado Pagado a la entrega

Estamos buscando un Desarrollador Java que será el responsable del diseño.

Responsabilidades:

.

- Producir un diseño técnico sólido y detallado.

- Escritura limpia, modular, mediante código robusto para implementar los requerimientos deseados con poca o ninguna supervisión.

- Aportar ideas para hacer mejor y más sencilla la aplicacion.

Habilidades/requisitos deseados:

- Lenguajes de Programación: Java

- Habilidades adicionales: J2EE

- Estilo de trabajo extremadamente detallista .

- 3-5 años de experiencia en programación.

- Títulación de Informática o experiencia equivalente.

- Un perfil completo en Nubelo.

- Predilección por una persona con referencias o una reputación establecida en Nubelo.

La idea fundamental es construir una aplicación de gestión de notas de

texto (anotaciones). La aplicación ha desarrollar se organizará en libretas, que se utilizarán para organizar las

notas. Además de las notas de texto, incluirá otras más avanzadas como pueden ser eventos, libros, discos, películas o

listas de tareas, en la línea de los nuevos gestores que hoy día existen en el mercado, pero desde perspectiva

simplificada..

La forma de desarrollarlo será partiendo del enfoque más básico, avanzando de forma iterativa. Para ello planteamos

tres etapas, en cada etapa se partirá del diseño y desarrollo de la etapa inmediatamente anterior para añadir nuevas

características y funcionalidades.

El sistema además de almacenar las notas, permitirá realizar una serie de acciones sobre las mismas, como su

modificación, borrado, creación de nuevas notas o libretas, operaciones de consulta, etc.

ETAPA 1

CREACIÓN DE UNA CLASE NOTA

permitir a los usuarios crear y gestionar notas. Dentro de esta

primera parte se realizará una aproximación básica al modelado inicial de algunos de los componentes del sistema.

Los componentes básicos de nuestro sistema en este punto del desarrollo serán las notas. Cada nota es un objeto, por

tanto para definir una nota necesitaremos crear una clase. Para ello, tenga en cuenta que una nota tendrá las

siguientes características (campos o atributos):

• Título.

• Contenido. Será un texto.

• Fecha de creación. Se definirá a través de tres números enteros correspondientes al día, el mes y el año.

Además, un objeto Nota debe permitir consultar y modificar estos campos a través de una serie de métodos creados a

tal efecto: por cada campo debe haber dos métodos, uno para consultar su valor y otro para modificarlo, por ejemplo,

para el campo titulo tendríamos los métodos getTitulo y setTitulo.

Asimismo, debe existir un método, llamado printNote, que escriba el contenido de la nota por pantalla (puede hacer

uso del método System.out.println.

Añada un método main, incluido en una nueva clase llamada Lanzador creada a tal efecto. Dentro de él pruebe a

crear varios objetos Nota con diferentes características y a acceder a las mismas mediante los métodos pertinentes,

escríbala en pantalla, use los métodos apropiados para modificarla y vuelva a escribirla por pantalla para ver como su

contenido ha cambiado. Ejecute el programa desde BlueJ y desde la línea de comandos (consola o símbolo de

sistema, según el sistema operativo que utilice).

ETAPA 2

CREACIÓN DE LIBRETAS

1. Tenga un título.

2. Almacene una lista de notas.

3. Se han de poder añadir y eliminar notas de la Libreta. Para eliminar una nota se puede tomar el título como

parámetro para identificarla. Por tanto, no debe permitirse que una misma Libreta almacene dos notas con

un mismo título.

4. La Libreta debe ser capaz de presentar por pantalla un listado de los títulos de las notas que contiene y otro

diferente incluyendo toda la información de cada Nota (utilizar el método creado en la clase Nota en el

apartado 3.1.3 para escribirla en pantalla). Para simplificar los métodos de almacenamiento y recuperación,

no es necesario que las notas se presenten siguiendo ningún orden, aunque

sí es habitual presentar las notas al usuario ordenadas por fecha, título, etc.

5. Además debe disponer de otro método que dada una fecha, devuelva por pantalla los títulos de todas las

notas almacenadas en la Libreta con fecha anterior a la indicada. De nuevo, no es necesario que las notas se

presenten de forma ordenada, sino que simplemente cumplan con la condición de la fecha. Desarrollar otro

método con la misma funcionalidad pero que presente por pantalla las notas completas y no sólo sus títulos.

6. Documente las clases que ha creado hasta ahora.

7. Implemente un método main que permita lanzar la aplicación de forma independiente y que contenga el

código necesario para crear una Libreta, añadir varias notas, eliminar alguna de ellas y listarlas (listado de

títulos, listado las notas al completo y listados por fecha igual, anterior y posterior a una dada, tanto de

títulos como de notas completas).

8. Tratamiento de errores. La aplicación ha de contemplar casos cómo que un título no exista o no haya notas

para listar dada una fecha y debe gestionar este tipo de situaciones informando de adecuadamente por

pantalla de lo que sucede.

ETAPA 2.2: ORGANIZANDO LAS LIBRETAS

Hasta ahora hemos construido una libreta de notas. El siguiente paso es añadir la posibilidad de trabajar con

diferentes libretas independientes. Esto proporciona un nuevo nivel de organización, permitiendo la clasificación

temática de las notas.

CREACIÓN DEL GESTOR DE LIBRETAS

Para ello, cree una nueva clase GestorLibretas que incluya:

• Una lista de libretas dentro de la cual no puede haber dos libretas con un mismo título.

• Debe proporcionar por pantalla un listado de las libretas que contiene (de sus títulos). No se considerará el

orden de presentación, al igual que en el caso de las notas dentro de una libreta (apartado 4.1.3 ).

• Debe devolver una libreta dado su título exacto.

• Debe permitir la creación de nuevas libretas.

• Debe permitir añadir libretas existentes a la lista.

• Debe permitir eliminar una libreta dado su título. En este caso se eliminará tanto la libreta como su

contenido.

• Dado el título de una libreta y una Nota, añadir la Nota a dicha Libreta.

• Dado el título de una Libreta y de una Nota, eliminar dicha Nota.

• Incluirá un método que escriba por pantalla las estadísticas del gestor. Como mínimo debe presentarse el

detalle del número de notas que contiene cada libreta, así como el número total de libretas y el total de

notas almacenadas.

• Incluirá otro par de métodos que dado el nombre de una libreta, escriba el contenido completo de ésta por

pantalla en un caso, y los títulos de sus notas en otro. No es necesario que las notas se presenten en un orden

concreto, basta con que se muestren en el orden en que fueron añadidas a la libreta.

• Incluirá un método que escriba por pantalla, por cada libreta, su nombre y los títulos de las notas que

contiene.

• Incluirá un método que dado un título de nota sea capaz de devolver el nombre de la libreta que contiene

dicha nota, si está almacenada en el sistema, o un mensaje de error si no existe ninguna nota con dicho título

almacenada. Puede darse el caso en el que existan dos o más notas con un mismo título en diferentes

libretas. En ese caso, este método debe devolver los títulos de todas las libretas que contengan esas notas.

Se pide además añadir al método main que se creó en el apartado 4.1 el código necesario para:

• Crear un gestor de libretas.

• Añadir la libreta previamente creada.

• Crear una nueva libreta en el sistema.

• Crear una nueva nota y añadirla a la libreta creada en el paso previo.

• Añadir nuevas libretas y notas a las mismas.

• Escribir por pantalla las estadísticas del sistema.

• Borrar alguna nota y alguna libreta, siendo la nota de una libreta que no sea la eliminada.

• Escribir de nuevo las estadísticas por pantalla para visualizar los cambios.

• Buscar por título la libreta que contiene una nota previamente almacenada y utilizar el resultado del método

en una nueva llamada a método que escriba por pantalla el contenido de la libreta en cuestión.

• Buscar por título una nota que no exista en el sistema, produciendo un mensaje informativo al respecto.

• Escribir por pantalla el contenido completo del gestor, pero mostrando sólo los títulos de las notas, no todo

su contenido.

ETAPA 3

En esta última etapa queremos añadir nuevos tipos de notas para enriquecer el sistema. Todas las notas tendrán

título, fecha de creación y contenido, pero algunas tendrán nuevos campos adicionales. Estas notas serán alertas y

referencias a libros, discos o películas. Los gestores de notas actualmente permiten guardar listas de libros, películas y

discos al igual que notas simples. No son objetos libro, película o disco, sino notas sobre libros, discos o películas que

simplemente facilitan el almacenamiento de información un poco más específica que una nota simple. Aparte de la

información específica, se podrán añadir comentarios como en cualquier nota.

En esta parte de la etapa nos vamos a centrar en extender la funcionalidad de la aplicación sin necesidad de modificar

las clases que habíamos creado anteriormente.

AÑADIENDO NUEVOS TIPOS DE NOTAS

En nuestro sistema hasta ahora sólo tiene cabida un tipo de notas. Se desea incluir nuevos tipos de notas, que

llamaremos Alerta, Libro, Película y Disco. Estas notas tienen todas las características de las notas originales, con las

siguientes novedades (no se han de modifcar las clases que ya teníamos para incluir estos nuevos tipos de notas en

el sistema):

• Una Alerta incluye una fecha de aviso y un texto asociado.

• Un Libro incluye uno o varios autores (es suficiente con almacenar una cadena de texto para simplificar el

problema) y un ISBN.

• Una Película incluye un director (basta con almacenar una cadena de texto), una nacionalidad y un año de

estreno.

• Un Disco incluye un artista (de nuevo, es suficiente con utilizar una cadena de texto) y un año.

• Haciendo uso del mecanismo del polimorfismo, cada tipo de nota debe escribir por pantalla sus

características particulares, además del título y los comentarios. Los comentarios para estos nuevos tipos de

notas se incluirán en el campo contenido, que se hereda de la clase Nota, al igual que el título.

Se pide además incluir en el método main que lanza la aplicación:

• El código para añadir algunas notas de los nuevos tipos a diferentes libretas.

• El código necesario para imprimir un listado de notas completo y comprobar que efectivamente aparecen

todos los datos de las notas nuevas y no sólo el título y el contenido.

Finalmente, modifque las clases que sean necesarias para incluir la posibilidad de listar las notas por tipos. Es

suficiente con que exista un método para listar cada tipo de notas. Añadir al método main el código necesario para

que dada una libreta se listen por separado sus películas, alertas, libros, etc. utilizando los métodos que se han creado

a tal efecto. Para identificar la clase a la que pertenece un objeto se puede hacer uso del operador instaceof, que dado

un objeto nos permite comprobar si implementa una clase concreta, por ejemplo:

if (n instanceof Pelicula) {

...

}

Para finalizar el diseño e implementación de la aplicación que tenemos entre manos,

vamos a introducir una nueva funcionalidad a la aplicación. Por ahora las notas se insertan y se muestran por pantalla

en el orden en que se almacenaron, lo cual resulta poco eficiente. Para facilitar la lectura de las notas vamos a hacer

que estas se presenten al usuario de forma ordenada.

ORDENANDO LAS NOTAS

El objetivo de este apartado es que las notas de una libreta se muestren ordenadas por fecha, de la más antigua a la

más reciente. Para mostrar las notas de forma ordenada por pantalla tenemos dos opciones: almacenar las notas con

cierto orden u ordenar las notas en el momento de presentarlas por pantalla. En este último caso, cada vez que

queramos visualizar las notas por pantalla habría que reordenarlas. Como sólo queremos ordenarlas por fecha, no

necesitamos reordenarlas cada vez, por lo que elegiremos la primera alternativa que nos permite reordenar

únicamente cuando una nueva nota sea añadida a una libreta. Por tanto se ha de modificar el código de inserción de

notas en las libretas de forma que las notas se inserten de forma ordenada empezando por la más antigua y

terminando por la más reciente, siempre según su fecha de creación. No es necesario usar estructuras de datos que

proporcionen ordenación, se pide utilizar la misma estructura de lista que ya teníamos, modificando la manera en que

se inserta una nota. Ahora en lugar de simplemente añadirla, tendremos que buscar previamente la posición en la

lista donde corresponde insertarla según su fecha y entonces insertarla en dicha posición.

Dado que ahora la inserción es ordenada, se debe aprovechar para mejorar la eficiencia de los otros métodos.

Documentar cuales serían los métodos y en que consiste la mejora. Incluir las modificaciones necesarias.

Se pide también incluir en el método main el código necesario para comprobar el correcto funcionamiento de las

modificaciones realizadas con distintos tipos de notas, de forma que se presenten por pantalla listas de notas

ordenadas por su fecha de creación.

Tiempo hasta el miercoles 16/05/12

Se adjunta archivo de las Clases a desarrollar.

Para aplicar con Bluej.

Administración de bases de datos Soporte a usuarios finales OpenStack Red Hat UNIX

Nº del proyecto: #12345211

Sobre el proyecto

6 propuestas Proyecto remoto Activo May 17, 2012

6 freelancers están ofertando un promedio de €250 por este trabajo

ChristianGimenez

Hola, Estoy interesado en el proyecto. El lenguaje que mejor manejo es Java, conozco muy bien J2EE. Mi propuesta consiste en trabajar 16 hs semanales. El costo de la hora es de 4.36. Esto lleva a un monto de 69.76 Más

€250 EUR en 14 días
(0 comentarios)
0.0
agallu

Buenas tarde, estoy interesado en su oferta. Sobre las habilidades y requisitos creo reunirlos todos, y en cuanto a las responsabilidades que definen forman parte de mi manera de trabajar. Si están interesados en qu Más

€250 EUR en 14 días
(0 comentarios)
0.0
nubelo_woHE2ycm

Tengo bastante experiencia en java, y por lo que veo debe de realizarse en java. Parece más un proyecto para un estudiante que para una empresa, igual me equivoco. Me interesa saber cuanto pagarías. Trabajo mis o Más

€250 EUR en 14 días
(0 comentarios)
0.0
yosulcm

Sin Problema.

€250 EUR en 14 días
(0 comentarios)
0.0
gabrielgarciape

Hola, como Licenciado en Informática y SCRUM Master certificado poseo los conocimientos necesarios para esta interesante propuesta de desarrollo de software que requiere extrema responsabilidad y compromiso.

€250 EUR en 14 días
(0 comentarios)
0.0