Encapsulamiento

UNIVERSIDAD DE PANAMÁCENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

FACULTAD DE INFORMÁTICA, ELECTRÓNICA Y COMUNICACIÓN

LICENCIATURA EN INFORMÁTICA PARA LA GESTIÓNEDUCATIVA Y EMPRESARIAL

PROGRAMACIÓN IVINF-212

LABORATORIO # 5

ENCAPSULACION

PROFESORDIEGO SANTIMATEO

INTEGRANTESJAIRO CONCEPCIÓN 9-724-1589DIOMEDES 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

8

Class Principal

Int can, I, Puesto;String Cad, AsigDevuelta;String[] Datos;Estudiante datosmay;Estudiante [ ] ArregloEst;

Main()

Objetos -ClasesDatosEst CapturaDespliega()

Asignatura Asignatura()EstudianteMay Estudiante()

Class Principal2Int k, I, j, ca, r;String Cad, cedula;String[] Datos;String AsigDevuelta;Float pro;Int[] notas;Estudiante [] ArregloEst;

Objetos-ClasesCapt CapturaDespliega()

EstudianteDat Estudiante()Aux Estudiante()

Main()

Class Asignatura Class CapturaDespliega

String Cadena() Void DespligaDat ( String dat) int CantEstudiante() void CapturaDat()

Class Estudiante

String Nombre; String Cedula; String codigo; int puesto; int notas[];float promedio ;String Asignatura;

Estudiante Getmayor (Estudiante ArregloEst[]) String DatosEstu1()String DatosEstu()Float CalPromedio (Estudiante aux)Estudiante BuscaCedula (Estudiante ArregloEst[], String ced)

BufferedReader AbreArch()

void OpenArch(String Datos[] )

String NombAsig; BufferedReader in;

String CadDatos;

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 PrincipalVariables de la Clase Descripción - Funcionamiento

Nombre Tipocan int Almacena la cantidad de estudiantes de un grupo

i int Contador del ciclo for Cad String Cadena que contiene los datos del estudiante

Puesto intAlmacena el puesto del estudiante, para luego pasarlo al vector de tipo Estudiante.

AsigDevuelta StringAlmacena el nombre de las asignaturas, para luego guardarla en el vector de tipo estudiante.

Datos String[] Vector que contiene los datos de los estudiantes

datosmay EstudianteAlmacena los datos del estudiante de mayor puesto.

ObjetosNombre Clases

DatosEst CapturaDespliega()Objeto para acceder a los métodos de la clase CapturaDespliega(

ArregloEst Estudiante [ ]Vector de objetos para manejar los datos del estudiante.

Asignatura Asignatura()Objeto para acceder a los métodos de la clase Asignatura()

EstudianteMay Estudiante()Objeto para acceder a los métodos de la clase Estudiante()

Métodos Descripción - Funcionamiento

Main() voidSe encarga de la ejecución del programa, llama a 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.

ClassAsignaturaVariables de la Clase Descripción - Funcionamiento

Nombre Tipo

NomAsig; StringVariable que obtiene y devuelve el nombre de la asignatura que se encuentra en el archive de texto.

in; BufferedReaderVariable que retorna el objeto cuando se abre el archive. Se utiliza en el método privado de esta clase.


AbreArch() BufferedReader

Método privado que crea el flujo y abre el archivo de texto que contiene el código y nombre de la asignatura, devuelve el objeto para utilizar el archivo en el siguiente método.

Variables locales

No tiene

OpenArch(String Datos[])

String

Realiza el llamado al método privado que crea el flujo para abrir el archivo, lee línea por línea, para localizar el nombre de la asignatura, cuando la encuentra la almacena en la variable NomAsig luego devuelve esta variable (cadena) con el nombre de todas las materias que hay ene el archivo.

Variables locales

s StringVariable tipo objeto para almacenar cada linea del 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.

ClassEstudianteVariables de la Clase Descripción - Funcionamiento

Nombre TipoNombre String Almacena el nombre del estudianteCedula String Almacena la cedula a buscar del estudiantecodigo String Almacena el código de la materiaPuesto int Guarda el puesto del estudianteNotas[ ] 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 - FuncionamientoGetmayor (Estudiante ArregloEst[])

Estudiante(Estudiante ArregloEst[])

Realiza la función de buscar el estudiante de mayor puesto y devolver todo sus datos, para esto utiliza la variable aux de tipo Estudiante

Variables locales

aux Estudiante0btiene y devuelve todos los datos del estudiante de mayor puesto.

i int Contador del ciclo for

DatosEstu1() StringEste método tiene como propósito obtener los datos de; nombre, cedula, código, puesto y asignatura, pasados a través del constructor

Variables locales

dat1 String Concatena para devolver una sola cadena con los datos de: nombre, cedula, código, puesto y asignatura.

DatosEstu() StringEste método tiene como propósito obtener los datos de; nombre, cedula del estudiante

Variables locales

dat1 String Concatena para devolver una sola cadena con los datos de: nombre y cedula.

15

CalPromedio(Estudiante

aux)Float

Este método tiene como objetivo calcular y devolver el promedio de las notas del estudiante. Toma el arreglo de objetos de tipo estudiante, a partir de este arreglo toma sus respectivas notas para calcular el promedio.

Variables locales

j intContador del ciclo for y de la cantidad de notas del estudiante.

suma int Acumula la sumatoria de las notas

BuscaCedula(Estudiante ArregloEst[],String ced)

Estudiante

Busca la cedula del estudiante, si la encuentra devuelve un arreglo de objetos tipo estudiante, con sus respectivos datos, emite un mensaje con la información para saber si encontró la cedula.

Variables locales

Sw IntVariable bandera para controlar el mensaje cuando no se encuentra la cedula.

i int Contador del ciclo for

Objetos

aux EstudianteObjeto del tipo estudiante, para almacenar todos 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 CapturaDespliegaVariables de la Clase Descripción - Funcionamiento

Nombre Tipo

CadDatos StringVariable para almacenar la cadena que contiene el mensaje de nombre, cedula y código de asignatura.

MÉTODOS Descripción - Funcionamiento

Cadena() StringEste método obtiene e imprime la cadena con el mensaje de nombre, cedula y código de asignatura.

Variables locales

Cadena StringInicializa la variable cadena con el mensaje de nombre, cedula y código de asignatura.

DespligaDat ( String dat)

voidEste método imprime los datos de estudiante como nombre, cedula, puesto, código y asignatura.

Variables locales

CapturaCedula()

StringEste Método captura y retorna la cedula del estudiante que se desea buscar .

Variables locales

cedula String Almacena la cedula a buscar

CantEstudiante()

intEste método captura y devuelve la cantidad de estudiante que se van a gestionar

Variables locales

CantEst intAlmacena la cantidad a estudiantes que se van a gestionar.

CapturaDat() voidEste método captura los datos del estudiante como 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 Principal2Variables de la Clase Descripción - Funcionamiento

Nombre Tipok 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 estudianteDatos String[] Vector que contiene los datos de los estudiantes

r intContador para almacenar las notas en el vector notas[]

cedula StringAlmacena la cédula a buscar devuelta por el método CapturaCédula()

prom float Almacena el promedio devuelto

ArregloEst Estudiante [ ]Arreglo de objetos de la clase Estudiante, para almacenar todos los datos del estudiante.

notas Int[ ] Arreglo de objetos para almacenar las notasObjetos

Nombre Clases

Capt CapturaDespliega()Objeto para acceder a la clase CapturaDespliega()

EstudianteDat Estudiante() Objeto para acceder a los datos del estudiante

aux Estudiante()Objeto auxiliar para acceder a los datos del estudiante


Main() voidSe encarga de la ejecución del programa, llama a 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:

main2

26

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.

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

Encapsulamiento

Documents

Transcript of Encapsulamiento