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Ó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; String Cad, cedula; String[] Datos; String AsigDevuelta; Float pro; Int[] notas; Estudiante [] ArregloEst;

Int can, I, Puesto; String Cad, AsigDevuelta; String[] Datos; Estudiante datosmay; Estudiante [ ] ArregloEst; Objetos -Clases DatosEst CapturaDespliega() Asignatura Asignatura() EstudianteMay Estudiante()

Objetos-Clases Capt CapturaDespliega() EstudianteDat Estudiante() Aux Estudiante()

Main()

Class Asignatura

String NombAsig; BufferedReader in;

BufferedReader AbreArch() void OpenArch(String Datos[] )

Main()

Class Estudiante

Class CapturaDespliega String CadDatos;

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)

8

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

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 Nombre Tipo can int i int Cad String Puesto

int

AsigDevuelta

String

Datos

String[]

datosmay

Estudiante

Descripción - Funcionamiento Almacena la cantidad de estudiantes de un grupo Contador del ciclo for Cadena que contiene los datos del estudiante Almacena el puesto del estudiante, para luego pasarlo al vector de tipo Estudiante. Almacena el nombre de las asignaturas, para luego guardarla en el vector de tipo estudiante. Vector que contiene los datos de los estudiantes Almacena los datos del estudiante de mayor puesto.

Objetos Nombre

Clases

DatosEst

CapturaDespliega()

ArregloEst

Estudiante [ ]

Asignatura

Asignatura()

EstudianteMay

Estudiante()

Métodos

Main()

void

Objeto para acceder a los métodos de la clase CapturaDespliega( Vector de objetos para manejar los datos del estudiante. Objeto para acceder a los métodos de la clase Asignatura() Objeto para acceder a los métodos de la clase Estudiante() Descripción - Funcionamiento Se 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
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 Nombre Tipo

Descripción - Funcionamiento

Variable que obtiene y devuelve el nombre de la asignatura que se encuentra en el archive de texto. Variable que retorna el objeto cuando se abre el BufferedReader archive. Se utiliza en el método privado de esta clase.

NomAsig;

String

in;

Métodos AbreArch() BufferedReader

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

String

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

ClassEstudiante Variables de la Clase Nombre Tipo Nombre String Cedula String codigo String Puesto int Notas[ ] int promedio float asignatura String MÉTODOS Getmayor Estudiante(Estu (Estudiante diante ArregloEst[]) ArregloEst[])

Descripción - Funcionamiento Almacena el nombre del estudiante Almacena la cedula a buscar del estudiante Almacena el código de la materia Guarda el puesto del estudiante Vector para almacenar las notas de los estudiantes Almacena el promedio de notas del estudiante. Almacena el nombre del estudiante. Descripción - Funcionamiento 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

Estudiante

i

int

DatosEstu1()

String

0btiene y devuelve todos los datos del estudiante de mayor puesto. Contador del ciclo for Este 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

DatosEstu()

String

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

String

Este 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

int

suma

int

BuscaCedul a(Estudiante ArregloEst[], String ced)

Estudiante

Contador del ciclo for y de la cantidad de notas del estudiante. Acumula la sumatoria de las notas 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

Int

i

int

Variable bandera para controlar el mensaje cuando no se encuentra la cedula. Contador del ciclo for

Objetos aux

Estudiante

Objeto 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.puesto+"\nAsignatuta: "+this.asignatura); return (dat1); }

"+this.cedula+"\n

/*********************************************************************************************/ /* 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

Codigo:

"+this.codigo+"\n

Puesto:

for(j=0;j
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 Nombre Tipo CadDatos

String

MÉTODOS Cadena()

String

Descripción - Funcionamiento Variable para almacenar la cadena que contiene el mensaje de nombre, cedula y código de asignatura. Descripción - Funcionamiento Este método obtiene e imprime la cadena con el mensaje de nombre, cedula y código de asignatura.

Variables locales

Cadena

DespligaDat ( String dat)

String

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

void

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

Variables locales

CapturaCed ula()

String

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

Variables locales

cedula

String

CantEstudia nte()

Almacena la cedula a buscar

int

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

int

Almacena la cantidad a estudiantes que se van a gestionar.

void

Este método captura los datos del estudiante como lo son; Nombre, cedula, Código de mayor asignatura.

Variables locales

CantEst

CapturaDat()

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 Nombre Tipo k int I, j int ca int Cad String Datos String[] r

int

cedula

String

prom

float

ArregloEst

Estudiante [ ]

notas

Int[ ]

Descripción - Funcionamiento Almacena la cantidad de estudiantes de un grupo Contadores de ciclos for Almacena la cantidad de notas de un estudiante Cadena que contiene los datos del estudiante Vector que contiene los datos de los estudiantes Contador para almacenar las notas en el vector notas[] Almacena la cédula a buscar devuelta por el método CapturaCédula() Almacena el promedio devuelto Arreglo de objetos de la clase Estudiante, para almacenar todos los datos del estudiante. Arreglo de objetos para almacenar las notas

Objetos Nombre

Clases

Capt

CapturaDespliega()

EstudianteDat

Estudiante()

aux

Estudiante() Métodos

Main()

void

Objeto para acceder a la clase CapturaDespliega() Objeto para acceder a los datos del estudiante Objeto auxiliar para acceder a los datos del estudiante Descripción - Funcionamiento Se 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
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