UNIVERSIDAD DE PANAM

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

FACULTAD DE INFORMTICA, ELECTRNICA Y
COMUNICACIN
LICENCIATURA EN INFORMTICA PARA LA GESTIN
EDUCATIVA Y EMPRESARIAL

PROGRAMACIN IV
INF-212

LABORATORIO # 5

ENCAPSULACION

PROFESOR
DIEGO SANTIMATEO

INTEGRANTES
JAIRO CONCEPCIN 9-724-1589
DIOMEDES MONTES 9-723-640

FECHA

24 DE OCTUBRE DE 2008

2
INDICE

3
Contenidos Pg.

Introduccin..................................................................................................... 3
Objetivos......................................................................................................... 4
Descripcin del Problema............................................................................... 5
Diagrama UML de Clases.............................................................................. 6
Explicacin del Diagrama UML de Clases ..................................................... 7
Descripcin de las Clases, Mtodos y Variables............................................ 8
Class Principal........................................................... ........................... 8
Cdigo Fuente................................................................................ 9
Class Asignatura................................................................................... 10
Cdigo Fuente................................................................................ 11,12
Class Estudiante................................................................................... 13,14
Cdigo Fuente................................................................................ 15-17
Class CapturaDespliega....................................................................... 18
Cdigo Fuente................................................................................ 19,20
Class Principal2..................................................................................... 21
Cdigo Fuente................................................................................ 22,23
Ejecucin de la Aplicacin, Modo Grfico para I/O......................................... 24-26
Reflexiones individuales del laboratorio.......................................................... 27
Conclusiones.................................................................................................. 28

INTRODUCCIN

4
 La Encapsulacin es el trmino de orientacin a objetos con el que podemos
describir la forma de vincular las operaciones y estados a un objeto particular.
La encapsulacin est ntimamente relacionada con la ocultacin de la
informacin, definiendo qu partes de un objeto son visibles y qu partes estn
ocultas.

La encapsulacin abarca a la ocultacin de la informacin:

Algunas partes son visibles (el interfaz pblico)
Otras partes son ocultas (o privadas)

En el presente laboratorio de Encapsulacin presentamos un programa en Java

orientado a objetos.
Este programa del laboratorio consta de las clases; Asignatura, Estudiante,
CapturaDespliega, Principal y Principal2, estas ltimas se encargaran de la ejecucin
del programa en un momento dado.
En primera instancia el programa captura el nombre, el puesto acadmico que
ocupa y el cdigo de la asignatura de mayor calificacin para cada uno de los N
estudiantes de un grupo,
Posteriormente adicionamos a la clase Estudiante un mtodo para calcular la
calificacin promedio de un estudiante.
Utilizamos la clase que realiza las I/O sin modificarla para capturar las M notas
de los N estudiantes, sus respectivos nombres y cdulas.
Determinamos el promedio de un estudiante a partir de sus cedula.

OBJETIVOS

5
Objetivo General

Escribir un programa que determinar el nombre del estudiante con mayor

puesto y desplegar la descripcin de la asignatura con mayor
calificacin.

Implementar otra clase Principal para controlar la ejecucin del

programa, para leer una cdula para saber a que estudiante se le debe
calcular el promedio.

Objetivos Especficos

Disear e implementar una clase que permita capturar datos para

cualquiera que sea la aplicacin.

Crear N objetos Estudiantes en la clase principal

Desplegar las salidas a travs de mensajes a un mtodo de la clase que

hace la entrada y salida (I/O).

Excluir a la clase Principal y clase Estudiante de hacer I/O

Cada mtodo debe atender solo una tarea o funcin.

Incluir cada clase en un archivo diferente.

Adicionar a la clase Estudiante un mtodo para calcular la calificacin

promedio de un estudiante.

Utilizar la clase que realiza I/O sin modificarla para capturar las M notas
de los N estudiantes, sus respectivos nombres y cdulas.

DESCRIPCIN DEL PROBLEMA

6
 I. Escriba un programa en Java estrictamente orientado a objetos que capture el
nombre, el puesto acadmico que ocupa y el cdigo de la asignatura de mayor
calificacin para cada uno de los N estudiantes de un grupo. El programa debe
determinar el nombre del estudiante con mayor puesto y desplegar la descripcin de la
asignatura con mayor calificacin.

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 cdigo y la descripcin de cada materia. Puede
crear el archivo con el editor de texto.

Considere los siguientes aspectos:

Disee e implemente una clase que permita capturar datos para
cualquiera que sea la aplicacin, 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 mtodo 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 mtodo de la clase I/O.
Ni la clase principal ni la clase Estudiante pueden hacer I/O
La clase Estudiante contiene todos los mtodos relativos a la actividad
del o con el estudiante.
Cada mtodo debe atender solo una tarea o funcin.
Incluya cada clase en un archivo diferente.

II. Adicione a la clase Estudiante un mtodo para calcular la calificacin

promedio de un estudiante. Use la clase I/O sin modificarla para capturar las M
notas de los N estudiantes, sus respectivos nombres y cdulas. Implemente otra clase
Principal para controlar la ejecucin. Lea una cdula para saber a que estudiante se le
debe calcular el promedio.

7
 DIAGRAMA UML DE LAS CLASES
Class Principal2
Class Principal
Int k, I, j, ca, r;
Int can, I, Puesto; String Cad, cedula;
String Cad, AsigDevuelta; String[] Datos;
String[] Datos; String AsigDevuelta;
Estudiante datosmay; Float pro;
Estudiante [ ] ArregloEst; Int[] notas;
Estudiante [] ArregloEst;
Objetos -Clases
DatosEst CapturaDespliega() Objetos-Clases
Asignatura Asignatura() Capt CapturaDespliega()
EstudianteMay Estudiante() EstudianteDat Estudiante()
Aux Estudiante()
Main() Main()

Class Asignatura Class Estudiante

Class CapturaDespliega
String Nombre; String CadDatos;
String Cedula;
String NombAsig; String codigo;
BufferedReader in; int puesto;
int notas[];
float promedio ;
String Asignatura;
String Cadena()
Void DespligaDat ( String dat) int
CantEstudiante()
Estudiante Getmayor (Estudiante void CapturaDat()
ArregloEst[])
String DatosEstu1()
BufferedReader AbreArch() String DatosEstu()
Float CalPromedio (Estudiante aux)
void OpenArch(String Estudiante BuscaCedula (Estudiante
Datos[] ) ArregloEst[], String ced)

8
EXPLICACIN DEL DIAGRAMA DE CLASES UML

En el diagrama que presentamos anteriormente vemos representadas dos (2)

clases principales; Principal y Principal2 las cuales son las encargadas de controlar la
ejecucin del programa.

En primera instancia ejecutamos la clase Principal, la cual se encarga de

realizar el llamado a los mtodos de las clases; Asignatura, Estudiante y
CapturaDespliega. Cada mtodo de las clases anteriormente mencionadas cumplen
con una funcin especfica;
La clase Asignatura, consta de dos (2) mtodos; el primero es privado
AbreArch() crea el flujo para leer el archivo de texto que contiene los datos de la
materia (cdigo y nombre) y el segundo OpenArch() toma el objeto que devuelve
AbreArch() para abrir y leer el archivo
La clase Estudiante consta de 5 mtodos que realizan todas las funciones
relacionadas con el estudiante, el mtodo Getmayor () busca el estudiante de mayor
puesto, DatosEstu1() se encarga de manejar los datos personales del estudiante
como lo son: Nombre, Cedula, Cdigo, Puesto, y Asignatura, los toma de la clase que
los captura y los devuelve en una sola cadena. El mtodo DatosEstu() realiza la
misma funcin solamente que con los datos de Nombre y Cedula.
La clase CapturaDespliega() es la encargada de realizar todas las entradas y
salidas del programa, cuenta con cuatro mtodos para tales fines. El mtodo
Cadena() es el que concatena en una cadena los datos de; Nombre, cedula, Cdigo
de mayor asignatura, capturados por el mtodo de esta misma clase; CapturaDat().
DespligaDat () se encarga de mostrar en pantalla toda la informacin del estudiante.
CapturaCedula() captura la cedula del estudiante a buscar, CantEstudiante()
captura la cantidad de estudiantes a procesar.

La segunda clase Principal, Principal2, realiza el mismo trabajo, con la

diferencia que esta clase ejecuta en la clase Estudiante un mtodo que permite
calcular el promerio de un estudiante dado un numero de cedula.

9
 DESCRIPCION DE LAS CLASES, METODOS Y VARIABLES

A continuacin presentamos una descripcin detallada de la utilidad de cada

una de las clases, y de los mtodos y variables que contiene cada una de estas.

Class Principal

Esta es la Clase Principal para la primera parte del laboratorio, su utilidad es

controlar el funcionamiento del programa a travs del acceso a cada uno los mtodos
de las clases; Asignatura, Estudiante y CapturaDespliega. En concordancia con el
enunciado propuesto, esta clase no realiza entradas ni salidas.

Class Principal
Variables de la Clase Descripcin - Funcionamiento
Nombre Tipo
can int Almacena la cantidad de estudiantes de un grupo
i int Contador del ciclo for
Cad String Cadena que contiene los datos del estudiante
Almacena el puesto del estudiante, para luego
Puesto int
pasarlo al vector de tipo Estudiante.
Almacena el nombre de las asignaturas, para
AsigDevuelta String
luego guardarla en el vector de tipo estudiante.
Datos String[] Vector que contiene los datos de los estudiantes
Almacena los datos del estudiante de mayor
datosmay Estudiante
puesto.

Objetos
Nombre Clases
Objeto para acceder a los mtodos de la clase
DatosEst CapturaDespliega()
CapturaDespliega(
Vector de objetos para manejar los datos del
ArregloEst Estudiante [ ]
estudiante.
Objeto para acceder a los mtodos de la clase
Asignatura Asignatura()
Asignatura()
Objeto para acceder a los mtodos de la clase
EstudianteMay Estudiante()
Estudiante()

Mtodos Descripcin - Funcionamiento

Se encarga de la ejecucin del programa, llama a
Main() void
los mtodos de las dems clases.

10
Cdigo fuente de Class Principal:

import java.io.*;
import java.lang.String;
class Principal{

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

CapturaDespliega DatosEst= new CapturaDespliega();

int can = DatosEst.CantEstudiante();

Estudiante [] ArregloEst= new Estudiante[can];
Asignatura Asignatura = new Asignatura();

int i;
String Cad;

for (i=0;i<can ;i++)

{
DatosEst.CapturaDat();
Cad = DatosEst.Cadena();
String[] Datos = Cad.split(",");
int Puesto = Integer.parseInt(Datos[3]);
String AsigDevuelta = Asignatura.OpenArch(Datos);

ArregloEst[i] = new Estudiante (Datos[0],Datos[1],Datos[2],Puesto,AsigDevuelta);

Estudiante EstudianteMay=new Estudiante();

Estudiante datosmay = EstudianteMay.Getmayor(ArregloEst);
DatosEst.DespliegaDat(datosmay.DatosEstu1())

11
Class Asignatura
La clase Asignatura esta conformada por dos mtodos, uno privado y otro
pblico. Realiza la funcin de; a travs del mtodo privado crear el flujo que abre el
archivo de texto de donde se encuentran el cdigo y nombre de la asignatura, para
posteriormente recorrer el archivo y extraer el nombre de las asignaturas y devolverlas
al programa principal, para que sean utilizadas por otras clases.

ClassAsignatura
Variables de la Clase Descripcin - Funcionamiento
Nombre Tipo
Variable que obtiene y devuelve el nombre de la
NomAsig; String
asignatura que se encuentra en el archive de texto.
Variable que retorna el objeto cuando se abre el
in; BufferedReader archive. Se utiliza en el mtodo privado de esta
clase.

Mtodos Descripcin - Funcionamiento

Mtodo privado que crea el flujo y abre el archivo
de texto que contiene el cdigo y nombre de la
AbreArch() BufferedReader
asignatura, devuelve el objeto para utilizar el
archivo en el siguiente mtodo.
Variables locales
No tiene

Realiza el llamado al mtodo privado que crea el

flujo para abrir el archivo, lee lnea por lnea, para
OpenArch( localizar el nombre de la asignatura, cuando la
String String encuentra la almacena en la variable NomAsig
Datos[]) luego devuelve esta variable (cadena) con el
nombre de todas las materias que hay ene el
archivo.

Variables locales
Variable tipo objeto para almacenar cada linea del
s String
archivo.

12
Cdigo fuente de Class Asignatura:

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

class Asignatura{

private String NomAsig;

private BufferedReader in;

public Asignatura(){//constructor
}

/*********************************************************************************************/
/* Metodo AbreArch abre el archivo */
/*********************************************************************************************/

private BufferedReader AbreArch()throws IOException

{
File fl=new File("Estudiante.txt");
if( fl.isFile()){
FileReader arch1 = new FileReader(fl);
in = new BufferedReader(arch1);
}
return(in);
}

/*********************************************************************************************/
/* Metodo OpenArch abre el archivo para buscar en codigo y el nombre de la material */
/*********************************************************************************************/

public String OpenArch(String Datos[]){

13
 try {

BufferedReader lee=AbreArch();
int j=0;
String linea;
String s = new String();

while((s = in.readLine())!= null){

if(s.startsWith(Datos[2])){
String[] Dat = s.split(" ");
this.NomAsig=Dat[1];
}
}

in.close();

}
catch (Exception e)
{
System.err.println("***Error al leer o abrir el archivo...\n" +e);
}

return(this.NomAsig);

}//fin de la clase Asignatura

14
Class Estudiante
La clase Estudiante esta conformada por cinco mtodos que realizan las
funciones relacionadas con las actividades del estudiante como lo son; obtener sus
datos; nombre, cedula, puesto, cdigo y nombre de asignatura. Para luego procesar
esta informacin y determinar el estudiante de mayor puesto, as como tambin
realizar la bsqueda a travs de la cdula y calcular el promedio de sus respectivas
notas.

ClassEstudiante
Variables de la Clase Descripcin - Funcionamiento
Nombre Tipo
Nombre String Almacena el nombre del estudiante
Cedula String Almacena la cedula a buscar del estudiante
codigo String Almacena el cdigo de la materia
Puesto int Guarda el puesto del estudiante
Notas[ ] int Vector para almacenar las notas de los estudiantes
promedio float Almacena el promedio de notas del estudiante.
asignatura String Almacena el nombre del estudiante.

MTODOS Descripcin - Funcionamiento

Getmayor Estudiante(Estu Realiza la funcin de buscar el estudiante de mayor
(Estudiante diante puesto y devolver todo sus datos, para esto utiliza
ArregloEst[]) ArregloEst[]) la variable aux de tipo Estudiante
Variables locales
0btiene y devuelve todos los datos del estudiante
aux Estudiante
de mayor puesto.
i int Contador del ciclo for

Este mtodo tiene como propsito obtener los

DatosEstu1() String datos de; nombre, cedula, cdigo, puesto y
asignatura, pasados a travs del constructor
Variables locales
Concatena para devolver una sola cadena con los
dat1 String datos de: nombre, cedula, cdigo, puesto y
asignatura.

Este mtodo tiene como propsito obtener los

DatosEstu() String
datos de; nombre, cedula del estudiante
Variables locales
Concatena para devolver una sola cadena con los
dat1 String
datos de: nombre y cedula.

15
 Este mtodo tiene como objetivo calcular y devolver
CalPromedio el promedio de las notas del estudiante. Toma el
(Estudiante Float arreglo de objetos de tipo estudiante, a partir de
aux) este arreglo toma sus respectivas notas para
calcular el promedio.
Variables locales
Contador del ciclo for y de la cantidad de notas del
j int
estudiante.
suma int Acumula la sumatoria de las notas

BuscaCedul Busca la cedula del estudiante, si la encuentra

a(Estudiante devuelve un arreglo de objetos tipo estudiante, con
Estudiante
ArregloEst[], sus respectivos datos, emite un mensaje con la
String ced) informacin para saber si encontr la cedula.
Variables locales
Variable bandera para controlar el mensaje cuando
Sw Int
no se encuentra la cedula.
i int Contador del ciclo for

Objetos
Objeto del tipo estudiante, para almacenar todos
aux Estudiante
sus datos

16
Cdigo fuente de Class Estudiante:
import javax.swing.*;
import java.io.*;

class Estudiante{
private String nombre;
private String cedula;
private String codigo;
private int puesto;
private int notas[];
private float promedio;
private String asignatura;

public Estudiante(){
}

public Estudiante(String nom, String ced, String cod, int pues, String asinatura1){
this.nombre=nom;
this.cedula=ced;
this.puesto=pues;
this.codigo=cod;
this.asignatura=asinatura1;
}//fin del constructor

public Estudiante(String nom,String ced, int not[]){

this.nombre=nom;
this.cedula=ced;
this.notas=not;

}//fin del constructor

/*********************************************************************************************/
/* Metodo Getmayor obtiene los datos del estudiante de mayor puesto */
/*********************************************************************************************/

17
 public Estudiante Getmayor(Estudiante ArregloEst[]){
Estudiante aux;
aux=ArregloEst[0];
for (int i=0;i < ArregloEst.length;i++)
if (ArregloEst[i].puesto < aux.puesto){
aux=ArregloEst[i];
}
return(aux);

}//fin del metodo Getmayor

/*********************************************************************************************/
/* Metodo DatosEstu1 obtiene los datos nombre,cedula,codigo,puesto y asignatura */
/*********************************************************************************************/

public String DatosEstu1(){

String dat1=("Nombre: "+this.nombre+"\nCedula: "+this.cedula+"\n Codigo: "+this.codigo+"\n Puesto:
"+this.puesto+"\nAsignatuta: "+this.asignatura);
return (dat1);
}

/*********************************************************************************************/
/* Metodo DatosEstu obtiene los datos nombre,cedula y promedio */
/*********************************************************************************************/

public String DatosEstu(){

String dat1=("Nombre: "+this.nombre+"\nCedula: "+this.cedula+"\n ");
return (dat1);
}
/*********************************************************************************************/
/* Metodo GetPromedio obtiene el promedio del estudiante */
/*********************************************************************************************/
public float CalPromedio(Estudiante aux){
int j;
int suma=0;

18
 for(j=0;j<aux.notas.length;j++){

suma=suma+aux.notas[j];

}
this.promedio= suma/j;

return(promedio);

}//fin del metodo GetPromedio

/*********************************************************************************************/
/* Metodo BuscaCedula busca la cedula del estudiante */
/*********************************************************************************************/

public Estudiante BuscaCedula(Estudiante ArregloEst[],String ced){

Estudiante aux=new Estudiante();
int sw=0;

for (int i=0;i < ArregloEst.length;i++)

if(ArregloEst[i].cedula.equals(ced))
{
JOptionPane.showMessageDialog(null,"Cedula
encontrada","Informacin del estudiante",JOptionPane.INFORMATION_MESSAGE);
aux = ArregloEst[i];
sw=1;
}
if(sw==0){
JOptionPane.showMessageDialog(null,"La Cedula nos se ha encontrada","Informacin del
estudiante",JOptionPane.INFORMATION_MESSAGE);
}
return(aux);

19
Class CapturaDespliega
La clase CapturaDespliega es la encargada de realizar las entradas y salidas
del programa, la misma cuenta con cinco mtodos para; capturar la cantidad de
estudiantes a gestionar, sus nombres, puestos, cedula, No. De cedula a buscar e
imprime los datos de esl estudiante de mayor puesto con los detalles de la materia, al
igual que el promedio de un estudiante a partir de la cedula introducida.

Class CapturaDespliega
Variables de la Clase Descripcin - Funcionamiento
Nombre Tipo
Variable para almacenar la cadena que contiene el
CadDatos String
mensaje de nombre, cedula y cdigo de asignatura.

MTODOS Descripcin - Funcionamiento

Este mtodo obtiene e imprime la cadena con el
Cadena() String
mensaje de nombre, cedula y cdigo de asignatura.
Variables locales
Inicializa la variable cadena con el mensaje de
Cadena String
nombre, cedula y cdigo de asignatura.

DespligaDat Este mtodo imprime los datos de estudiante como

void
( String dat) nombre, cedula, puesto, cdigo y asignatura.
Variables locales

CapturaCed Este Mtodo captura y retorna la cedula del

String
ula() estudiante que se desea buscar .
Variables locales
cedula String Almacena la cedula a buscar

CantEstudia Este mtodo captura y devuelve la cantidad de

int
nte() estudiante que se van a gestionar
Variables locales
Almacena la cantidad a estudiantes que se van a
CantEst int
gestionar.

Este mtodo captura los datos del estudiante como

CapturaDat() void lo son; Nombre, cedula, Cdigo de mayor
asignatura.
Variables locales
No tiene

20
Cdigo fuente de Class CapturaDespliega:
import java.io.*;
import javax.swing.*;
class CapturaDespliega{

private String CadDatos;

public CapturaDespliega(){

/****************************************************************************************************/
/*Metodo Cadena imprime los datos de estudiante como nombre,cedula,puesto,codigo y asignatura */
/****************************************************************************************************/

public String Cadena()

{
String cadena = CadDatos;
return(cadena);
}//fin del metodo Cadena

/****************************************************************************************************/
/*Metodo DespliegaDat imprime los datos de estudiante como nombre,cedula,puesto,codigo y asignatura */
/****************************************************************************************************/

public void DespliegaDat( String dat,float prom)

{
JOptionPane.showMessageDialog (null,dat+"Informacin del estudiante "+" promedio" +
promJOptionPane.INFORMATION_MESSAGE);

}//fin de metodo DespliegaDat

/*********************************************************************************************/

21
 /* Metodo CapCedula pregunta por la cedula del estudiante que se desea buscar */
/*********************************************************************************************/

public String CapturaCedula()

{
String cedula;
cedula = JOptionPane.showInputDialog(null, "Introduzca la cedula de el estudiante a buscar");
return(cedula);
}//fin del metodo CapCedula

/*********************************************************************************************/
/* Metodo CantEstudiante captura la cantidad de estudiane que se van a gestionar */
/*********************************************************************************************/

public int CantEstudiante()

{
this.CadDatos=JOptionPane.showInputDialog(null, "Numero de estudiantes");
int CantEst=Integer.parseInt(CadDatos);
return(CantEst);

}
/****************************************************************************************************/
/* Metodo CapturaDat preguna por los datos del estudiante */
/****************************************************************************************************/

public void CapturaDat()

{

this.CadDatos=JOptionPane.showInputDialog(null, "Nombre,cedula,Codigo de mayor asignatura,\n");

22
Class Principal2; (II parte)

Para esta segunda parte del laboratorio Implementamos otra clase Principal
llamada Principal2 para controlar la ejecucin del programa.
Adicionamos a la clase Estudiante un mtodo para calcular la calificacin
promedio de un estudiante, a travs de la lectura de una cedula. Usamos la clase I/O
sin modificarla para capturar las M notas de los N estudiantes, sus respectivos
nombres y cdulas

Class Principal2
Variables de la Clase Descripcin - Funcionamiento
Nombre Tipo
k int Almacena la cantidad de estudiantes de un grupo
I, j int Contadores de ciclos for
ca int Almacena la cantidad de notas de un estudiante
Cad String Cadena que contiene los datos del estudiante
Datos String[] Vector que contiene los datos de los estudiantes
Contador para almacenar las notas en el vector
r int
notas[]
Almacena la cdula a buscar devuelta por el
cedula String
mtodo CapturaCdula()
prom float Almacena el promedio devuelto
Arreglo de objetos de la clase Estudiante, para
ArregloEst Estudiante [ ]
almacenar todos los datos del estudiante.
notas Int[ ] Arreglo de objetos para almacenar las notas
Objetos
Nombre Clases
Objeto para acceder a la clase
Capt CapturaDespliega()
CapturaDespliega()
EstudianteDat Estudiante() Objeto para acceder a los datos del estudiante
Objeto auxiliar para acceder a los datos del
aux Estudiante()
estudiante

Mtodos Descripcin - Funcionamiento

Se encarga de la ejecucin del programa, llama a
Main() void
los mtodos de las dems clases.

23
Cdigo fuente de Class Principal2:
import java.io.*;
import java.lang.String;
class Principal2{

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

CapturaDespliega Capt= new CapturaDespliega();

int k = Capt.CantEstudiante();
Estudiante [] ArregloEst= new Estudiante[k];
int i,j;
int ca=0;

String Cad;
int r=0;

for (i=0;i<k ;i++)

{
int posiciona[];
Capt.CapturaDat();
Cad = Capt.Cadena();
String[] Datos = Cad.split(",");

ca=Datos.length-2;
int [] notas=new int[ca];
for (j=2;j<Datos.length;j++)
{
notas[r] = Integer.parseInt(Datos[j]);
r++;

24
 }

ArregloEst[i] = new Estudiante (Datos[0],Datos[1],notas);

}

Estudiante EstudianteDat=new Estudiante();

Estudiante aux=new Estudiante();
String cedula=Capt.CapturaCedula();
aux = EstudianteDat.BuscaCedula(ArregloEst,cedula);
float prom = EstudianteDat.CalPromedio(aux);
Capt.DespliegaDat(aux.DatosEstu(),prom);

}//fin del main

25
 EJECUCIN DE LA APLICACIN, MODO GRFICO PARA I/O

A continuacin describimos cada una de las evidencias de la ejecucin de la

aplicacin.

En esta pantalla realizamos la captura de la cantidad de estudiantes a procesar:

En este paso se procede a capturar los datos del Estudiante: Nombre, Cdula, Cdigo
de Asignatura, y el puesto que ocupa. Los datos se ingresan de manera continua
separando a cada uno con una coma (,)

Procedemos a capturar los datos del primer estudiante:

Se captura los datos del segundo estudiante:

Salida, se muestran los datos del estudiante

de mayor puesto con sus datos; Nombre,
Cdula, Cdigo de Asig, Puesto, y el nombre
de la Asignatura, que se extrae del archivo de
texto.
main2

26
 Las siguientes pantallas corresponden a la segunda parte del laboratorio, en el
cual implementamos a la clase estudiante el mtodo que calcula el promedio de un
estudiante dado una cdula, Utilizamos la clase anterior CapturaDespliega sin
realizarle modificaciones. Creamos otra clase principal (Principal2) para que se
encargara de controlar la ejecucin del programa.

En esta pantalla realizamos la captura de la cantidad de estudiantes a procesar:

En este paso se procede a capturar los datos del Estudiante: Nombre y Cdula,
Adems de sus respectivas notas. Los datos se ingresan de manera continua
separando a cada uno con una coma (,).

Procedemos a capturar los datos del primer estudiante: Nombre, cdula, notas.

Procedemos a capturar los datos del segundo estudiante: Nombre, cdula, notas.

En este paso se solicita la cedula del estudiante al que se desea calcular el promedio.

27
Si la cedula del estudiante existe, se mostrara el siguiente mensaje

Seguidamente se muestran los datos del estudiante; Nombre, Cedula y el promedio de

las notas.

28
 REFLEXIONES INDIVIDUALES DEL LABORATORIO

Diomedes Montes 9-723-640

En la realizacin de este laboratorio he adquirido conocimientos significativos

sobre la Encapsulacion, donde he visto reflejado la ventaja de la OO al permitir a los
objetos tener la capacidad de ser un contenedor (o cpsula) de sus propiedades y
comportamiento. Logrando asi tener una serie de datos propios del objeto en una sola
variable por asi decirlo.
Asi de esta manera con la encapsulacion podemos disear los mtodos de
manera que nos permita interactuar con los objetos an cuando se den cambios en
sus respectivos cdigos.

Concepcin Jairo 9-724-1589

Los conocimientos que adquir en este laboratorio fue el manejo de encapsulacin en

los mtodos y variables de instancias de cada clase. Aprend tambin a estructurar de
una mejor manera una clase que fuera utilizada por dos main() sin modificar nada la
clase creada.
Entre las dificultades que encontr estn: el manejo de los mensajes para los
dos main, adems uno de los aspectos que no logramos hacer es que el programa
trabajar de una manera eficiente los puntos que usted solicito.

29
 CONCLUSIONES

Luego de elaborar el presente laboratorio de encapsulacin podemos concluir que;

La encapsulacin es el trmino de orientacin a objetos con el que podemos

describir la forma de vincular las operaciones y estados a un objeto particular.

Est ntimamente relacionada con la ocultacin de la informacin, definiendo

qu partes de un objeto son visibles y qu partes estn ocultas, es una propiedad que

permite Ocultar la informacin al resto de los objetos

La encapsulacin abarca a la ocultacin de la informacin:

Algunas partes son visibles (el interfaz pblico)

Otras partes son ocultas (o privadas).

Este laboratorio ha sido de mucho provecho para nosotros ya que a travs del

mismo hemos logrado adquirir conocimientos nuevos que encierran a la programacin

Orientada a Objetos que nos servirn para desempearnos en nuestro futuro como

profesionales.

30