You are on page 1of 29

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

LABORATORIO # 5

ENCAPSULACION

PROFESOR
DIEGO SANTIMATEO

INTEGRANTES
JAIRO CONCEPCIÓN 9-724-1589
DIOMEDES MONTES 9-723-640

FECHA

24 DE OCTUBRE DE 2008

2
INDICE

3
Contenidos Pág.

Introducción..................................................................................................... 3
Objetivos......................................................................................................... 4
Descripción del Problema............................................................................... 5
Diagrama UML de Clases.............................................................................. 6
Explicación del Diagrama UML de Clases ..................................................... 7
Descripción de las Clases, Métodos y Variables............................................ 8
Class Principal........................................................... ........................... 8
Código Fuente................................................................................ 9
Class Asignatura................................................................................... 10
Código Fuente................................................................................ 11,12
Class Estudiante................................................................................... 13,14
Código Fuente................................................................................ 15-17
Class CapturaDespliega....................................................................... 18
Código Fuente................................................................................ 19,20
Class Principal2..................................................................................... 21
Código Fuente................................................................................ 22,23
Ejecución de la Aplicación, Modo Gráfico para I/O......................................... 24-26
Reflexiones individuales del laboratorio.......................................................... 27
Conclusiones.................................................................................................. 28

INTRODUCCIÓN

4
La Encapsulación es el término de orientación a objetos con el que podemos
describir la forma de vincular las operaciones y estados a un objeto particular.
La encapsulación está íntimamente relacionada con la ocultación de la
información, definiendo qué partes de un objeto son visibles y qué partes están
ocultas.

La encapsulación abarca a la ocultación de la información:


• Algunas partes son visibles (el interfaz público)
• Otras partes son ocultas (o privadas)

En el presente laboratorio de Encapsulación 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 ejecución
del programa en un momento dado.
En primera instancia el programa captura 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,
Posteriormente adicionamos a la clase Estudiante un método para calcular la
calificación 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 cédulas.
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 descripción de la asignatura con mayor
calificación.

• Implementar otra clase Principal para controlar la ejecución del


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

Objetivos Específicos

 Diseñar e implementar una clase que permita capturar datos para


cualquiera que sea la aplicación.

 Crear N objetos Estudiantes en la clase principal

 Desplegar las salidas a través de mensajes a un método de la clase que


hace la entrada y salida (I/O).

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

 Cada método debe atender solo una tarea o función.

 Incluir cada clase en un archivo diferente.

 Adicionar a la clase Estudiante un método para calcular la calificación


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 cédulas.

DESCRIPCIÓN DEL PROBLEMA

6
I. 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.

II. 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.

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
EXPLICACIÓN 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
ejecución del programa.

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


realizar el llamado a los métodos de las clases; Asignatura, Estudiante y
CapturaDespliega. Cada método de las clases anteriormente mencionadas cumplen
con una función específica;
La clase Asignatura, consta de dos (2) métodos; el primero es privado
AbreArch() crea el flujo para leer el archivo de texto que contiene los datos de la
materia (código y nombre) y el segundo OpenArch() toma el objeto que devuelve
AbreArch() para abrir y leer el archivo
La clase Estudiante consta de 5 métodos que realizan todas las funciones
relacionadas con el estudiante, el método Getmayor () busca el estudiante de mayor
puesto, DatosEstu1() se encarga de manejar los datos personales del estudiante
como lo son: Nombre, Cedula, Código, Puesto, y Asignatura, los toma de la clase que
los captura y los devuelve en una sola cadena. El método DatosEstu() realiza la
misma función 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 métodos para tales fines. El método
Cadena() es el que concatena en una cadena los datos de; Nombre, cedula, Código
de mayor asignatura, capturados por el método de esta misma clase; CapturaDat().
DespligaDat () se encarga de mostrar en pantalla toda la información 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 método que permite
calcular el promerio de un estudiante dado un numero de cedula.

9
DESCRIPCION DE LAS CLASES, METODOS Y VARIABLES

A continuación presentamos una descripción detallada de la utilidad de cada


una de las clases, y de los métodos 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 través del acceso a cada uno los métodos
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 Descripción - 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 métodos de la clase
DatosEst CapturaDespliega()
CapturaDespliega(
Vector de objetos para manejar los datos del
ArregloEst Estudiante [ ]
estudiante.
Objeto para acceder a los métodos de la clase
Asignatura Asignatura()
Asignatura()
Objeto para acceder a los métodos de la clase
EstudianteMay Estudiante()
Estudiante()

Métodos Descripción - Funcionamiento


Se encarga de la ejecución del programa, llama a
Main() void
los métodos de las demás clases.

10
Código 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 métodos, uno privado y otro
público. Realiza la función de; a través del método privado crear el flujo que abre el
archivo de texto de donde se encuentran el código 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 Descripción - 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 método privado de esta
clase.

Métodos Descripción - Funcionamiento


Método privado que crea el flujo y abre el archivo
de texto que contiene el código y nombre de la
AbreArch() BufferedReader
asignatura, devuelve el objeto para utilizar el
archivo en el siguiente método.
Variables locales
No tiene

Realiza el llamado al método privado que crea el


flujo para abrir el archivo, lee línea por línea, 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
Código 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 métodos que realizan las
funciones relacionadas con las actividades del estudiante como lo son; obtener sus
datos; nombre, cedula, puesto, código y nombre de asignatura. Para luego procesar
esta información y determinar el estudiante de mayor puesto, así como también
realizar la búsqueda a través de la cédula y calcular el promedio de sus respectivas
notas.

ClassEstudiante
Variables de la Clase Descripción - Funcionamiento
Nombre Tipo
Nombre String Almacena el nombre del estudiante
Cedula String Almacena la cedula a buscar del estudiante
codigo String Almacena el código 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.

MÉTODOS Descripción - Funcionamiento


Getmayor Estudiante(Estu Realiza la función 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 método tiene como propósito obtener los


DatosEstu1() String datos de; nombre, cedula, código, puesto y
asignatura, pasados a través del constructor
Variables locales
Concatena para devolver una sola cadena con los
dat1 String datos de: nombre, cedula, código, puesto y
asignatura.

Este método tiene como propósito 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 método 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) información 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
Código 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","Información del estudiante",JOptionPane.INFORMATION_MESSAGE);
aux = ArregloEst[i];
sw=1;
}
if(sw==0){
JOptionPane.showMessageDialog(null,"La Cedula nos se ha encontrada","Información 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 métodos 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 Descripción - Funcionamiento
Nombre Tipo
Variable para almacenar la cadena que contiene el
CadDatos String
mensaje de nombre, cedula y código de asignatura.

MÉTODOS Descripción - Funcionamiento


Este método obtiene e imprime la cadena con el
Cadena() String
mensaje de nombre, cedula y código de asignatura.
Variables locales
Inicializa la variable cadena con el mensaje de
Cadena String
nombre, cedula y código de asignatura.

DespligaDat Este método imprime los datos de estudiante como


void
( String dat) nombre, cedula, puesto, código y asignatura.
Variables locales

CapturaCed Este Método captura y retorna la cedula del


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

CantEstudia Este método 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 método captura los datos del estudiante como


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

20
Código 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+"Información 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 ejecución del programa.
Adicionamos a la clase Estudiante un método para calcular la calificación
promedio de un estudiante, a través 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 cédulas

Class Principal2
Variables de la Clase Descripción - 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 cédula a buscar devuelta por el
cedula String
método CapturaCédula()
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

Métodos Descripción - Funcionamiento


Se encarga de la ejecución del programa, llama a
Main() void
los métodos de las demás clases.

23
Código 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
EJECUCIÓN DE LA APLICACIÓN, MODO GRÁFICO PARA I/O

A continuación describimos cada una de las evidencias de la ejecución de la


aplicación.

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, Cédula, Código
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,
Cédula, Código 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 método que calcula el promedio de un
estudiante dado una cédula, Utilizamos la clase anterior CapturaDespliega sin
realizarle modificaciones. Creamos otra clase principal (Principal2) para que se
encargara de controlar la ejecución 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 Cédula,
Además 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, cédula, notas.

Procedemos a capturar los datos del segundo estudiante: Nombre, cédula, 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 realización 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 cápsula) 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 diseñar los métodos de
manera que nos permita interactuar con los objetos aún cuando se den cambios en
sus respectivos códigos.

Concepción Jairo 9-724-1589

Los conocimientos que adquirí en este laboratorio fue el manejo de encapsulación en


los métodos y variables de instancias de cada clase. Aprendí también 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é están: el manejo de los mensajes para los
dos main, además 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 encapsulación podemos concluir que;

La encapsulación es el término de orientación a objetos con el que podemos

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

Está íntimamente relacionada con la ocultación de la información, definiendo

qué partes de un objeto son visibles y qué partes están ocultas, es una propiedad que

permite Ocultar la información al resto de los objetos

La encapsulación abarca a la ocultación de la información:

 Algunas partes son visibles (el interfaz público)

 Otras partes son ocultas (o privadas).

Este laboratorio ha sido de mucho provecho para nosotros ya que a través del

mismo hemos logrado adquirir conocimientos nuevos que encierran a la programación

Orientada a Objetos que nos servirán para desempeñarnos en nuestro futuro como

profesionales.

30