Sistema bibliotecario Java

ESCUELA POLITECNICA NACIONAL
INGENIERIA ELECTRONCA Y REDES DE INFORMACION
PROGRAMACION ORIENTADA A OBJETOS

INFORME

TEMA: Aplicación en JAVA “SISTEMA BIBLIOTECARIO”

OBJETIVO: Poner en práctica todos los conocimientos adquiridos durante el
trascurso del semestre en la creación e implementación de un programa interactivo
administrador-usuario.

DESARROLLO DEL PROGRAMA

 Descripción del programa
El programa ofrece varios servicios como son el de visualizar los artículos que se tienen a
disposición, así como también una descripción de los mismo: nombre, autor, año de
publicación, etc. Además podemos tener acceso a la opción de préstamo si es que estamos
registrados en la base de datos Usuarios del sistema, también podemos ver las personas
que tienen artículos prestados y cuáles son.
En definitiva se tienen todos los servicios que se pueden ofrecer en un biblioteca, ofrece un
buen servicio tanto al administrador de la Biblioteca como a los usuarios inscritos.

 Paquetes utilizados

El paquete java.util.- Este paquete es muy útil porque pone a disposición 34 clases
y 13 interfaces que implementan algunas de las estructuras de datos más comunes. Algunas
operaciones sobre fechas y sobre el calendario, y otras cosas. Además el paquete java.util
incluye otros subpaquetes que son: java.util.mime, java.util.zip y java.util.jar que sirven
respectivamente para tratar archivos de tipo MIME, de tipo ZIP y de tipo Java Archive (JAR).

Interfaces
Collection Map
Comparator Map.Entry
Enumeration Observer
EventListener Set
Iterator SortedMap
List SortedSet
ListIterator

Estas interfaces establecen algunas propiedades de nuestras estructuras de datos. Se
implementan en algunas de las siguientes clases.

Clases
AbstractCollection Collections
AbstractList Date
AbstractMap Dictionary
AbstractSequentialList EventObject
AbstractSet GregorianCalendar
ArrayList HashMap
Arrays HashSet
BitSet Hashtable
Calendar LinkedList

1


ListResourceBundle StringTokenizer
Locale Timer
Observable TimerTask
Properties TimeZone
PropertyPermission TreeMap
PropertyResourceBundle TreeSet
Random Vector
ResourceBundle WeakHashMap
SimpleTimeZone
Stack

Excepciones
ConcurrentModificationException NoSuchElementException
EmptyStackException TooManyListenersException
MissingResourceException

 Utilizando el paquete en el código mediante la clase “ArrayList”

public class Catalogo {

private ArrayList<CatalogoItem> items;

public Catalogo(ArrayList<CatalogoItem> items) {
super();
this.items = items;
}

public ArrayList<CatalogoItem> getItems() {
return items;
}

El paquete java.io. Manejo de las I/O.- El paquete que el API estándar de
Java nos proporciona para gestionar las operaciones de I/O tanto del sistema como desde/a
ficheros. Como sabemos, Java es un lenguaje orientado a red, cuyo potencial radica en todo
aquello que tenga que ver con la ejecución de aplicaciones a través de la red y, por tanto,
este paquete se ajusta perfectamente a esta condición permitiendo la gestión de ficheros
desde sitios remotos. Evidentemente, Java va mucho más allá del típico println(), cuyo uso
más normal y natural es el dehacer los "debugging" de la aplicación que estemos creando.
Por último, para los diseñadores de applets, recalcar que Java nos permite escribir sobre un
fichero si previamente hemos autentificado y/o firmado nuestro applet.

Lectura y escritura de ficheros.
En Java, todos los ficheros son orientados a byte por lo que nos proporciona métodos para
leer y escribir desde/a un fichero. No obstante, también nos permite hacer “wrapping” de
dicho flujo orientado a byte para convertirlo a un objeto basado en caracteres.
Las dos principales clases que nos posibilitan trabajar con los ficheros son FileInputStream
y FileOutputStream las cuales crean un enlace entre el flujo de bytes y el fichero. Para abrir
un fichero simplemente le pasamos al constructor de estas clases el nombre de éste, luego
con los métodos read() y write() actuaremos sobre él y finalmente mediante el método
close() cerramos la sesión con el fichero. Más adelante se detallan un poco más estas clases
y las acompañamos de algunos ejemplos útiles.
2


 private static void ArchivoUser() throws Exception{
BufferedReader fin = new BufferedReader(new FileReader("ArchivoUser.txt"));
String line = fin.readLine();

El paquete javax.swing.- El paquete Swing es parte de la JFC (Java Foundation
Classes) en la plataforma Java. La JFC provee facilidades para ayudar a la gente a construir
GUIs. Swing abarca componentes como botones, tablas, marcos, etc...
Las componentes Swing se identifican porque pertenecen al paquete javax.swing.
Swing existe desde la JDK 1.1 (como un agregado). Antes de la existencia de Swing, las
interfaces gráficas con el usuario se realizaban a través de AWT (Abstract Window Toolkit),
de quien Swing hereda todo el manejo de eventos. Usualmente, para toda componente
AWT existe una componente Swing que la reemplaza, por ejemplo, la clase Button de AWT
es reemplazada por la clase JButton de Swing (el nombre de todas las componentes Swing
comienza con "J").

Estructura básica de una aplicación Swing.
Una aplicación Swing se construye mezclando componentes con las siguientes reglas.
 Debe existir, al menos, un contenedor de alto nivel (Top-Level Container), que
provee el soporte que las componentes Swing necesitan para el pintado y el manejo
de eventos.
 Otras componentes colgando del contenedor de alto nivel (éstas pueden ser
contenedores o componentes simples).

 Utilización de Swing mediante JOptionPane

default:
JOptionPane.showMessageDialog(null,"No existe esta opcion");

 FUNDAMENTOS DEL LENGUAJE DE JAVA

Características de la POO
Encapsulamiento: Significa reunir a todos los elementos que pueden considerarse
pertenecientes a una misma entidad, al mismo nivel de abstracción. Esto permite aumentar
la cohesión de los componentes del sistema.

 En esa parte de la clase LibrarySistem se ha implementado el encapsulamiento
consistente en el agrupamiento de datos y su tratamiento en una misma estructura

public class LibrarySistem {

private static Catalogo catalogo;
private static BorrowerDataBase borrower;
private static BufferedReader stdIn = new BufferedReader(new
InputStreamReader(System.in));

public static void main(String[] args)throws IOException {

3


Herencia: las clases no están aisladas, sino que se relacionan entre sí, formando una
jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento de
todas las clases a las que pertenecen. La herencia organiza y facilita el polimorfismo y el
encapsulamiento permitiendo a los objetos ser definidos y creados como tipos
especializados de objetos preexistentes. Esto suele hacerse habitualmente agrupando los
objetos en clases y estas en árboles o enrejados que reflejan un comportamiento común.
Cuando un objeto hereda de más de una clase se dice que hay herencia múltiple.

public class Recording extends CatalogoItem {
public class Book extends CatalogoItem {

Recording

Catalogo Item

Book

De lo cual observamos en este ejemplo que la clase Recording y la clase Book hereda de la
superclase Catalogo Item.

Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden
compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento
correspondiente al objeto que se esté usando. O dicho de otro modo, las referencias y las
colecciones de objetos pueden contener objetos de diferentes tipos, y la invocación de un
comportamiento en una referencia producirá el comportamiento correcto para el tipo real
del objeto referenciado.

 La subclase Recording y Book re-escribe el método de la
Superclase Catalogo Item

Subclase Recording:
public String toString(){

String cadena = "codigo : " + code +"n" +"Año: "+ year +"n" +"Autor: " + author +
"n"
+ "Formato: " + format +"n" +"Estado:" ;

if (available == true)
cadena += "Disponible";
else
cadena += "No Disponible";
return cadena;
}
public String toString4(){
String formato = "";
formato = "P_" + code +"_" + title + "_" + year+ "_" + available +"_" + author + "_" +
format ;

return formato;
}

4


Super clase Catalogo Item:

String cadena = code + " " + title + " " ;
cadena += "<D>";
else
cadena += "<ND>";
return cadena;
}
public abstract String toString1();

NOTA
Llevando la idea de herencia a un extremo podemos las clases definidas en Catalogo Item:
public abstract String toString1(); y public abstract String toString4(); son clases abstractas
son clases parcialmente definidas, no se puede hacer un new de una de ellas ya que no
posee instancias.

 En la clase catalogo se emplea los array que estos son estructuras de
memoria que almacenan en una variable múltiples valores del mismo tipo.

import java.util.*;
public class Catalogo {

private ArrayList<CatalogoItem> items;

public Catalogo(ArrayList<CatalogoItem> items) {
super();
this.items = items;
}

public Catalogo() {

items = new ArrayList<CatalogoItem>();
}

 Itemes:Devuelve el valor de los atributos de <code>Items</code>
@return valor al atributo <code>Items</code>

public ArrayList<CatalogoItem> getItems() {
return items;
}

 Asigna el valor para los atributos del objeto tipo<code>Items</code>
@param items contiene el campo para el atributo <code>Items</code>

public void setitems(ArrayList<CatalogoItem> items) {
this.items = items;

5


}
public void addItem(CatalogoItem item){
items.add(item);
}
public CatalogoItem getItem(int index) {
return items.get(index);

}

CatalogoItem(String code, String title, int year, boolean available) {
super();
this.code = code;
this.title = title;
this.year = year;
this.available = available;
}

NOTA:
This:

Al acceder a variables de instancia de una clase, la palabra clave this hace referencia a los
miembros de la propia clase. Java incluye un valor de referencia especial llamado this, que
se utiliza dentro de cualquier método para referirse al objeto actual. El valor this se refiere
al objeto sobre el que ha sido llamado el método actual.

Ejemplo

this.year = year;

 Retorna un objeto del tipo <code>CatalogoItem</code> si encuentra el
<code>Codigo</code> enviado @param codigo contiene el campo para el atributo
<code>Codigo</code> que va ser ingresado@return temp cadena con la
informacion de un objeto del tipo <code>CatalogoItem</code>

public CatalogoItem getItem(String codigo){
for(CatalogoItem temp : items){
if(temp.getCode().equals(codigo)){

return temp;
}
}
return null;
}
public int numeroDeItems(){
return items.size();
}
}

6


 En la clase CatalogoItem permite manipular objetos tipo
<code>CatlogoItem</code>

public abstract class CatalogoItem {

protected String code;
protected String title;
protected int year;
protected boolean available;

 Se inicializa un objeto tipo <code>CatalogoItem</code> con valores dados
@param code contiene el valor del atriuto <code>code</code>
@param title contiene el valor del atriuto <code>title</code>
@param year contiene el valor del atriuto <code>year</code>
@param available contiene el valor del atriuto <code>available</code>

CatalogoItem(String code, String title, int year, boolean available) {
super();
this.code = code;
this.title = title;
this.year = year;
}

 Nos Devuelve el valor al atributo <code>Code</code>
@return valor al atributo <code>Code</code>

public String getCode() {
return code;
}

 Asigna el valor del atributo <code>Code</code>
@param author contiene el campo para el atributo <code>Code</code>

public void setCode(String code) {
this.code = code;
}
public String getTitle() {
return title;
}

 Asigna el valor del atributo <code>Title</code>
@param title contiene el campo para el atributo <code>Title</code>

public void setTitle(String title) {
this.title = title;
}

7


 @return valor al atributo <code>Year</code>

public int getYear() {
return year;
}

 Asigna el valor del atributo <code>Year</code>
@param year contiene el campo para el atributo <code>Year</code>

public void setYear(int year) {
this.year = year;
}

 @return valor al atributo <code>Available</code>

public boolean isAvailable() {
return available;
}

 Asigna el valor del atributo <code>Available</code> @param available contiene el
campo para el atributo <code>Available</code>

public void setAvailable(boolean available) {
}

 Retorna una cadena de caracteres con el formato de la informacion de los item que
pertenecen al <code>CatalogoItem<code>
@return cadena contiene la cadena con la informacion de los Item del
<code>CatalogoItem<code>


String cadena = code + " " + title + " " ;
cadena += "<D>";
else
cadena += "<ND>";
return cadena;

}

Método Abstracto
 Una clase que tiene al menos un método abstracto, es una clase abstracta.
Para declarar un método o una clase abstracta se usa la palabra abstract.

8


Cuando en una clase derivada no se redefine un método abstracto mediante una
implementación, el método continúa siéndolo en la clase derivada.
No se permite la creación de objetos de clases abstractas


return code + " " + title ;
}

}

 En la clase Borrower hay el encapsulamiento que permite la protección de la
manipulación externa de algunas partes de los objetos

public class Borrower {

private String id;
private String name;
private BorrowedItem borrowedItem;

 Inicializa con valores dedos un objeto del tipo <code>Borrower</code>

Borrower(String id, String name, BorrowedItem borrowedItem) {

super();
this.id = id;
this.name = name;
this.borrowedItem = borrowedItem;
}

 Inicializa por defecto un objeto del tipo <code>Borrower</code>

Borrower(String id, String name){
this.id = id;
this.name = name;
borrowedItem = new BorrowedItem();
}

public String getName() {
return name;

public void setName(String name) {
this.name = name;

public String getId() {
return id;

public void setId(String id) {
this.id = id;

9


}

public String getname() {
return name;
}

public void setname(String name) {
this.name = name;
}

 Con la creación de esta clase nos permite manipular objetos del tipo
<code>BorrowedItem</code>

public BorrowedItem getBorrowedItem() {
return borrowedItem;

public void setBorrowedItem(BorrowedItem borrowedItem) {
this.borrowedItem = borrowedItem;
}


String listaUsu = id + " " + name ;

return listaUsu;
}


String listaUsu = name + "n" + borrowedItem.toString() ;

return listaUsu;

}



formato = id + "_" + name ;

for (CatalogoItem item : borrowedItem.getCatalogo()) {
formato += "_" + item.getCode();
}

return formato;
}
}

public class BorrowedItem {

private ArrayList<CatalogoItem> catalogo;

10


public BorrowedItem(){

catalogo =new ArrayList<CatalogoItem>();
}

BorrowedItem(ArrayList<CatalogoItem> catalogo) {
super();
this.catalogo = catalogo;
}

public ArrayList<CatalogoItem> getCatalogo() {
return catalogo;
}

public void setCatalogo(ArrayList<CatalogoItem> catalogo) {
this.catalogo = catalogo;
}

 Permite añadir un <code>Item</code> al <code>CatalogoItem</code>
@param item contiene el campo para el el atributo <code>Item</code>

public void añadirItem(CatalogoItem item){

catalogo.add(item);
}

 Permite eliminar un <code>Item</code> del<code>CatalogoItem</code>
@param item contiene el campo que va ser eliminado

public void removeItem(CatalogoItem item){

catalogo.remove(item);
}

public CatalogoItem getItem(int index) {

return catalogo.get(index);
}

 Retorna una cadena del tipo <code>CatalogoItem</code> si encuentra el
<code>Codigo</code>
 @param codigo contiene el campo para el atributo <code>Codigo</code> que va
ser ingreasado
 @return una cadena del tipo <code>CatalogoItem</code> si encuentra el
<code>Codigo</code> o un null en caso contrario

public CatalogoItem get(String codigo){

11


for(CatalogoItem temp : catalogo){
if(temp.getCode().equals(codigo)){

return temp;
}
}

return null;
}


return catalogo.size();
}


String lista = "";
for(CatalogoItem temp : catalogo){
lista +=temp.getCode()+ " " + temp.getTitle()+"n";
}
return lista;
}
}

 En la clase BorrowerDataBase se ha implementado arrays.
Los arrays son estructuras de memoria que almacenan en una variable múltiples
valores del mismo tipo.
Permite manipular un objeto del tipo <code>BorrowerDataBase</code>

 Se ha creado un objeto de tipo array, cuando se instancia un objeto array, sus
elementos se inicializan al valor por defecto del tipo correspondiente

public class BorrowerDataBase {

private ArrayList<Borrower> borrower;

public BorrowerDataBase(){

borrower= new ArrayList<Borrower>();
}

public BorrowerDataBase(ArrayList<Borrower> borrower) {
super();
this.borrower = borrower;
}

public ArrayList<Borrower> getBorrower() {
return borrower;
}

12


public void setBorrower(ArrayList<Borrower> borrower) {
this.borrower = borrower;
}

public void addBorrower(Borrower borrower1){

borrower.add(borrower1);

}

public Borrower getBorrower(int index) {

return borrower.get(index);
}

public Borrower get(String id){

for(Borrower temp : borrower){
if(temp.getId().equals(id)){

return temp;
}
}

return null;
}


return borrower.size();
}

}

 En la creación de la clase BOOK tenemos la herencia que permite que se puedan
definir nuevas clases basadas en clases existentes, lo cual facilita la reutilizar código
previamente desarrollado. Si una clase deriva de otra (extends) hereda todas sus
variables y métodos. La clase derivada puede añadir nuevas variables y métodos
redefinir las variables y métodos heredados.

public class Book extends CatalogoItem {

private String author;
private int numberOfPag;

public Book(String code, String title, int year, boolean available,String author, int
numberOfPag) {
super(code, title, year, available);

this.author = author;
this.numberOfPag = numberOfPag;
13


public String getauthor() {
return author;
}

public void setauthor(String author) {
}

public int getNumberOgPag() {
return numberOfPag;
}

public void setNumberOgPag(int numberOgPag) {
this.numberOfPag = numberOgPag;
}


String detalle="";

detalle += "Titulo : " + title + "n" + "Año :" + year + "n"
+ "Numero de Paginas : " + numberOfPag + "n" + "Estado : ";

detalle += "<D>";
else
detalle += "<ND>";
return detalle;
}



formato = "B_" + code +"_" + title + "_" + year+ "_" + available +"_" + author + "_" +
numberOfPag ;

return formato;

}

}

 La clase Recording deriva de CatalogoItem lo cual quiere decir que hereda sus
métodos y variable miembro.

public class Recording extends CatalogoItem {

private String author;
private String format;
14


public Recording(String code, String title, int year, boolean available,String
author,String format) {
super(code, title, year, available);
// TODO Auto-generated constructor stub
this.format= format;
}

public String getAuhor() {
return author;
}

public void setAutor(String author) {
}

public String getFormat() {
return format;
}

public void setFormat(String format) {
this.format = format;
}


String cadena = "codigo : " + code +"n" +"Año: "+ year +"n" +"Autor: " +
author + "n"
+ "Formato: " + format +"n" +"Estado:" ;

cadena += "Disponible";
else
cadena += "No Disponible";
return cadena;
}



formato = "P_" + code +"_" + title + "_" + year+ "_" + available +"_" +
author + "_" + format ;

return formato;

}

}

15


UTILIZACION DEL PROGRAMA

1. Se observa un menú, en la cual se seleccionara una opción.
2. Este programa solo aceptara ingresar números entre [0-6] para seleccionar la
opción, si se ingresa una letra u otro numero fuera del intervalo especificado, se
producirá una validación.

3. Si escogemos la opción 1 mostrará el catalogo de artículos que posee nuestra
biblioteca, y se visualizara cual libros estarán disponibles o no.

16


4. Se puede ver la lista de los usuarios inscritos en nuestra biblioteca, los cuales tienen
la posibilidad de tomar prestados los artículos de la biblioteca.

5. Podemos ver detalladamente las características del libro.

6. Podemos ver si el usuario tiene un libro prestado o no.

7. El usuario puede verificar si el libro esta prestado o no, si no está prestado se lo
puede llevar.

17


8. Luego se actualizara el catalogo, se podrá verificar que el libro ha sido prestado es
decir no está disponible <ND>.

9. Podemos también regresar el artículo colocando nuestro código del artículo y el
código de identificación, actualizándose la base de datos.

18


19

Sistema bibliotecario Java

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Sistema bibliotecario Java

Similar a Sistema bibliotecario Java (20)

Último

Último (20)

Sistema bibliotecario Java