Informe Proyecto Poo

ESCUELA POLITÉCNICA NACIONAL

PROGRAMACIÓN ORIENTADA A OBJETOS

PROYECTO FINAL

TEMA: APLICACIÓN DE UNA LIBRERÍA

INTEGRANTES:

- CARLOS CALDERÓN.

- FABIÁN QUIMBIULCO.

PERIODO: SEPTIEMBRE – ENERO

INFORME DEL PROYECTO.

Para demostración de los conocimientos aprendidos durante el periodo de clase en

programación orientada a objetos, es necesario ponerlos en práctica y que mejor con un

proyecto final en el que se vea el nivel de aprendizaje obtenido, nada complejo pero

también nada básico.

Existen muchas aplicaciones en lo que se pueda ver la programación, en el caso nuestro,

se escogió un tema didáctico, útil, y sobretodo fácil de entender por usuarios y por

personas entendidas en la programación.

El tema se refiere a una biblioteca que no solo permite el préstamo de libros sino

también de grabaciones musicales. El programa tendrá su interfaz grafica para mejor

visibilidad del usuario, y un contexto de código bien estructurado para cumplir con la

finalidad de que el programa funcione correctamente y haga lo que se le destino hacer.

Objetivo

Nuestro objetivo principal es el aplicar el conocimiento de la Programación Orientada a

Objetos a una aplicación útil en la vida diaria y que sea de fácil demostración y

entendimiento.

Análisis del proyecto

El análisis consiste en la implementación que se ha hecho para que funcione el

programa como son la notación UML, las clases que se utilizaron, las pruebas que se

realizan para la verificación del funcionamiento óptimo del programa.

La notación UML ayuda mucho al programador ya que es la plataforma del programa,

es la esencia o el fundamento. Es por eso que es muy importante porque desde aquí

vendrá el proceso correcto para el programa.

El diagrama de clases tiene que ver con la notación UML, es en donde se vera de

manera sencilla lo que se va a utilizar en cada clase implementado en el programa y esto

tiene que ver con los métodos, variables, constructores, las herencias, lo que es el

polimorfismo, tokenizer, las excepciones que para nuestro caso tienen que estar

presentes en el caso de algún dato ingreso de forma incorrecta.

El tema implica la realización de un programa que satisfaga el procedimiento de

préstamos de libro y de grabaciones de audio como son la música. El programa debe

permitir el préstamo y devolución de los artículos de la librería con un catálogo de

artículos disponibles y además una lista de los usuarios de la biblioteca para que se los

pueda prestar e identificar a qué usuario se le ha prestado un artículo.

El siguiente diagrama de clase resalta los elementos utilizados para implementar la

versión del sistema de librería:

A continuación basándonos en este diagrama de clases se procede a la realización y

descripción de las clases que se van a utilizar:

Como fundamento, una biblioteca posee libros y para nosotros también videos y CDs de

música que con anterioridad en una base de datos se los guarda por cuestiones de

seguridad y no en el mismo programa ya ejecutado. Esto quiere decir que al ingresar

libros nuevos, es preferible ingresarlos a la base de datos pero directamente en el código

del programa y no guardarlos con la ejecución del mismo. Además, una biblioteca tiene

sus usuarios particulares que pueden pedir prestados libros, que pueden devolverlos, y

que todo este proceso se lo va registrando en el programa.

Esto es lo que nuestro programa realiza; el proceso de una biblioteca.

La Clase Catalog

La clase Catalog utiliza una colección de instancias de CatalogItem e implementa la

interfaz Iterable para permitir la iteración sobre los artículos del catalogo utilizando

bucles for-each.

Variables de instancia:

· items. Una colección ArrayList que contiene referencias a instancias de la

clase CatalogItem.

Constructor y métodos:

· public Catalog(). Crea la colección items, que inicialmente está vacío.

· public void addItem(CatalogItem catalogItem).Añade el artículo especificado al

catálogo.

· public CatalogItem getItem(String code).Regresa una referencia a la instancia

de CatalogItem con el código especificado. Regresa null si no hay artículos con

el código especificado.

· public Iterator iterator(). Regresa un iterador sobre los artículos del catálogo.

· public int getNumberOfItems(). Regresa el número de artículos en el catálogo.

Implementación:

import java.util.*; import java.io.*; /** * Mantiene la información sobre un catálogo de una biblioteca. * Contiene una colección de objetos {@link CatalogItem}. */ public class Catalog implements Iterable<CatalogItem> { /* Colección de objetos <code>CatalogItem</code>.*/ private ArrayList<CatalogItem> items; /** * Construye un string vacío. */ public Catalog() { this.items = new ArrayList<CatalogItem>(); } /** * Añade un objeto {@link CatalogItem} a este catálogo. * @param catalogItem el objeto {@link CatalogItem}. */ public void addItem(CatalogItem catalogItem) { this.items.add(catalogItem); } /** * Regresa un iterador sobre los artículos de este catálogo. * @return un {@link Iterator} de objetos {@link CatalogItem}. */ public Iterator<CatalogItem> iterator() { return this.items.iterator(); } /** * Regresa un objeto {@link CatalogItem} con el <code>code</code>

* especificado. * @param code el código de un artículo. * @return El objeto {@link CatalogItem} con el código * especificado. Regresa <code>null</code> si el objeto con * el código no es encontrado. */ public CatalogItem getItem(String code) { for (CatalogItem catalogItem : items) { if (catalogItem.getCode().equals(code)) { return catalogItem; } } return null; } /** * Regresa el número de artículos del catálogo. * @return el número de objetos {@link CatalogItem} en este * catálogo */ public int getNumberOfItems() { return this.items.size(); } }

La Clase BorrowedItems

La clase BorrowedItems modela la lista de artículos que han sido prestados a un

usuario. Utiliza una colección de instancias de CatalogItem e implementa la

interfaz Iterable para permitir la iteración sobre los artículos prestados utilizando

bucles for-each.


· items. Una colección ArrayList que contiene referencias a instancias de la

clase CatalogItem.


· public BorrowedItems(). Crea la colección items, que inicialmente está vacío.

· public void addItem(CatalogItem catalogItem).Añade el artículo especificado a la

lista de elementos solicitados por el usuario.

· public CatalogItem getItem(String code).Regresa una referencia a la

instancia CatalogItem con el código especificado. Regresa null si no hay

artículos con el código especificado.

· public Iterator iterator(). Regresa un iterador sobre los artículos prestados.

· public int getNumberOfItems(). Regresa el número de artículos prestados.

Implementación:

import java.util.*; import java.text.*; /** * Mantiene una colección de {@link CatalogItems} * prestados a un usuario. */ public class BorrowedItems implements Iterable<CatalogItem> { /* Artículos del catálogo prestados a un usuario.*/ private ArrayList<CatalogItem> items; /** * Establece la colección de {@link CatalogItems} como vacía. */ public BorrowedItems() { this.items = new ArrayList<CatalogItem>(); } /** * Añade un objeto {@link CatalogItem} a esta colección y * establece el objeto {@link CatalogItem} como no disponible. * @param item the {@link CatalogItem} object. */ public void addItem(CatalogItem catalogItem) { this.items.add(catalogItem); catalogItem.setAvailable(false); } /** * Elimina un objeto {@link CatalogItem} de esta colección * y establece el objeto {@link CatalogItem} como disponible. * @param catalogItem el objeto {@link CatalogItem}. */ public void removeItem(CatalogItem catalogItem) { this.items.remove(catalogItem); catalogItem.setAvailable(true);

} /** * Regresa un iterador sobre los artículos prestados de esta * colección. * @return un {@link Iterator} de objetos {@link CatalogItem} */ public Iterator<CatalogItem> iterator() { return this.items.iterator(); } /** * Regresa un objeto {@link CatalogItem} con el <code>código</code> * especificado. * @param code el código de un artículo. * @return El objeto {@link CatalogItem} con el código * especificado. Regresa <code>null</code> no se encuentra * el objeto con el código. */ public CatalogItem getItem(String code) { for (CatalogItem catalogItem : this.items) { if (catalogItem.getCode().equals(code)) { return catalogItem; } } return null; } /** * Regresa el número de artículos prestados. * @return el número de artículos prestados. */ public int getNumberOfItems() { return this.items.size(); } }

La Clase BorrowerDatabase

La clase BorrowerDatabase modela una base de datos de usuarios. Utiliza una colección

de instancias de Borrower e implementa la interfaz Iterable para permitir la iteración

sobre los elementos de la base de datos utilizando bucles for-each.


· borrowers. Una colección ArrayList que contiene referencias a instancias de la

clase Borrower.


· public BorrowerDatabase(). Crea la colección borrowers, que inicialmente está

vacío.

· public String addBorrower(Borrower borrower).Añade el usuario especificado a la

base de datos.

· public Borrower getBorrower(String id). Regresa una referencia a la

instancia Borrower con el número de identificación especificado. Regresa null si

no hay usuarios en la base de datos con el número de identificación

especificado.

· public Iterator iterator(). Regresa un iterador sobre la base de datos de usuarios.

· public int getNumberOfItems(). Regresa el número de usuarios en la base de datos.

Implementación:

import java.util.*; import java.text.*; /** * Mantiene una colección de objetos {@link Borrower}. */ public class BorrowerDatabase implements Iterable<Borrower> { /* Colección de objetos <code>Borrower</code>.*/ private ArrayList<Borrower> borrowers; /** * Construye una colección vacía de objetos */ public BorrowerDatabase() { this.borrowers = new ArrayList<Borrower>(); } /** * Añade un usuario {@link Borrower} a la base de datos. */ public void addBorrower(Borrower borrower) { this.borrowers.add(borrower); } /**

* Regresa un iterador sobre los usuarios de esta base de datos. */ public Iterator<Borrower> iterator() { return this.borrowers. iterator(); } /** * Regresa el usuario con el <code>id</code> * especificado. * @param id el id del usuario. * @return El objeto {@link Borrower} con el id especificado. * Regresa <code>null</code> si el objeto con el id * especificado no es encontrado. */ public Borrower getBorrower(String id) { for (Borrower borrower : this.borrowers) { if (borrower.getId().equals(id)) { return borrower; } } return null; } /** * Regresa el número de usuarios en esta * base de datos. * @return el número de usuarios en esta * base de datos. */ public int getNumberOfBorrowers() { return this.borrowers.size(); } }

La Clase Book

La clase Book modela un libro como tiene que ir en la información para el usuario. Para

cada libro viene dado el nombre del autor, el número de páginas y el año de edición.


· author y numberofPages.


· public Book(). Crea una colección solo con las instancias de la variables de autor,

número de páginas.

· public String getAuthor(). Devuelve cierto libro como valor al autor.

· public String getNumberofPages(). Regresa una referencia o valor a la variable de

número de páginas.

Implementación:

/** * Esta clase modela un libro. Extiende {@link CatalogItem} y * añade la siguiente información: * el autor del libro, un <code>String</code></li> * el número de páginas del libro, un <code>int</code></li> */ public class Book extends CatalogItem { /* Autor del libro.*/ private String author; /* Número de páginas del libro.*/ private int numberOfPages; /** * Construye un objeto <code>Book</code>. * @param initialCode el código del libro. * @param initialTitle el título del libro. * @param initialYear el año en que fue publicado el libro. * @param initialAuthor el autor del libro. * @param initialNumberOfPages el número de páginas del libro. */ public Book(String initialCode, String initialTitle, int initialYear, String initialAuthor, int initialNumberOfPages) { super(initialCode, initialTitle, initialYear); this.author = initialAuthor; this.numberOfPages = initialNumberOfPages; } /** * Regresa el autor de este libro. * @return el autor de este libro. */ public String getAuthor() { return this.author; }

/** * Regresa el número de páginas de este libro. * @return el número de páginas de este libro. */ public int getNumberOfPages() { return this.numberOfPages; } /** * Regresa la representación string de este libro. * @return la representación string de este libro. */ public String toString() { return super.toString() + "_" + getAuthor() + "_" + getNumberOfPages(); } }

La Clase Borrower

La clase Borrower hace referencia al modelo de un usuario de una biblioteca. Aquel que

pide prestado libros o videos o CDs y que después de utilizarlos los devuelve. Todo

registrado en el programa con un ID para cada uno y con su respectivo nombre para

reconocimiento.


· id, name y borrowedItems.


· public Borrower(). Inicializa las variables para el id, el nombre y los artículos que

el usuario tiene de la biblioteca.

· public boolean equals(Object object). Permite comparar el id que se ingresa con el

que ya esta registrado y al demostrar verdad continua el proceso caso contrario

un mensaje de error se visualizará.

Implementación:

/** * Esta clase modela un usuario de una biblioteca. Contiene la siguiente * información: * El id del usuario, un <code>String</code></li>

* El nombre del usuario, un <code>String</code></li> * Los artículos que han sido prestados al usuario, * un objeto <code>BorrowedItems</code></li> */ public class Borrower { /* Número de identificación del usuario.*/ private String id; /* Nombre del usuario.*/ private String name; /* Artículos prestados al usuario.*/ private BorrowedItems borrowedItems; /** * Construye un objeto <code>Borrower</code>. * La colección de artículos prestados inicialmente está vacía. * * @param initialId el id del usuario. * @param initialName el nombre del usuario. */ public Borrower(String initialId, String initialName) { this.id = initialId; this.name = initialName; this.borrowedItems = new BorrowedItems(); } /** * Regresa el número de identificación de este usuario. */ public String getId() { return this.id; } /** * Regresa el nombre de este usuario. */ public String getName () { return this.name; } /** * Regresa la colección de artículos prestados. */ public BorrowedItems getBorrowedItems () {

return this.borrowedItems; } /** * Regresa <code>true</code> si el id de este usuario es * igual al id del argumento. */ public boolean equals(Object object) { return object instanceof Borrower && getId().equals(((Borrower) object).getId()); } /** * Regresa la representación string de este usuario. */ public String toString() { return getId() + "_" + getName(); } }

La Clase CatalogItem

La clase CatalogItem simplemente modela los artículos de la librería en este caso por un

catálogo. Aquí se visualizara a qué artículo se refiere, con su año de publicación y el

código.


· code, title, year, available. Este último para comprobar la disponibilidad del

artículo.


· public CatalogItem(). Establece la variable de instancia available como verdadero.

Implementación:

La Clase Recording

La clase Recording modela otro de los artículos del catalogo como es una grabación

como un video o CDs. La información que muestra el intérprete y el formato de la

grabación. Debido a la herencia ya van inicializados el año de publicación y el código.


· performer y format. Estas dos variables representan el interprete de la grabación y

el formato de la misma.


· public Recording(). Inicializa las variables.

Implementación:

/** * Esta clase modela una grabación. Extiende {@link CatalogItem} y * añade la siguiente información: * el intérprete de la grabación, un <code>String</code></li> * el formato de la grabación, un <code>String</code></li> */ public class Recording extends CatalogItem { /* Intérprete de la grabación. */ private String performer; /* Formato de la grabación. */ private String format; /** * Construye un objeto <code>Recording</code>. * @param initialCode el código del catálogo de artículos. * @param initialTitle el título del catálogo de artículos. * @param initialYear el año del catálogo de artículos. * @param initialPerformer el intérprete de la grabación. * @param initialFormat el formato de la grabación. */ public Recording(String initialCode, String initialTitle, int initialYear, String initialPerformer, String initialFormat) { super(initialCode, initialTitle, initialYear); this.performer = initialPerformer; this.format = initialFormat; } /** * Regresa el intérprete de esta grabación. * @return el intérprete de esta grabación. */ public String getPerformer() { return this.performer;

} /** * Regresa el formato de esta grabación. * * @return el formato de esta grabación. */ public String getFormat() { return this.format; } /** * Regresa la representación string de esta grabación. * @return la representación string de esta grabación. */ public String toString() { return super.toString() + "_" + getPerformer() + "_" + getFormat(); } }

La Clase LibrarySystem

La clase LibrarySystem modela en si un ejemplo práctico del funcionamiento de una

librería. Es el resultado final del programa y por ende la clase ejecutable. Aquí se ponen

en relación las demás clases realizadas, gracias al concepto de herencia que se las puede

relacionar y ahorrar tiempo y espacio en el código.


· public static Catalog load(). El constructor carga las variables de la

clase Catalog tanto libros como grabaciones para fundamentar la base de datos.

· private static BorrowerDatabase load(). Carga los datos de los usuarios en la base

de datos para que al realizar modificaciones en entrada y salida de libros, se

guarde la información.

· private void displayCatalog(). Despliega los artículos del catálogo sean libros o

grabaciones.

· private void displayCatalogItem(). Despliega el artículo requerido pero antes

solicita el código del artículo para que así compruebe el programa que el artículo

existe en la librería y si está disponible también.

· private displayBorrowerDatabase(). Despliega los usuarios o clientes de la librería

· private displayBorrower(). Despliega al usuario que se solicite pero antes requiere

del código del usuario para ver si el usuario es cliente de la librería y qué

artículos posee.

· private void checkout(). Registra el préstamo de algún libro o grabación a un

usuario y lo guarda.

· private void checkin(). Registra la devolución de algún libro o grabación del

usuario y lo guarda.

Implementación:

import javax.swing.JOptionPane; import java.io.*; import java.util.*; /** * Esta clase implementa un ejemplo del sistema de biblioteca. */ public class LibrarySystem { private static BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in)); private static PrintWriter stdOut = new PrintWriter(System.out, true); private static PrintWriter stdErr = new PrintWriter(System.err, true); private Catalog catalog; private BorrowerDatabase borrowerDB; /** * Carga un catalogo de biblioteca y una base de datos del prestatario * de un archivo y después comienza la aplicación. * @param args argumentos String. * @throws IOException si hay errores en la entrada. */ public static void main(String[] args) throws IOException { Catalog catalog = load(); LibrarySystem app = new LibrarySystem(catalog, load(catalog)); app.run(); } /* * Carga la informacion del catalogo */ private static Catalog load () {

Catalog catalog = new Catalog(); catalog.addItem(new Book("B001", "Effective Java Programming",

2001,"Joshua Bloch", 252)); catalog.addItem(new Book("B002", "Como Programar en Java", 1995, "Deitel", 395)); catalog.addItem(new Book("B003", "Refactoring", 1999,"Martin Fowler", 431)); catalog.addItem(new Book("B004", "Harry Potter y el misterio del principe", 2006, "J.K. Rowling", 322)); catalog.addItem(new Book("B005", "Code Complete", 1993, "Steve C McConnell", 857)); catalog.addItem(new Book("B006", "The Psychology of Comp. Progr.", 1998,"Gerald M. Weinberg", 360));

catalog.addItem(new Book("B007", "Gracias Por El Fuego ", 1999, "Mario Benedetii", 239));

catalog.addItem(new Book("B008", "The Practice of Programming", 1999,"Brian W. Kernighan", 257));

catalog.addItem(new Book("B009", "Odisea", 1000, "Homero",245)); catalog.addItem(new Book("B010", "The Java Programming Language", 2000,"Ken Arnold", 595)); catalog.addItem(new Book("B011", "Etica para Amador", 2001,"Fernando Savater", 496)); catalog.addItem(new Book("B012", "El Arte de Amar", 1996,"Erich Fromm", 680)); catalog.addItem(new Book("B013", "Applying UML and Patterns", 2001, "Craig Larman", 656)); catalog.addItem(new Book("B014", "Harry Potter y el Caliz de Fuego", 1995, "J.K. Rowling", 216)); catalog.addItem(new Book("B015", "Agile Software Development", 2001,"Alistair Cockburn", 256)); catalog.addItem(new Recording("R001", "Getz/Gilberto", 1963,"Stan Getz and Joao Gilberto", "CD")); catalog.addItem(new Recording("R002", "Kind of Blue", 1997, "Miles Davis", "CD")); catalog.addItem(new Recording("R003", "Supernatural", 1999, "Santana", "Tape")); catalog.addItem(new Recording("R004", "Private Collection", 1983, "Jon & Vangelis", "Tape")); catalog.addItem(new Recording("R005", "Abbey Road", 1969, "Beatles", "CD")); catalog.addItem(new Recording("R006", "Joshua Tree", 1990,"U2", "CD"));

return catalog; }

/* * Carga la base de datos de usuarios */ private static BorrowerDatabase load(Catalog catalog) { BorrowerDatabase borrowerDB = new BorrowerDatabase(); Borrower borrower = new Borrower("ID001", "Victor Perez"); borrower. getBorrowedItems().addItem(catalog.getItem("B003")); borrower. getBorrowedItems().addItem(catalog.getItem("R001")); borrower. getBorrowedItems().addItem(catalog.getItem("B012")); borrowerDB. addBorrower(borrower); borrower = new Borrower("ID002", "Carlos Calderon"); borrowerDB. addBorrower(borrower); borrower = new Borrower("ID003", "Fabian Quimbiulco"); borrower. getBorrowedItems().addItem(catalog.getItem("B006")); borrowerDB. addBorrower(borrower); borrower = new Borrower("ID004", "Andres Paez"); borrower. getBorrowedItems().addItem(catalog.getItem("B002")); borrowerDB. addBorrower(borrower); borrower = new Borrower("ID005", "Carmen Suasnavas"); borrowerDB. addBorrower(borrower); borrower = new Borrower("ID006", "Cesar Aguayo"); borrower. getBorrowedItems().addItem(catalog.getItem("B007")); borrower. getBorrowedItems().addItem(catalog.getItem("B009")); borrowerDB. addBorrower(borrower); borrower = new Borrower("ID007", "Cristel Cardenas"); borrower. getBorrowedItems().addItem(catalog.getItem("B011")); borrowerDB. addBorrower(borrower); borrower = new Borrower("ID008", "Paco Moncayo"); borrower. getBorrowedItems().addItem(catalog.getItem("R003")); borrower. getBorrowedItems().addItem(catalog.getItem("B005")); borrowerDB. addBorrower(borrower); borrower = new Borrower("ID009", "Santiago Bravo"); borrowerDB. addBorrower(borrower);

borrower = new Borrower("ID010", "Luis Bravo"); borrower. getBorrowedItems().addItem(catalog.getItem("B004")); borrowerDB. addBorrower(borrower); return borrowerDB; } /* * Construye un objeto <code>LibrarySystem</code>. * Inicializa el catalogo y la base de datos del usuario con * los valores especificados en el parámetro. */ private LibrarySystem(Catalog initialCatalog, BorrowerDatabase initialBorrowerDB) { this. catalog = initialCatalog; this.borrowerDB = initialBorrowerDB; } /* * Presenta un menú de opciones y ejecuta la tarea seleccionada. */ private void run() throws IOException { int choice = getChoice(); while (choice != 0) { if (choice == 1) { displayCatalog(); } else if (choice == 2) { displayCatalogItem(); } else if (choice == 3) { displayBorrowerDatabase(); } else if (choice == 4) { displayBorrower(); } else if (choice == 5) { checkOut(); } else if (choice == 6) { checkIn(); } choice = getChoice(); } }

/* Despliega un menú de opciones y verifica la selección del usuario. */ private int getChoice() throws IOException { int input; do { try { String escoger; escoger = JOptionPane.showInputDialog(null,"LIBRERIA CALDERON - QUIMBIULCO\n" + "0. Cerrar\n" + "1. Despliega catalogo\n" + "2. Despliega libros y grabaciones del catalogo\n" + "3. Despliega usuarios\n" + "4. Despliega libros o grabaciones de usuarios\n" + "5. Salida de libros o grabaciones\n" + "6. Reingreso de libros o grabaciones\n\n" + "Escoja opcion: "); input = Integer.parseInt(escoger); if (0 <= input && 6 >= input) { break; } else { JOptionPane.showMessageDialog(null,"Opcion invalida: " + input); } } catch (NumberFormatException nfe) { stdErr.println(nfe);; } } while (true); return input; } /* * Despliega el catálogo. */

private void displayCatalog() { int numberOfItems = this.catalog.getNumberOfItems(); if (numberOfItems == 0) { JOptionPane.showMessageDialog(null,"El catalogo esta vacio"); } else { for (Iterator i = catalog.iterator(); i.hasNext();) { CatalogItem item = (CatalogItem) i.next(); JOptionPane.showMessageDialog(null,item.getCode() + " " + item.getTitle() + " " + (item.isAvailable()? "(A)" : "(NA)")); } } } /* * Despliega el libro del catalogo */ private void displayCatalogItem() throws IOException { CatalogItem item = readCatalogItem(); if (item != null) { JOptionPane.showMessageDialog(null," Titulo: " + item.getTitle()); JOptionPane.showMessageDialog(null," Año: " + item.getYear()); if (item instanceof Book) { Book book = (Book) item; JOptionPane.showMessageDialog(null," Autor: " + book.getAuthor()); JOptionPane.showMessageDialog(null," Numero de paginas: " + book.getNumberOfPages()); } else if (item instanceof Recording) { Recording recording = (Recording) item;

JOptionPane.showMessageDialog(null," Editorial: " + recording.getPerformer()); JOptionPane.showMessageDialog(null," Formato: " + recording.getFormat()); } JOptionPane.showMessageDialog(null," Status: " + (item.isAvailable() ? "Disponible" : "No disponible")); } else { JOptionPane.showMessageDialog(null,"No existe libro con ese codigo"); } } /* * Despliega la base de datos de usuarios */ private void displayBorrowerDatabase() { if (borrowerDB.getNumberOfBorrowers() == 0) { JOptionPane.showMessageDialog(null,”La base de datos de usuarios esta vacia"); } else { for (Iterator i = borrowerDB. iterator(); i.hasNext();) { Borrower borrower = (Borrower) i.next(); JOptionPane.showMessageDialog(null, borrower.getId() + " " + borrower.getName()); } } } /* * Despliega el usuario */ private void displayBorrower() throws IOException { Borrower borrower = readBorrower(); if (borrower != null) { JOptionPane.showMessageDialog(null," Nombre: " + borrower.getName());

BorrowedItems borrowedItems = borrower. getBorrowedItems(); if (borrowedItems. getNumberOfItems() == 0) { JOptionPane.showMessageDialog (null," Sin libros prestados"); } else { JOptionPane.showMessageDialog (null," Libros prestados:"); for (Iterator i = borrowedItems. iterator(); i.hasNext();) { CatalogItem item = (CatalogItem) i.next(); JOptionPane.showMessageDialog(null," " + item.getCode() + " " + item.getTitle()); } } } else { JOptionPane.showMessageDialog(null,"No existe usuario con ese codigo"); } } /* * Resgistra el préstamo de un articulo al usuario. */ private void checkOut() throws IOException { CatalogItem item = readCatalogItem(); if (item == null) { JOptionPane.showMessageDialog(null,"No existe libro con ese codigo"); } else if (item.isAvailable()) { Borrower borrower = readBorrower(); if (borrower == null) { JOptionPane.showMessageDialog(null,"No existe usuario con ese codigo"); } else { borrower. getBorrowedItems().addItem(item); JOptionPane.showMessageDialog(null,"El libro " + item.getCode()

+ " fue prestado a " + borrower.getId()); } } else { JOptionPane.showMessageDialog(null,"El libro " + item.getCode() + " no esta disponible"); } } /* * Registra el regreso de un libro. */ private void checkIn() throws IOException { CatalogItem item = readCatalogItem(); if (item == null) { JOptionPane.showMessageDialog(null, "No existe libro con ese codigo"); } else if (item.isAvailable()) { JOptionPane.showMessageDialog(null,"El libro " + item.getCode() + "no esta prestado"); } else { Borrower borrower = readBorrower(); if (borrower == null) { JOptionPane.showMessageDialog(null,"No existe usuario con ese codigo"); } else { borrower. getBorrowedItems().removeItem(item); JOptionPane.showMessageDialog(null,"El libro " + item.getCode() + " ha sido regresado"); } } } /* * Obtiene el objeto CatalogItem. */ private CatalogItem readCatalogItem() throws IOException { stdErr.print("Codigo del libro "); stdErr.flush();

return this.catalog.getItem(stdIn.readLine()); } /* * Obtiene el objeto usuario. */ private Borrower readBorrower() throws IOException { stdErr.print("Codigo usuario "); stdErr.flush(); return this.borrowerDB. getBorrower(stdIn.readLine()); } } Esta última clase es el ejecutable del programa en el cual se verán relacionadas todas las

clases anteriores aplicando los conceptos antes mencionados.

El programa tiene una pequeña interfaz gráfica para que sea mejor visible al usuario.

Se puede trabajar con el concepto de “archivos” aplicando a este proyecto, pero por

facilidad y por no llegar a un grado de complejidad de nuestro proyecto, el tema de

grabar en archivos esta intrínsecamente en el programa donde al realizar alguna acción,

quedará registrada la acción pero en el tiempo de ejecución del programa, mas no en un

archivo plano como sería conveniente hacerlo.

El funcionamiento del programa es real y para esto se deben realizar un número de

pruebas necesarias por el programador para quedar satisfecho con los resultados.

Pruebas de la aplicación del programa procedimiento para ejecutarlo

Las pruebas se las realiza acabado el programa y se lo hace corriendo la clase del

ejecutable, para nuestro caso la clase “LibrarySystem” que es donde está el código que

permite ingresar los datos por teclado como son:

private static BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in)); private static PrintWriter stdOut = new PrintWriter(System.out, true); private static PrintWriter stdErr = new PrintWriter(System.err, true);

JOptionPane.showInputDialog()

JOptionPane.showMessageDialog()

Al tener ya la clase ejecutable, se la “hace correr” para obtener el programa con la

interfaz gráfica.

Lo que para nuestro programa obtenemos es un menú con las opciones que podemos

tener en la biblioteca como el despliegue de catalogo antes visto en la clase “Catalog” y

“CatalogItem”, el despliegue de la lista de usuarios, el préstamo y reingreso de libros y

grabaciones, los artículos que cierto usuario tiene.

Si al escoger la opción 0. Como muestra la figura, obviamente el programa

automáticamente se cierra debido a la opción que se tiene de “do” y “while”.

Las demás opciones nos permiten visualizar el contenido en el archivo que por defecto

se lo realizo en el mismo código del programa, en este caso de la clase ejecutable.

Para la opción 1. Se tiene los artículos del catalogo que en este caso son de la biblioteca.

Los datos se los puede visualizar en la clase con su respectivo código, nombre del libro,

año de edición, autor y número de paginas en ese orden y son los siguientes:

- "B001", "Effective Java Programming", 2001, "Joshua Bloch", 252.

- "B002", "Como Programar en Java", 1995, "Deitel", 395.

- "B003", "Refactoring", 1999, “Martin Fowler", 431.

- "B004", "Harry Potter y el misterio del príncipe", 2006, "J.K. Rowling", 322.

- "B005", "Code Complete", 1993, "Steve C McConnell", 857.

- "B006", "The Psychology of Comp. Progr.", 1998, "Gerald M. Weinberg", 360.

- "B007", "Gracias Por El Fuego ", 1999, "Mario Benedetii", 239.

- "B008", "The Practice of Programming", 1999,"Brian W. Kernighan", 257.

- “B009", "Odisea", 1000,"Homero", 245.

- "B010", "The Java Programming Language", 2000,"Ken Arnold", 595.

- "B011", "Ética para Amador", 2001,"Fernando Savater", 496.

- "B012", "El Arte de Amar", 1996,"Erich Fromm", 680.

- "B013", "Applying UML and Patterns", 2001,"Craig Larman", 656.

- "B014", "Harry Potter y el Cáliz de Fuego", 1995, "J.K. Rowling", 216.

- "B015", "Agile Software Development", 2001,"Alistair Cockburn", 256.

- "R001", "Getz/Gilberto", 1963, "Stan Getz and Joao Gilberto", "CD".

- "R002", "Kind of Blue", 1997, "Miles Davis", "CD".

- "R003", "Supernatural", 1999, "Santana", "Tape".

- "R004", "Private Collection", 1983, "Jon & Vangelis", "Tape".

- “R005", "Abbey Road", 1969,"Beatles", "CD".

- "R006", "Joshua Tree", 1990, "U2", "CD".

Al escoger la opción antes mencionada se desplegara uno por uno esta lista de artículos

que pertenecen al catálogo así:

Al hacer clic en aceptar tendremos cada uno de los artículos de la librería como son

libros y grabaciones musicales.

Para opción 2. Lo que vamos a obtener es la disponibilidad de algún artículo que se

requiera obviamente ingresando el código del libro. Si el libro existiese observaremos la

información de ese libro y si está disponible o no caso contrario si no existe el libro o no

esta ingresado correctamente el código obtendremos el mensaje de error:

En el gráfico podemos observar que el libro existe y la información del mismo. Así

como el año de publicación, el autor, el número de páginas y el status si está disponible

o no.

Si el código es ingresado incorrectamente, el mensaje será:

Para la opción 3. Tenemos la lista de usuarios desplegados uno por uno y que están

guardados de igual manera que el catálogo en el mismo código dentro de la clase

ejecutable. Para cada usuario se visualizara el código de identificación del mismo y el

nombre:

- "ID001", "Víctor Pérez".

- "ID002", "Carlos Calderón".

- "ID003", "Fabián Quimbiulco".

- "ID004", "Andrés Páez".

- "ID005", "Carmen Suasnavas".

- "ID006", "Cesar Aguayo".

- "ID007", "Cristel Cárdenas".

- "ID008", "Paco Moncayo".

- "ID009", "Santiago Bravo".

- "ID010", "Luis Bravo".

Al escoger la opción antes mencionada se desplegara uno por uno esta lista de los

usuarios miembros de la biblioteca así:

Para la opción 4. Se desplegará la información que se necesita de cierto usuario para

conocer los artículos obtenidos por el mismo sean estos libros o grabaciones, todo

queda almacenado pro en el tiempo de ejecución.

Si se ingresa inclusive mal el código del usuario se mostrará un mensaje de error:

Para la opción 5. Se trata del préstamo de los artículos a los usuarios miembros de la

biblioteca y del registro de los mismos. Para esta opción se pedirá en primer lugar el

código del artículo para que el programa compruebe la disponibilidad y la existencia del

artículo. Después de haber comprobado de que el artículo este disponible, el programa

exigirá el código del usuario al cual se le va a prestar dicho artículo; en esto también se

debe ingresar correctamente el código del usuario para validar el préstamo, caso

contrario dará un aviso de error.

Aquí se puede apreciar la disponibilidad del artículo, como no esta disponible nos

muestra el mensaje.

Para la opción 6. Es en cambio el reingreso de los artículos de algún usuario específico.

Lo mismo que para la opción 5. , aquí se pedirá de igual manera pero en este caso se

ingresara primero el código de usuario y después el artículo devuelto.

De igual manera se mostrara un mensaje si el libro o la grabación no ha sido prestada y

por lo tanto está disponible.

Por lo tanto con estas pruebas se puede comprobar la funcionalidad del programa que en

este caso satisface nuestro objetivo.

Informe Proyecto Poo

Technology

Transcript of Informe Proyecto Poo