PROYECTO2-Archivo de Texto

cÜÉzÜtÅtv|™Ç \i \ÇyArEDEcÜÉzÜtÅtv|™Ç \i \ÇyArEDEcÜÉzÜtÅtv|™Ç \i \ÇyArEDEcÜÉzÜtÅtv|™Ç \i \ÇyArEDE

cÜÉçxvàÉ 6EcÜÉçxvàÉ 6EcÜÉçxvàÉ 6EcÜÉçxvàÉ 6E `tÇx}É Wx TÜv{|äÉá wx gxåàÉ`tÇx}É Wx TÜv{|äÉá wx gxåàÉ`tÇx}É Wx TÜv{|äÉá wx gxåàÉ`tÇx}É Wx TÜv{|äÉá wx gxåàÉ

Manejo de Archivos de Textos

Universidad de Panamá

CRUV - 2007

Manejo de Archivos de texto

- 2 -

UNIVERSIDAD DE PANAMÁ CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

FACULTAD DE INFORMÁTICA, ELECTRÓNICA Y COMUNICACIÓN LICENCIATURA EN INFORMÁTICA PARA LA GESTIÓN EDUCATIVA Y

EMPRESARIAL

“Programación IV Inf._212”“Programación IV Inf._212”“Programación IV Inf._212”“Programación IV Inf._212”

“Proyecto # 2”

“Manejo de Archivos de Textos”

ESTUDIANTE:

BALLESTEROS, DANIEL CED. 9-704-1031 ORTEGA, AMANDA CED. 9-723-367

PROFESOR:

DIEGO SANTIMATEO

SEMESTRE: II SEMESTRE – II AÑO

FECHA DE ENTREGA: 26-OCTUBRE-2007


- 3 -

Índice

INTRODUCCIÓN ................................................................................................................ 4

OBJETIVOS ....................................................................................................................... 5

DESCRIPCIÓN DE CONCEPTOS ........................................................................................... 6

ANÁLISIS Y DISEÑO ORIENTADO A OBJETOS ...................................................................... 9

DESCRIPCIÓN DEL PROBLEMA O DOMINIO.....................................................................10

DEFINICIÓN DEL DOMINIO............................................................................................10

OBJETIVOS DE LA APLICACIÓN......................................................................................10

OBJETIVO GENERAL ......................................................................................................10

OBJETIVOS ESPECÍFICOS ..............................................................................................10

ANÁLISIS ORIENTADO A OBJETOS .................................................................................11

CLASES DEL DOMINIO...................................................................................................11

DESCRIPCIÓN DE LAS CLASES DEL DOMINIO..................................................................12

IDENTIFICACIÓN DE LOS ATRIBUTOS Y PROPIEDADES DE LAS CLASES............................13

DIAGRAMA UML ............................................................................................................14

CARACTERIZACIÓN DE LAS ESTRUCTURAS DE DATOS UTILIZADAS .....................................15

DESCRIPCIÓN DE LAS FUENTES DE INFORMACIÓN UTILIZADAS..........................................17

CÓDIGOS –CLASES DEL PROGRAMA...................................................................................22

EVIDENCIAS DE LA EJECUCIÓN .........................................................................................30

REFLEXIÓN SOBRE EL TRABAJO EN EQUIPO Y LA METODOLOGÍA PROPUESTA. ....................34

EVALUACIÓN INDIVIDUAL DE LA EXPERIENCIA ..................................................................36

BIBLIOGRAFÍAS - WEBGRAFIAS ........................................................................................39


- 4 -

INTRODUCCIÓN

Los Archivos se definen como una de las estructuras de datos que permite el

almacenamiento de datos en forma masiva, estos pueden ser secuenciales o de texto

o binario de acceso directo. El proceso de lectura de un archivo de texto es similar a la

lectura desde el teclado. En esta ocasión trabajaremos con archivos de texto para el

desarrollo de una aplicación desarrollada en el lenguaje de programación Java.

Este documento trata sobre una aplicación práctica estructurada siguiendo los

conceptos del paradigma Orientado a Objetos que consiste en crear una aplicación

Java, debidamente estructurada con las clases necesarias y algoritmos eficientes, que

permita consultar a partir de la cédula, las calificaciones identificadas con asignatura y

docente, así como también los datos generales de facultad escuela, y carrera.

Para su desarrollo trabajamos con un archivo de texto que contiene las calificaciones de

los estudiantes del CRUV, correspondientes al segundo semestre de 2006, del cual se

extrae los datos de la Facultad que el usuario decida consultar.

Se desarrolla entonces en este documento: La definición del problema, el Diagrama

UML, la descripción de las clases, la caracterización de las estructuras de datos

utilizadas, desarrollo de las estrategias para obtener información, metodología utilizada

y conocimientos adquiridos durante el desarrollo de la aplicación.


- 5 -

OBJETIVOS

- Objetivo General :

Crear una aplicación Java, debidamente estructurada y siguiendo los conceptos del

paradigma orientado a objetos, que permita consultar a partir de la cédula, las

calificaciones de los estudiantes del C.R.U.V. del segundo semestre -2006, cada

una identificadas con asignatura y docente, así como también los datos generales de

facultad escuela, y carrera.

- Objetivos Específicos

• Consultar documentos que permitan la estructuración del diagrama de UML, y la

definición del diseño de las clases.

• Extraer del archivo de texto original los datos de la facultad para la búsqueda de

datos.

• Elaborar las clases necesarias y los algoritmos que permitan dar funcionamiento

eficiente a la aplicación.

• Probar la aplicación siguiendo la estrategia sugerida en las diferentes

documentaciones consultadas.


- 6 -

Descripción de ConceptosDescripción de ConceptosDescripción de ConceptosDescripción de Conceptos


- 7 -

Descripción breve de algunos Conceptos:

A continuación presentamos una breve descripción de conceptos y nombres de métodos

utilizados en la elaboración de este proyecto.

Archivo: Los Archivos se definen como una de las estructuras de datos que permite el

almacenamiento de datos en forma masiva, estos pueden ser secuenciales o de texto

o binario de acceso directo.

Métodos internos-Java:

- Equals(): Compara un String con un objeto cualquiera que puede ser otro

String, y devuelve true cuando dos Strings son iguales o false si son distintos.

- Substring(posi, posf(): Nos permite extraer un substring especificando la

posición de comienzo y la el final.

- indexOf(): Busca si un String o parte de ese String se encuentra dentro de otro

específico.

- startsWith(cad,pos): busca un String dentro de otra cadena, a partir de la

posición específica.

Clases especiales:

Clases FileReader y FileWriter están orientadas a manejar ficheros de texto, permitiendo

tanto operaciones de lectura como de escritura. Ambas pertenecen al package java.io

- FileReader: abre un fichero de texto en modo lectura.

- FileWriter: abre un fichero de texto en modo escritura.

- BufferedReader: El buffering es una técnica que aumenta la eficacia de

entrada y salida. En vez de leer o escribir inmediatamente en el disco cada vez

que se solicita la operación, el objeto de flujo utilizará el buffer siempre que

pueda. BufferedReader también ofrece la función readLine(), que permite al

usuario leer líneas en vez de caracteres.


- 8 -

Excepción El término excepción es una forma abreviada de "evento excepcional" que se produce

durante la ejecución de un programa que interrumpe el flujo normal de instrucciones.

Cuando Java se encuentra con una excepción: o detiene el procesado del código en el

que está trabajando, o crea un tipo concreto de objeto de excepción, o ejecuta la rutina

que gestiona dicha excepción.

Tipos de excepciones

Existen dos tipos de excepciones en Java: comprobadas y sin comprobar.

Las excepciones comprobadas se producen por algún error en el entorno en el que se

desarrolla el código. Por ejemplo, si el código intenta leer información de un archivo

que no existe, el programa arrojará una excepción IOException. Una excepción

comprobada se escapa del control del programador: puede producirse incluso si el

código no contiene ni un solo error. Por lo tanto, debe estar preparado para obtener

excepciones comprobadas en el código: podrá detectarlas o arrojarlas.

Las excepciones no comprobadas suelen producirse por errores de programación. En

este caso, lo más indicado es corregir el programa.


- 9 -

Análisis y Diseño Orientado a ObjetosAnálisis y Diseño Orientado a ObjetosAnálisis y Diseño Orientado a ObjetosAnálisis y Diseño Orientado a Objetos


- 10 -

DESCRIPCIÓN DEL PROBLEMA

Diseño y desarrollo de una aplicación Java que permita extraer de un archivo de texto

con las diferentes facultades del C.R.U.V, una facultad específica y a partir de ésta

consultar, por medio de la cédula del estudiante, las calificaciones y demás datos que la

identifiquen.

Definición del dominio El dominio de este problema es la matricula de estudiantes del Centro Regional

Universitario de Veraguas en el segundo semestre del año 2006, ya que representa el

ámbito para el cual se desarrolla la aplicación y en el cual se encuentran los datos

solicitados por el sistema.

OBJETIVOS DE LA APLICACIÓN

Objetivo General: Identificar a partir de la cédula, las calificaciones de los estudiantes del CRUV en el

segundo semestre del año 2006, extrayendo los datos de una facultad específica e

identificando las calificaciones con los datos de la escuela, carrera, asignatura y

docente.

Objetivos Específicos: • Extraer del archivo original, la Facultad que el usuario desee consultar.

• Realizar una búsqueda en el archivo que contiene los datos de la Facultad

escogida mediante la cédula del estudiante, donde se identifique la cédula

buscada, escuela, carrera, calificación, profesor y asignatura.

• Desplegar en una ventana los resultados obtenidos mediante la búsqueda

realizada.


- 11 -

Class GetFile

NewFile;

OriginalFile;

Facultad;

Crear( );

Class LookFile

Archivo;

Cedula;

GetDat( );

Class CaptureDisplay

GetDatos( );

Despliega();

ANÁLISIS ORIENTADO A OBJETOS

A partir de la descripción del problema o dominio, de obtener los objetivos del Sistema,

utilizaremos las etapas del Análisis Orientado a Objeto, (documento Miguel Ángel

Abían), para así describir el dominio del problema mediante clases y objetos.

ETAPAS DEL ANÁLSIS ORIENTADO A OBJETOS Identificación de las clases de dominio

Elaboración del glosario de términos (se omite).

Identificación de los atributos o propiedades de las clases

Diagrama UML

CLASES DEL DOMINIO Identificación de las clases del dominio Para la identificación de las Clases del dominio, utilizaremos las técnicas de identificación de sustantivo

Clases del Dominio


- 12 -

Descripción de las clases del dominio: A continuación se realiza una descripción de las clases abstraídas que forman parte de la aplicación.

Descripción del Funcionamiento de cada Clase

Clases Atributos Comportamientos

Class GetFile

En esta clase se encuentran variables de instancia privadas:

NewFile: Nombre del archivo de texto que se crea a partir del archivo original.

OriginalFile: Archivo de texto original del que se extraen los datos de una facultad específica.

Facultad: Indica el nombre de la facultad que se desea consultar.

Funcionalidad del método:

Crear (): Mediante este método se extrae del archivo original, los datos de la facultad que indique el usuario. Utiliza las variables de instancia NewFile y OriginalFile… Se abre el archivo original para leer por línea y se crea un nuevo archivo que guarda los datos de la facultad específica. Métodos internos –Java utilizados:

• startsWith(cad,pos): Se utilizó para determinar si la facultad indicada por el usuario se encontraba a partir de la posición 15 del archivo..

• indexOf(): Busca en la línea que contiene los datos de la facultad, si el nombre de la facultad buscada se encuentra.

Class LookCed

En esta clase contiene variables de instancia privadas:

Cedula: Es la cédula del estudiante para la búsqueda de calificaciones.

Archivo: Archivo de texto que contiene una facultad específica, para la búsqueda de calificaciones mediante la cédula del estudiante.


GetDat (): Este método se encarga de realizar la búsqueda para determinar mediante la cedula, las calificaciones del estudiante identificadas por escuela, carrera, asignatura y profesor. Métodos internos –Java utilizados:

• Substring(posi, posf(): Nos permite extraer la cédula del estudiante desde las posiciones indicadas, para luego ser comparadas.

• indexOf(): Busca si dentro de la línea leída se encuentra parte de la cadena (cédula)…

• Equals(): Compara si la cédula introducida es igual a la cadena extraída del archivo, si es verdadero entonces despliega los datos solicitados.

• Split(): se utiliza para dividir la línea leída desde el archivo y luego seleccionar la calificación del estudiante.

Class Capture Display

---------------------------------


getDatos(): Captura los datos solicitados por el sistema.

Despliega (): Despliega los resultados obtenidos mediante la búsqueda.


- 13 -

Identificación de los atributos y propiedades de las clases

En esta etapa se identifican los atributos y propiedades que tendrán las clases, como

sabemos los atributos o características de una Clase pueden ser de tres tipos,

mediante estos se define el grado de comunicación y visibilidad de ellos con el entorno,

en nuestro proyecto todos los atributos o variables de instancia utilizadas son privadas y

se identifican con la imagen que mantienen en la parte izquierda - -

El procedimiento para la gestión de los atributos se dio mediante la identificación de los

posibles valores comunes a los objetos de una clase:

En cuanto a la clase GetFile, se obtiene de un archivo de texto original un archivo más

pequeño, mediante el nombre de la facultad elegida, de aquí identificamos como

atributos:

NewFile: que es el archivo que se crea cada vez que elegimos una facultad.

OrieginalFile: Es el archivo original del cual se pueden obtener los datos de una

facultad específica.

Facultad: Indica el nombre de la facultad a la cual pertenece el estudiante.

En la clase LookCed, se busca la cédula del estudiante con el fin de desplegar las

notas y datos de la asignatura encontrada, sus atributos:

Cedula: es la cédula que se busca.

Archivo: Es el archivo obtenido del original y del cual se extraerán las calificaciones.

A continuación presentamos el Diagrama de Modelamiento de clases para una mejor

organización jerárquica de las clases. El mismo identifica atributos, tipo de variables,

(primitivas o de la clase String), y métodos que le permitirán interactuar y realizar

diferentes operaciones.


- 14 -

Class GetFile

NewFile: String;

OriginalFile: String;

Facultad: String;

Crear( );

Class LookFile

Archivo: String;

Cedula: String;

GetDat( );

Class CaptureDisplay

GetDatos( );

Despliega();

Class PincClass

Búsqueda de Calificaciones

Main( );

Diagrama UML (Organización de las clases- incluye: Nombre de la clase, atributos y métodos)


- 15 -

Caracterización de las Estructuras de Datos Caracterización de las Estructuras de Datos Caracterización de las Estructuras de Datos Caracterización de las Estructuras de Datos UtilizadasUtilizadasUtilizadasUtilizadas


- 16 -

Caracterización de las Estructuras de Datos Utilizadas Caracterización de las estructuras de datos seleccionadas Incluye su utilidad (nombre, tipo o estructura, para qué será usada) y dónde será usada.

Estructuras de Datos Utilizadas..

Estructura Nombre Tipo Utilidad Donde es Utilizada

Archivo de texto

prueba.txt

File

En este archivo guardamos los datos de la facultad que seleccione el usuario. Los datos contenidos en este archivo, serán utilizados para la búsqueda mediante la cedula.

Esta estructura de datos es utilizada en la siguiente clase de la aplicación -Java: - Class LookCed: Mediante un método de esta clase, llamado GetDat(), se realiza la búsqueda en el archivo prueba.txt, para así determinar las calificaciones identificadas con asignatura y docente, al igual que los datos generales de facultad escuela, y carrera..

Archivo de texto

2006-SEGUNDO.txt

File

Archivo que contiene los datos de todas las facultades del C.R.U.V; y del cual se extrae la facultad con la cual trabajará la aplicación.

Esta estructura de datos es utilizada en la siguiente clase de la aplicación -Java: - Class GetFile: Mediante un método de esta clase, llamado Crear(), se realiza la grabación del archivo prueba.txt, durante este proceso se graban todos los datos de la facultad elegida por el usuario los cuales se encuentran en el archivo original 2006-SEGUNDO.txt.

Array Cedu[ ] String

Array que contiene los datos de la línea del archivo donde se encuentra la calificación del estudiante..

Esta estructura de datos es utilizada en la siguiente clase de la aplicación -Java:

- Class LookCed: Dentro de la clase lookCed, se encuentra el método GetDat, donde se utiliza este vector para realizar una división de los datos contenidos en esta línea, y así desplegar sólo la calificación del estudiante.


- 17 -

Descripción de las Fuentes de Información Descripción de las Fuentes de Información Descripción de las Fuentes de Información Descripción de las Fuentes de Información UtilizadasUtilizadasUtilizadasUtilizadas


- 18 -

Descripción Completa, pero breve de las fuentes de información utilizada y de la

incidencia en la solución del problema:

1- La Clase String:

Referencia Bibliográfica:

Antonio Bel Puchol. Apuntes del Lenguaje Java [en línea]: 17 de junio de 2001.”Capítulo

10. La Clase Strings”. <http://www.arrakis.es/~abelp/ApuntesJava/Strings.htm>

[Consulta: 10 de Septiembre de 2007].

----------------------------------------------------

Descripción Breve del Contenido:

En esta fuente de información se encuentra una guía rápida sobre la Clase Strings:

Primeramente expone una introducción de cómo maneja Java los Strings, después

se demuestra como crear un Strings, como concatenarlos y luego describe los

métodos más utilizados en esta clase. Es en esta sección de la referencia donde nos

encontramos con la parte verdaderamente útil para nosotros de esta fuente de

información .

Incidencia en la solución del problema:

Algunos métodos de la clase Strings que no habiamos utilizado, los encontramos en

esta fuente de información, los métodos .equals(Object obj) que compara si un

String contiene la misma secuencia de caracteres que otro. El método indexOf

(String s), que busca en String y devuelve el índice de la primera aparición de la

subcadena representada por s. Nos fueron de mucha utilidad, ya que podíamos con

estos métodos buscar una cédula para desplegar los datos correspondientes a esta.


- 19 -

2- Strings Class:


Sun Microsystems Inc. Java.lang Class[en línea]: 2003. “java.lang – Class String”

<http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html>[Consulta: 15 de

Octubre de 2007]

-----------------------------------------------


Los Strings son constantes y una vez creados no pueden ser modificados, pero si

pueden ser asignados o compartidos en otras variables; esta referencia bibliográfica

ofrece información en Ingles sobre la clase Strings y como realizar múltiples

acciones en ella a través de los métodos; esta referencia es confiable ya que es

ofrecida por Sun Microsystems, la misma empresa responsable del desarrollo del

lenguaje Java.

En este documento se describen los métodos necesarios para trabajar objetos de la

Clase Strings, una descripción detallada sobre su utilidad y como utilizarlos

adecuadamente.

Incidencia en la solución del problema:

Por ser esta una fuente de información confiable y muy completa, pudimos conocer

el funcionamiento y posibles usos de varios métodos de la Clase String que nos

podrían ser de utilidad a la hora de resolver el problema. Luego de probar varias

opciones de mètodos como startsWith que verifica si un String comienza con el

parámetro dado, indexOf que devuelve el index de la primera ocurrencia de un

string en otro, substring que verifica si un string es parte de otro o tambien puede

obtener este string y de esta forma verificando sus usos logramos encontrar los

métodos de la Clase String que fueran de utilidad a la hora de resolver el problema

propuesto.


- 20 -

3- Operaciones I/O en Java:


Luis Fernando Niño Vásquez. Sistemas Inteligentes [en línea]: Enero 2005,”Operaciones

de Entrada/Salida en Java”, <http://dis.unal.edu.co/~lfnino/softel/cap5/> [Consulta:

12 de Octubre de 2007]

---------------------------------------


Este capítulo sobre Operaciones I/O en Java y comienza mediante la exposición de

las bases conceptuales de las clases de I/O en Java, exponiendo la metáfora de

"tuberías" sobre la que se encuentran apoyadas, a la vez que se ilustran conceptos

fundamentales como flujos, fuentes y filtros, gracias a los cuales se obtendrá de una

forma intuitiva el concepto de conexión entre las diferentes clases de I/O del

paquete java.io.

Incidencia en la Solución del Problema:

El manejo de la Clase I/O fue de vital importancia para la solución de nuestro

problema al momento en que se produce algún error en el entorno en el que se

desarrolla el código. Por ejemplo, si el código intenta leer información de un archivo

que no existe, el programa arrojará una excepción IOException.


- 21 -

4- Usando Clases en Java:


Andres Montano Pellegrini. Usando Clases en Java [en línea] :26 de Diciembre de

2006,<http://www.gaugeus.com/ramblings/2006/12/26/usando-clases-en-java-class-

usage-in-java>, [Consulta: 12 de Octubre de 2007]

----------------------------------------------------


Muy pocos objetos son predefinidos por Java como el System.out, para que

podamos hacer cualquier cosa útil con Java nosotros debemos crear estos objetos.

Esta fuente trata sobre la creación y manejo de objetos en Java.

En una primera parte se aborda la creación y manejo de objetos String. Luego la de

Archivos en disco; operaciones como crearlo, proveerlo de contenido, renombrarlo,

rescribirlo y obtener el contenido. Todo esto enfocado a archivos de texto. En su

parte final el documento trata sobre obtener entradas desde una red, tema que no

le compete al presente proyecto, pero de mucho interés en el aprendizaje del

lenguaje Java.

Incidencia en la Solución del Problema:

Las fuentes de información anteriores a ésta fueron consultadas en su mayoría para

obtener métodos útiles de la Clase Strings. Pero la presente fuente fue la de mayor

utilidad porque además de darnos los conceptos necesarios para la creación de

objetos String, no ofreció los conocimientos necesarios para la correcta apertura y

manejo del archivo trabajado, además del conocimiento de la Clase file y varios

métodos utilizados para su utilización.


- 22 -

Códigos Códigos Códigos Códigos ––––Clases del ProgramaClases del ProgramaClases del ProgramaClases del Programa


- 23 -

/*Clase principal se encarga de inicializar los objetos las diferentes clases realizadas para dar funcionalidad a la aplicación Java, la cual tiene como objetivo consultar a partir de la cédula, las calificaciones identificadas con asignatura y docente, así como también los datos generales de facultad, escuela, y carrera...*/

//Clase Principal ---------------------------------------------------------------------------------------------------------------------------------------------- import javax.swing.*; import java.text.*; import java.lang.String.*; class PrincClass{ public static void main(String[] args) { //Se crea un objeto de la clase CaptureDisplay para acceder a los métodos... CaptureDisplay acces1=new CaptureDisplay(); // se accesa al método de la clase CaptureDisplay para obtener la FACULTAD.... String facultad=acces1.getDatos(); // Se accesa al método de la clase CaptureDisplay para obtener la cédula.... String cedula=acces1.getDatos(); //Se crea un objeto de la clase GetFile... GetFile acces=new GetFile("prueba.txt","2006-SEGUNDO.txt",facultad); // Se accesa al metodo Crear para obtener el archivo nuevo String archivo=acces.Crear(); //Se crea un objeto de la clase LookCed para acceder a los métodos... LookData acess2=new LookData(archivo,cedula); //Se capturan los datos de las calificaciones mediante el metodo GetDat... String dato = acess2.GetDat(); //Se accesa al método Despliega para desplegar los datos... acces1.Despliega(dato,facultad); }fin de la clase }fin del main

/*Del archivo de texto original, extrae los datos del archivo original según la facultad escogida de manera que se crea un archivo de texto


- 24 -

más pequeños y estructurados según los requerimientos de la tarea. */ //****************************************************************************************

//Clase GetFile ---------------------------------------------------------------------------------------------------------------------------------------------- import java.io.*; public class GetFile{ // VARIABLES DE INSTANCIAS //******************************************************************* private String newFile; private String originalFile; private String facultad; // CONSTRUCTOR DE LA CLASE //******************************************************************* public GetFile(String nuev, String princ, String facu) { this.newFile=nuev; this.originalFile=princ; this.facultad=facu; } // METODOS - Crear //Extrae los datos de un archivo a otro específico //******************************************************************* public String Crear(){ int l; boolean sw=true; try { //aqui abrimos el archivo original para leer por línea String viejo=originalFile; FileReader arch1 = new FileReader(viejo); BufferedReader in = new BufferedReader(arch1); String s; //se realiza la grabación de datos en un nuevo archivo String arch = newFile; FileWriter fw = new FileWriter (arch); BufferedWriter bw = new BufferedWriter (fw); PrintWriter salArch = new PrintWriter (bw); // ciclo que recorre el archivo original para realizar


- 25 -

//la grabación en el archivo nuevo boolean op=false; while (((s = in.readLine())!= null) && (sw)) { if ((op) && (((l=s.indexOf("FACULTAD"))!=-1) && (!s.startsWith(facultad,15)))) sw=false; if(((l=s.indexOf(facultad))!=-1)||(op)){ salArch.println (s); op=true;} }//fin del ciclo while salArch.close (); //Excepciones de entrada salida try { in.close(); } catch ( IOException e ) { System.err.println( "El archivo no se pudo cerrar correctamente" ); } } catch (Exception e) { System.err.println("***Error al leer o abrir el archivo...\n" +e); } return(newFile);// retorna nombre del archivo }//Fin del método }//fin de la clasein


- 26 -

/*Clase que contiene un método específico para la busqueda en el archivo de datos, de la facultad escogida. Identifica a partir de la cédula, las calificaciones identificadas con asignatura y docente, así como también los datos generales de facultad escuela y carrera. */ //****************************************************************************************

//Clase LookData ---------------------------------------------------------------------------------------------------------------------------------------------- import java.io.*; import javax.swing.*; public class LookData { // VARIABLES DE INSTANCIAS //**************************************************************************************** private String archObtenido ; private String cedula; // CONSTRUCTOR DE LA CLASE //**************************************************************************************** public LookData(String newArch,String ced) {

this.archObtenido=newArch; this.cedula=ced; } // METODOS - GetDat //Obtiene los datos según la búsqueda que se realiza... //************************************************************************************ public String GetDat(){ String carr="",esc="",asig="",prof=""; String allData="",dat="";int l; boolean sw=true; try {

//aqui abrimos el archivo que contiene la facultad //para leer por linea BufferedReader dato = new BufferedReader(new FileReader(archObtenido));

String s=new String();


- 27 -

/*Este ciclo se recorre el archivo para determinar mediante la cedula las calificaciones del estudiante identificadas por escuela, carrera, asignatura y profesor...*/ while((s = dato.readLine())!= null) { if( s.indexOf("ESCUELA")!=-1) esc=" "+s; if( s.indexOf("CARRERA")!=-1) carr=" "+s; if( s.indexOf("ASIGNATURA")!=-1) asig=" "+s; if( s.indexOf("PROFESOR")!=-1) prof=" "+s; /* Una vez la cedula coincida con la ced. introducida se guardan los siguientes datos: calificaciones identificadas con asignatura y docente, así como también los datos generales de facultad escuela, y carrera..*/ if(((l=s.indexOf(cedula))!=-1)&&(s.substring(15,31).equals(cedula))) { sw=false; String[] cedu = s.split(" "); String calif=(" CALIFICACION:"+cedu[3]); String ced=(" CEDULA BUSCADA: "+cedu[2]+"\n"); String lin=(" --------------------------------------------------------------"+"\n"); dat += "\n"+asig+"\n"+prof+"\n"+ calif+"\n"+lin; allData= esc+ "\n"+ carr +"\n"+"\n"+ced+"\n"+dat; } }// fin del while //En caso de que no se encuentre la cedula //se despliega este mensaje if(sw) allData="**** LA CEDULA INTRODUCIDA NO EXISTE ****"; try { dato.close(); }


- 28 -

catch ( IOException e ) { System.err.println( "El archivo no se pudo cerrar correctamente" ); } }//fin try catch (Exception e) { System.err.println("***Error al leer o abrir el archivo...\n" +e); } return(allData);//retorna todos los datos }//fin del método }//fin de clase


- 29 -

import java.io.*; import javax.swing.*;

//Clase CaptureDisplay ---------------------------------------------------------------------------------------------------------------------------------------------- public class CaptureDisplay { //CONSTRUCTOR public CaptureDisplay( ) { } // METODOS getDatos //Captura la cédula del estudiante para realizar la búsqueda //******************************************************************* public String getDatos() {

String dat =JOptionPane.showInputDialog(null, "Programa para busqueda de calificaciones"+"\n"+"Indique los datos--1ero.Facultad...2do.Cedula");

return(dat); } // METODOS Despliega /*Despliega los datos de la busqueda, los cuales estan concatenados como variable String, despliega la cédula del estudiante, facultad, carrera, escuela, datos del profesor y de la materia*/ //******************************************************************* public void Despliega(String dato, String facultad) { System.out.println( "\n"+" UNIVERSIDAD DE PANAMA"); System.out.println(" FACULTAD: "+facultad+"\n"); System.out.println(dato+"\n"); }// fin del método }//FIN DE LA CLASE


- 30 -

Evidencias de la EjecuciónEvidencias de la EjecuciónEvidencias de la EjecuciónEvidencias de la Ejecución


- 31 -

Evidencias de la Ejecución---1 Se captura el nombre y código de la facultad

Se captura la cédula del estudiante

Datos Solicitados


- 32 -

Evidencias de la Ejecución---2

Se captura el nombre y código de la facultad

Se captura la cédula del estudiante


- 33 -

Datos Solicitados Evidencias de la Ejecución---3

Se captura el nombre y código de la facultad

Se captura una cédula que no existe

RESULTADO DE LA EJECUCIÓN


- 34 -

Reflexión sobre el Trabajo en Equipo y la Reflexión sobre el Trabajo en Equipo y la Reflexión sobre el Trabajo en Equipo y la Reflexión sobre el Trabajo en Equipo y la MetodologíMetodologíMetodologíMetodología Propuesta.a Propuesta.a Propuesta.a Propuesta.


- 35 -

Reflexión sobre el trabajo en equipo y la metodología utilizada:

Para la elaboración de este proyecto se realizo un trabajo coordinado, siguiendo la orientación

del Procedimiento dada por el facilitador de la materia.

En cuanto al trabajo en equipo podemos resaltar que se realizó con el esfuerzo de los dos

integrantes del grupo; Intentando así cumplir con los objetivos y procedimiento a seguir para

culminar la tarea.

Aunque estuvieron presentes ciertas dificultades para la solución de algoritmos, fueron

superadas y se pudo lograr el producto final, gracias a las consultas realizadas a diferentes

fuentes de información proporcionadas por el profesor en las referencias del proyecto y la

metodología propuesta para su desarrollo.

En cuanto a la metodología utilizada mencionaremos por orden de seguimiento cada

uno de los pasos para la elaboración de la propuesta UML.

1. Se realizó un consenso grupal para determinar el problema a resolver, el dominio de la

aplicación y las clases involucradas.

2. Se procedió a consultar los documentos de Miguel A. Abián y de Andrés Montano Pelleregini

para la estructuración del diagrama de sistema UML, además de la definición del diseño de

clases.

4. Se realizó el diseño del Diagrama UML con el nombre de las clases, atributos y

comportamientos.

5. Revisión de algunos conceptos sobre métodos y clases especiales que nos ayudaran en el

desarrollo de algoritmos.

6. Se realizó una clase que nos permite extraer del archivo de texto original que contiene las

calificaciones del segundo semestre 2006 del CRUV, los datos de la facultad que el usuario

decida consultar.

7. Se confeccionó una clase con los atributos y comportamientos necesarios para la búsqueda

de información dentro del archivo creado.

8. Mediante la creación de una Clase denominada Captura- Despliega, se muestran los

resultados de la aplicación.

8. Se procedió a hacer una descripción de las fuentes de información consultadas.


- 36 -

Evaluación individual de la ExperienciaEvaluación individual de la ExperienciaEvaluación individual de la ExperienciaEvaluación individual de la Experiencia


- 37 -

Evaluación individual de la experiencia Amanda Ortega – ced 9-723-367

1. Conocimientos previos: Antes de la elaboración de este proyecto poseía

conocimientos sobre el manejo de archivos en otro lenguaje de programación (C++),

además tenía conocimientos en cuanto al diseño orientado a objetos, y la

estructuración de un diagrama de sistema UML, así como también la realización de

ciertas aplicaciones orientadas a objetos, realizadas en los laboratorios presenciales de

las clases anteriores.

2. Nuevos conocimientos: Gracias a la realización de este proyecto aprendí a trabajar

con estructuras de datos como lo son los Archivos los cuales me permiten el

almacenamiento de datos en forma masiva.

- Aprendí a trabajar con las Clases FileReader y FileWriter las cuales proporcionan

funcionalidad en el manejo de ficheros de texto, permitiendo tanto operaciones de

lectura como de escritura.

- Trabajé también con la clase BufferedReader, la cual proporciona una técnica que

aumenta la eficacia de entrada y salida.

- Trabaje con las excepcionesIO comprobadas que se producen por algún error en

el entorno en el que se desarrolla el código.

- Pude utilizar nuevos métodos de Java con String los cuales me permitieron lograr

la tarea de una forma más eficiente y con mayor comodidad, etc.

3. Dificultades: La principal dificultad se dio en la clase GetFile, donde teníamos que

extraer los datos de una facultad para luego realizar la búsqueda mediante la cédula… la

dificultad se dio porque generalizamos la búsqueda para trabajar con cualquier

facultad.

4. Proyecciones en su formación profesional: Este proyecto es de gran utilidad en el

perfil profesional que todo estudiante de la Licenciatura en Informática debe proyectar,

el desarrollo de esta herramienta nos permite explotar los conocimientos que dia a día

adquiero en esta facultad… Será imprescindible para la resolución de problemas

cotidianos que se presenten en la empresa donde adquiera un empleo.


- 38 -

Evaluación individual de la experiencia en este Trabajo

(Daniel B. Ballesteros V.)

1. Especificar conocimientos previos:

Los conocimientos previos, necesarios para elaborar este proyecto fueron: La Comprensión

clara de los conceptos y aplicaciones de la programación Orientada a Objetos(Las clases, los

objetos, los métodos, entre otros) documentos como el de Miguel Ángel Abian, Palos y artículos

en el web como el de Andres Montano Pellegrini, todos proporcionados por el profesor Diego

Santimateo fueron de gran utilidad ya que se debía conocer la Clase String, el manejo de

archivos y de entradas / salidas como las excepciones, para poder resolver el problema

propuesto.

2. Nuevos Conocimientos:

Los nuevos conocimientos fueron varios especialmente un afianzamiento en el manejo de los

objetos creados, trabajar con archivos especialmente los de texto y nuevos métodos y como

combinarlos para lograr resultados útiles a la solución de problemas, además del manejo de

excepciones muy útiles para crear programas más eficientes.

3. Dificultades:

Conocer la correcta utilización de los métodos para ser utilizados con la Clase String y probar

los resultados de su implementación fue un poco difícil, porque algunos métodos que mi grupo

creía iban a funcionar no ofrecían los resultados esperados y rápidamente debíamos cambiarlos

por otros. Hasta que encontramos los que se ajustaban a nuestras necesidades en este

problema a resolver.

4. Proyecciones en su formación Profesionales:

Este proyecto en conjunto con todo lo aprendido en la materia de Programación Orientada a

Objetos se proyecta en mi formación profesional para ser utilizada en la resolución de

problemas del área educativa o empresarial en el cual nos vayamos a manejar como

profesionales. Aplicando los conocimientos que la Orientación a Objetos ofrece a la creación de

sistemas informáticos útiles y eficientes, de fácil mantenimiento, bajos costos y llevado a la

aplicación gracias a lenguajes diseñados para la OO como lo es Java.


- 39 -

BIBLIOGRAFÍAS - WEBGRAFIAS

- Documento pdf. Miguel Angel Abian. Análisis OO. http://www.javahispano.org/tutorials.item.action?id=25

- Antonio Bel Puchol. Apuntes del Lenguaje Java [en línea]: 17 de junio de 2001.”Capítulo

10. La Clase Strings”. <http://www.arrakis.es/~abelp/ApuntesJava/Strings.htm> [Consulta:

10 de Septiembre de 2007].

- Sun Microsystems Inc. Java.lang Class[en línea]: 2003. “java.lang – Class String”

<http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html>[Consulta: 15 de Octubre

de 2007]

- Luis Fernando Niño Vásquez. Sistemas Inteligentes [en línea]: Enero 2005,”Operaciones

de Entrada/Salida en Java”, <http://dis.unal.edu.co/~lfnino/softel/cap5/> [Consulta: 12 de

Octubre de 2007]

- Andres Montano Pellegrini. Usando Clases en Java [en línea] :26 de Diciembre de

2006,<http://www.gaugeus.com/ramblings/2006/12/26/usando-clases-en-java-class-usage-

in-java>, [Consulta: 12 de Octubre de 2007]

PROYECTO2-Archivo de Texto

Documents

Transcript of PROYECTO2-Archivo de Texto