Aplicación biblioteca préstamo libros música Java

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.
*/

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.
*/

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"));
borrowerDB. addBorrower(borrower);

borrower = new Borrower("ID002", "Carlos Calderon");

borrower = new Borrower("ID003", "Fabian Quimbiulco");

borrower = new Borrower("ID004", "Andres Paez");

borrower = new Borrower("ID005", "Carmen Suasnavas");

borrower = new Borrower("ID006", "Cesar Aguayo");

borrower = new Borrower("ID007", "Cristel Cardenas");

borrower = new Borrower("ID008", "Paco Moncayo");
borrower. getBorrowedItems().addItem(catalog.getItem("R003"));

borrower = new Borrower("ID009", "Santiago Bravo");

borrower = new Borrower("ID010", "Luis Bravo");

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();
displayBorrowerDatabase();
displayBorrower();
checkOut();
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 -
QUIMBIULCOn" +
"0. Cerrarn"
+ "1. Despliega catalogon"
+ "2. Despliega libros y grabaciones del
catalogon"
+ "3. Despliega usuariosn"
+ "4. Despliega libros o grabaciones de
usuariosn"
+ "5. Salida de libros o grabacionesn"
+ "6. Reingreso de libros o grabacionesnn"
+
"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 {


if (item == null) {
JOptionPane.showMessageDialog(null,"No existe libro con
ese codigo");
} else if (item.isAvailable()) {


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 {
item.getCode() +
" no esta disponible");
}
}

/*
* Registra el regreso de un libro.
*/
private void checkIn() throws IOException {


if (item == null) {
JOptionPane.showMessageDialog(null,
"No existe libro con ese codigo");
} else if (item.isAvailable()) {
item.getCode() + "no esta prestado");
} else {


if (borrower == null) {
JOptionPane.showMessageDialog(null,"No existe
usuario con ese codigo");
} else {
borrower. getBorrowedItems().removeItem(item);
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.

Aplicación biblioteca préstamo libros música Java

Recommandé

Recommandé

Contenu connexe

Similaire à Aplicación biblioteca préstamo libros música Java

Similaire à Aplicación biblioteca préstamo libros música Java (20)

Dernier

Dernier (20)

Aplicación biblioteca préstamo libros música Java