REPUBLICA DE PANAMA

CENTRO REGIONAL UNIVERSITARIO DE

VERAGUAS

“LABORATORIO #5 ENCAPSULACIÓN”

PROGRAMACION III

PROFESOR: DIEGO SANTIMATEO

INTEGRANTES:

NORBERTO DELGADO
9-731-110

FERNANDO VILLARREAL
6-711-1562

SEMESTRE: II

AÑO LECTIVO: 2008

 INTRODUCCION

En el siguiente laboratorio trataremos la encapsulación que no es más que la

capacidad de un objeto de poder encerrar sus propiedades y comportamientos
dentro de una especie de cápsula para evitar que otras clases la puedan acceder
o modificar.
La encapsulación permite interactuar con los objetos aún cuando se den
cambios en sus respectivos códigos.
En este trabajo encontrara que la creación de un problema basado en
encapsulación en el encontrara dicho problema, las clases y métodos y que
función hacen en el problema en la descripción del problema encontrara en si
lo que el problema debe hacer y la ejecución del mismo.
Espero que sea de su agrado y que conlleve todo lo que dicho trabajo requería.
 DESCRIPCION DEL PROBLEMA

1- escriba un programa en Java estrictamente orientado a objetos que capture

el nombre, el puesto académico que ocupa y el código de la asignatura de
mayor calificación para cada uno de los N estudiantes de un grupo. El
programa debe determinar el nombre del estudiante con mayor puesto y
desplegar la descripción de la asignatura con mayor calificación. Ni la clase
que representa al estudiante, ni la que representa las asignaturas, ni la clase
que contiene al main deben realizar entradas ni salidas. La clase Asignatura
maneja un archivo que contiene el código y la descripción de cada materia.
Puede crear el archivo con el editor de texto.

Considere los siguientes aspectos:

• Diseñe e implemente una clase que permita capturar datos para

cualquiera que sea la aplicación, de manera que el programa que recurra
a ella sea el único conocedor de lo que se desea capturar.
• Deben existir N objetos Estudiantes creados en la clase principal (la que
contiene al main).
• La salida debe desplegase con un mensaje a un método de la clase que
hace la entrada y salida (I/O). Esto implica que usted debe construir el
mensaje de salida para usarlo en la interfaz del método de la clase I/O.
• Ni la clase principal ni la clase Estudiante pueden hacer I/O
• La clase Estudiante contiene todos los métodos relativos a la actividad
del o con el estudiante.
• Cada método debe atender solo una tarea o función.
• Incluya cada clase en un archivo diferente.

2- Adicione a la clase Estudiante un método para calcular la calificación

promedio de un estudiante. Use la clase I/O sin modificarla para capturar las
M notas de los N estudiantes, sus respectivos nombres y cédulas. Implemente
otra clase Principal para controlar la ejecución. Lea una cédula para saber a
que estudiante se le debe calcular el promedio.
 CODIGO FUENTE

CLASE PRINCIPAL

import java.io.*;
import javax.swing.*;
class Principal
{
public static void main(String args[])throws IOException
{
int n=0,puest=0;
String cadena;
/******************************************************/
Captura_Despliega objeto = new Captura_Despliega();
Estudiante[] arr = new Estudiante[50];
/******************************************************/
n = objeto.Lee_Cantidad();
for(int i=0;i<n;i++)
{
cadena = objeto.Lee_Datos(i);
String[] datos = cadena.split(":");
puest = Integer.parseInt(datos[2]);
arr[i] = new Estudiante(datos[0],datos[1],puest,datos[3],datos[4]);
}
objeto.imprime_datos(arr,n);
}
}

Descripción:

La clase principal es la que nos controla la ejecución inicial programa ya que después esa
tarea nos la ejecuta el método imprime_datos de la clase Captura_Despliega.
Se instancias dos objetos: Uno con la clase Captura_Despliega para poder usar sus métodos
mediante su invocación con el objeto asociado y el otro que es un arreglo de objetos y se
instancia con la clase estudiante el cual nos contiene todos los datos relacionados con los
estudiantes.
Primeramente invocamos al método Lee_Cantidad de la clase Captura_Despliega que nos
lee la cantidad de estudiantes que deseamos evaluar y se lo asignamos a n, luego hacemos
un ciclo y dentro del ciclo invocamos al método Lee_Datos que nos lee todos los datos
relacionados con los estudiantes. En este método los datos son concadenados y separados
por “:” para posteriormente ser separados individualmente y poder realizar las instancias de
cada estudiante.
Al finalizar el ciclo se invoca al método imprime_datos en el cual se imprimen los datos de
los n estudiantes y se sigue con la ejecución del programa. Nótese que el main ya no
interviene más, todo queda cuestionado por la clase Captura_Despliega.
CLASE CAPTURA _ DESPLIEGA

import java.io.*;
import javax.swing.*;
class Captura_Despliega
{
/*************************************************************************
*****/
public int Lee_Cantidad()throws IOException
{
int cantidad;
String cadena;
cadena=JOptionPane.showInputDialog(null,
"Cuantos estudiantes tiene el grupo",
"Entrada",
JOptionPane.QUESTION_MESSAGE);
cantidad = Integer.parseInt(cadena);
return(cantidad);
}
/*************************************************************************
*****/
public String Lee_Datos(int var)throws IOException
{
int i,m;
String cadena1;
String cadena2;
String cadena3;
String cadena4;
String cadena5;
String cadena6;
String cadena7="0";
String cadena8;
cadena1 =JOptionPane.showInputDialog(null,
"Introduzca el nombre del estudiante "+(var+1)+"",
"Entrada",
JOptionPane.QUESTION_MESSAGE);
cadena4=JOptionPane.showInputDialog(null,
"Introduzca la cedula",
"Entrada",
JOptionPane.QUESTION_MESSAGE);
cadena3=JOptionPane.showInputDialog(null,
"Introduzca el puesto academico",
"Entrada",
JOptionPane.QUESTION_MESSAGE);
cadena2=JOptionPane.showInputDialog(null,
"Introduzca el codigo de la asignatura de mayor nota",
"Entrada",
JOptionPane.QUESTION_MESSAGE);
cadena5=JOptionPane.showInputDialog(null,
"Cuantas notas tiene el estudiante",
"Entrada",
JOptionPane.QUESTION_MESSAGE);
m=Integer.parseInt(cadena5);
for(i=0;i<m;i=i+1)
{
cadena6=JOptionPane.showInputDialog(null,
"Introduzca la nota "+(i+1)+"",
"Entrada",
JOptionPane.QUESTION_MESSAGE);
cadena7=cadena7+";"+cadena6+"";
}
cadena7=cadena7+";fin";
cadena8=""+cadena1+":"+cadena2+":"+cadena3+":"+cadena4+":"+cadena7+":";
return(cadena8);
}
/*************************************************************************
*****/
public void imprime_datos(Estudiante arr[],int n)throws IOException
{
float promedio;
String cadena;
JOptionPane.showMessageDialog(null,
"A continuacion se muestran los datos de los estudiantes evaluados",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
for(int i=0;i<n;i++)
{
JOptionPane.showMessageDialog(null,
"El nombre del estudiante "+(i+1)+" es ==> "+arr[i].nombre+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null,
"El codigo de la asignatura de mayor nota es ==> "+arr[i].codigo+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null,
"Su puesto academico es ==> "+arr[i].puesto+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null,
"Su cedula es ==> "+arr[i].cedula+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
}
Estudiante est = Estudiante.Devuelve_Estudiante_mayor(arr,n);
Despliega(est);
cadena = Lee_cedula();
promedio = Estudiante.Calcula_prom(arr,n,cadena);
Despliega_promedio(promedio);
}
/*************************************************************************
*****/
private void Despliega(Estudiante est)throws IOException
{
String cadena;
JOptionPane.showMessageDialog(null,
"A continuacion se muestran los datos del estudiante de mayor puesto academico",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null,
"Nombre del estudiante de mayor puesto academico es ==> "+est.nombre+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null,
"Su puesto academico es ==> "+est.puesto+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null,
"Codigo de la asignatura de mayor calificacion es ==> "+est.codigo+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
JOptionPane.showMessageDialog(null,
"Su cedula es ==> "+est.cedula+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
cadena = Asignatura.Compara(est.codigo);
Despliega_descripcion(cadena);
}
/*************************************************************************
*****/
private void Despliega_descripcion(String des)
{
JOptionPane.showMessageDialog(null,
"Descripcion de la asignatura ==> "+des+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
}
/*************************************************************************
*****/
private String Lee_cedula()
{
String cadena="";
cadena=JOptionPane.showInputDialog(null,
"Introduzca la cedula a evaluar",
"Entrada",
JOptionPane.QUESTION_MESSAGE);
return(cadena);
}
/*************************************************************************
*****/
private void Despliega_promedio(float prom)
{
if(prom > 0)
{
JOptionPane.showMessageDialog(null,
"El promedio del estudiante es ==> "+prom+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
}
else
{
JOptionPane.showMessageDialog(null,
"La cedula no existe en el registro",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
}
Salida();
}
/************************************************************************/
private void Salida()
{
JOptionPane.showMessageDialog(null,
"Ha salido del programa !!!!",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
}
/************************************************************************/
}

Descripción:

Esta clase es la encargada de llevar tanto las entradas como las salidas por pantalla a cabo,
es decir, todas las entradas desde el teclado o las salidas por pantalla las controla esta clase.
Ella cuenta con 8 métodos:
El método Lee_Cantidad (): Este método se encarga de leer la cantidad de estudiantes
que tiene el grupo. Es de tipo int y retorna la cantidad al main.
Consta de dos variables:
Cadena la cual almacena la cantidad de estudiantes como una cadena y cantidad que es la
cadena transformada a entero mediante  Integer.parseInt ().

El método Lee_Datos (): Este método se encarga de leer todos los datos relacionados con
cada estudiante (su nombre, cedula, puesto académico, código de la asignatura de mayor
nota y las notas que el estudiante realizo). Este método recibe un argumento y no es más
que el índice del ciclo for proveniente del main para indicar a que estudiante le estamos
leyendo sus datos. Solo es para relacionarlo o identificarlo.
Consta de 10 variables:
i que nos sirve de índice para controlar el for donde se len las m notas de cada estudiante.
m que guarda la cantidad de notas para cada estudiante.
Cadena1 que almacena el nombre del estudiante.
Cadena2 que almacena el código de la signatura de mayor nota.
Cadena3 que almacena el puesto académico del estudiante.
Cadena4 que almacena la cedula del estudiante.
Cadena5 que almacena la cantidad de notas pero como una cadena, esta cadena se
transforma a entero con Integer.parseInt () y se le asigna a m.
Cadena6 que guarda la nota que se vaya leyendo del estudiante dentro del ciclo for y se
concadena a cadena7 que ya contiene un cero como punto de avance. Nótese que se separan
por “;” para separar las notas de los otros datos como el nombre, cedula, etc. ya que estos
los separa los dos puntos “:”. Al salir del ciclo concadenamos a cadena7 la palabra fin para
saber que ese es el fin de la cadena. Esta cadena7 es muy importante ya que contiene todas
las notas del estudiante separadas por “;” y nos servirá a la hora de obtener el promedio ya
que se pueden separar una a una utilizando el método  split.
Al final todas las cadenas se concadenan unas de otras a cadena8 que es la cadena total, es
decir la cadena que tiene tanto los datos del estudiante separados por “:” como las notas
separadas por “;”.
Este método es de tipo String y retorna cadena8 al main para ser trabajada.

El método imprime _ datos (): Este método se encarga de imprimir los datos de los n
estudiantes sin incluir las notas. Recibe dos argumentos:
El arreglo de objetos que contiene los datos de los estudiantes y n que contiene la cantidad
de estudiantes.
Utilizando la variable i mediante un for podemos recorrer cada posición del arreglo e ir
imprimiendo sus atributos que no son más que los datos de cada estudiante. Luego este
método invoca al método Devuelve_Estudiante_mayor() de la clase Estudiante para
encontrar al estudiante de mayor puesto académico. Se le pasan dos argumentos: El arreglo
de objetos y la cantidad de estudiantes y este método retorna un objeto y se le asigna a est,
luego se invoca al método Despliega que imprime los datos del objeto evaluado
anteriormente ( el estudiante est), luego se invoca al método Lee_cedula() que nos lee la
cedula del estudiante que queremos determinar su promedio y se invoca al método
Calcula_prom() de la clase Estudiante que determina el promedio, Nótese que este método
recibe la cedula como argumento, el arreglo de objetos y la cantidad de estudiantes y
finalmente se invoca al método Despliega_promedio() que imprime dicho promedio.
El método Despliega (): Este método se encarga de imprimir los datos del estudiante de
mayor puesto académico. Recibe por argumento al objeto evaluado en el método
imprime_datos(). Luego se invoca al método Compara de la clase Asignatura pasándole por
argumento el código de la asignatura de mayor puesto de este estudiante para buscar en el
archivo la descripción de la materia perteneciente al código y si la encuentra es retornada a
este método (Despliega) asignándosele a cadena donde se invoca al método
Despliega_descripcion () pasándole esta variable para ser imprimada.

El método Despliega_descripcion (): Que ya fue explicado anteriormente. Este método

imprime la descripción de la materia perteneciente al código de mayor nota asociado al
estudiante de mayor puesto académico. Recibe por argumento la variable que contiene la
descripción.

El método Lee _ cedula (): Este método se encarga de leer la cedula del estudiante al cual
se le desea calcular el promedio. Es de tipo String y devuelve la cedula al método
imprime_datos para ser trabajada.

El método Despliega_promedio (): Este método se encarga de imprimir el promedio

calculado en la clase Estudiante. Lo recibe mediante argumento desde el método
imprime_datos y finalmente invoca al método Salida() que es explicado posteriormente.

El método Salida (): Este método es invocado desde el método Despliega_promedio ()

E imprime un mensaje indicándole al usuario que ya a terminado la ejecución del
programa.
CLASE ESTUDIANTE

import java.io.*;
class Estudiante
{
String nombre;
String codigo;
int puesto;
String cedula;
String notas;
/************************************************************************/
public Estudiante(String nom,String cod,int pues,String ced,String not)
{
this.nombre=nom;
this.codigo=cod;
this.puesto=pues;
this.cedula=ced;
this.notas=not;
}
/************************************************************************/
public static Estudiante Devuelve_Estudiante_mayor(Estudiante arr[],int n)
{
int i,menor=10000,aux=2;
for(i=0;i<n;i=i+1)
{
if(arr[i].puesto < menor)
{
menor=arr[i].puesto;
aux=i;
}
}
return(arr[aux]);
}
/************************************************************************/
public static float Calcula_prom(Estudiante arr[],int n,String cadena)
{
int i,j,sw=0,cn=0;
String cadena1="";
float suma=0,prom=0;
for(i=0;i<n;i=i+1)
{
if(arr[i].cedula.equals(cadena))
{
cadena1=arr[i].notas;
String[] datos=cadena1.split(";");
j=0;
while(sw==0)
{
if(datos[j].equals("fin"))
sw=1;
if(sw==0)
{
suma=suma+Integer.parseInt(datos[j]);
cn=cn+1;
}
j=j+1;
}
prom=suma/(cn-1);
}
}
return(prom);
}
/**********************************************************************/
}

Descripción:

Esta clase contiene los atributos en los cuales se guardan los datos de los estudiantes a la
hora de realizar las instancias además contiene dos métodos:

El método Devuelve_Estudiante_mayor (): Este método calcula y devuelve al método

imprime_datos el objeto estudiante de mayor puesto académico. Recibe el arreglo de
objetos y la cantidad de estudiantes (n) por argumento. Lo que hace es recorrer todo el
arreglo e ir comparando cada puesto académico del estudiante con una variable inicializada
con un valor grande. Si es menor que esta variable se guarda su posición y a la variable de
valor grande se le asigna el puesto académico para seguir buscando el mayor. Al final del
ciclo se retorna todo el objeto estudiante perteneciente a la posición guardada al método
imprime_datos para ser trabajado.

El método Calcula_prom (): Este método se encarga de calcular el promedio del

estudiante que se leyó su cedula, para ello recibe por argumento el arreglo de objetos, la
cantidad n y la cedula a buscar. Lo que hace es comparar cada cedula de los estudiantes con
la cedula que se recibe por argumento, si son iguales se le asigna a una cadena el atributo
notas que contiene las cadenas de notas separadas por “;” y se separan mediante  split.
Luego se hace un ciclo while para recorrer todas las notas de la cadena e ir sumando y
contando. Nótese que antes de sumar se compara la nota con la palabra fin para ver si ya
hemos llegado al final de la cadena y así poder salir del ciclo. Si esto ocurre, a prom le
asignamos la suma entre el contador y este es el promedio del estudiante que es retornado al
método imprime_datos para ser trabajado. Nótese que este método es de tipo float ya que
calcula el promedio.
El contador es reducido en 1 ya que contamos el numero 0 que marca el inicio de la cadena
de notas a la hora de sacar el promedio.
CLASE ASIGNATURA

import java.io.*;
import java.lang.*;
class Asignatura
{
/************************************************************************/
public static String Compara(String cod)throws IOException
{
String cadena="No existe";
String cadena1="";
String cadena2="";
String cadena3="";
boolean b;
FileReader arch1 = new FileReader("datos.txt");
BufferedReader in = new BufferedReader(arch1);
String s =new String();
cadena2=""+cod+"";
while((s=in.readLine())!= null)
{
cadena1=s;
String[] datos = cadena1.split(";");
cadena3=datos[0];
b=cadena2.equals(cadena3);
if(b)
cadena=datos[1];
}
in.close();
return(cadena);
}
/************************************************************************/
}

Descripción:

Esta clase es la que permite buscar en el archivo el código de la asignatura de mayor nota
relacionado al estudiante de mayor puesto académico.
Recibe por argumento el código de la asignatura y se compara con cada código de la lectura
por línea que realiza esta clase del archivo.
Al leer una línea se le asigna a una cadena, esta cadena se descompone en dos cadenas
mediante split ya que las dos cadenas están separadas por “;”..
Una con el código y la otra con la descripción. Comparamos el código recibido con el
código separado, si son iguales en otra cadena se guarda la descripción. Al final se retorna
esta cadena al método Despliega para ser trabajada. Nótese que la cadena que guarda la
descripción se inicializó con la cadena “No existe”, para indicar que si el código no se
encuentra imprima que no existe.
EJECUCIÓN DEL PROGRAMA

En esta ventana leemos la cantidad Leemos el nombre del estudiante 1.

De estudiantes que tiene el grupo.

Leemos su cedula. Leemos su puesto académico.

Leemos el código de la asignatura Leemos la cantidad de notas

de mayor nota. que presentó.
Leemos la nota numero 1. Leemos la nota numero 2.

Leemos la nota numero 3. Leemos el nombre del

Estudiante numero2.

Leemos su cedula. Leemos su puesto académico.

Leemos el código de la asignatura Leemos la cantidad de
de mayor nota. Notas que presento.

Leemos la nota 1. Leemos la nota 2.

Leemos la nota 3. Leemos la nota 4.

Leemos el nombre del estudiante 3. Leemos su cedula.

Leemos su puesto académico. Leemos el código de la

Asignatura de mayor nota

Leemos la cantidad de notas Leemos la nota 1.

Que presento el estudiante.
Leemos la nota 2. Este mensaje índice que vamos
A imprimir los datos de los
Estudiantes.
Con este mensaje le indicamos al usuario que se van a imprimir los datos
del estudiante de mayor puesto académico.
 Aquí pedimos la cedula para
Encontrar el promedio de un
Estudiante.

Aquí vemos el promedio del Aquí salimos del programa.

Estudiante evaluado.
Este es el archivo que guarda el código y las descripciones de las materias.
 COMENTARIO

Fernando:

En lo que respecta a este laboratorio, fue mucho más fácil que el primero ya que trabajar
con un arreglo de objetos es bastante práctico y muy fácil, buscar el código en el archivo e
imprimir la materia se tornaba algo difícil pero al final no fue mayor cosa.
El encapsulamiento no fue mayor problema ya que solo había que declarar los métodos
privados y que la clase que los tenía las llamara sin necesidad de que el main u otra clase
intervinieran.

Norberto:

Este trabajo fue un poco mas sencillo que el del laboratorio numero 1 ya que la
encapsulación fue mas entendible para mi y por consiguiente la creación del mismo
problema en si no tubo mayor inconveniente aunque l problema fue la entrega del mismo
ya que se nos presentaron distintos imprevistos y no nos permitió entregarlo en el momento
que se pidió.
 Conclusión
Este trabajo se baso en la encapsulación de variables de instancia en problemas de archivos
los cuales son en general la creación de una variable que no pueda ser utilizada por otros
métodos de otras clases este problema requería el empleo de archivos y la manipulación de
dicho archivo.
Este trabajo fue creado con la función de mejorar y afianzar el conocimiento de nosotros
los programadores de java y por consiguiente todo lo que conlleva la manipulación de java.
Espero que este trabajo haya sido de su agrado ya que a nosotros nos permitió el manejo de
variables privadas y publicas y así tener mas conocimiento de java y así tener mas
entendimiento de java y de todos sus maneras de implementación.