UNIVERSIDAD DE PANAMA

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS

FACULTAD DE INFORMÁTICA, ELECTRÓNICA Y COMUNICACIÓN
INGENIERÍA EN INFORMÁTICA

INF 222 - PROGRAMACIÓN III

LABORATORIO #5

SOBRE:
ENCAPSULACIÓN

INTEGRANTES:
FELIX RIVERA
EUFEMIA BUITRAGO

PROFESOR:
DIEGO SANTIMATEO
 INTRODUCCION

La encapsulación es la capacidad de un objeto de ser un contenedor (o cápsula) de sus

propiedades y comportamiento. Esto significa que los datos o variables y el código del objeto
deben estar ocultos detrás de la interfaz. La idea es que la interfaz (método público en una clase)
que esté bien diseñada y en consecuencia sea permanentemente consistente, permita interactuar
con los objetos aún cuando se den cambios en sus respectivos códigos.
 PROBLEMA PLANTEADO

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 desplegarse 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.
 SOLUCION DEL PROBLEMA

Primera Clase (Main de la Parte “a”):

import java.io.*; //declaración de las librerías utilizadas
import java.util.*;
import javax.swing.*;
import java.lang.String;
class Principal
{
public static void main(String[] args)throws IOException
{
try
{
String dat,t; //declaración de las variables a utilizar
int i,puesto;
CapturaDespliega acces = new CapturaDespliega();//se crea un objet
Asignatura cap_dat_txt = new Asignatura(); //se crea un objeto

int n=acces.getCantidad(); //llama método q’ indica cant. de estud

Estudiante [] estud= new Estudiante[n];
String no = new String();
String c = new String();
String p = new String();

JOptionPane.showMessageDialog(null,"Ingrese los datos separados por

una coma ',' :");

for(i=0;i<n;i++)//controla la cantidad de estudiantes ingresados

{
dat = acces.captura_teclado();

StringTokenizer tokens = new StringTokenizer(dat,",");

while(tokens.hasMoreTokens())
{
no =tokens.nextToken();
c=tokens.nextToken();
p=tokens.nextToken();
}
Double[] puest=new Double[1];
puest[0] = Double.parseDouble(p);
estud[i]=new Estudiante(no,c,puest);
}
Estudiante on =estud [0];
Estudiante h = on.mayor(estud,n);
String nomb=h.no();
String co=h.c();
Double[] pue=h.puest();
t=cap_dat_txt.capturar(nomb,co,pue);
acces.imprimir(t);
}
catch(Exception e){
JOptionPane.showMessageDialog(null," ****Error en la
captura****");}
}
}
Tabla que representa las diversas variables, invocación a los métodos, etc. en la clase Principal.

VARIABLE Ó MÉTODO DESCRIPCIÓN TIPO

dat Captura el resultado del método que captura String
los datos.
t Captura el resultado del método donde se String
lee el archivo y se comparan los códigos.
no Guarda el primer token(parte del String dat) String
c Guarda el segundo token(parte del String String
dat)
p Guarda el tercer token(parte del String dat) String
n Captura el resultado del método que captura
la cantidad de estudiantes
puest[0] Almacena el valor del puesto convertido en Double
Double.
puest
i Controla el ciclo para la cantidad de int
estudiantes
nomb Captura el resultado del método que captura String
el nombre del estudiante con puesto mayor
co Captura el resultado del método que captura String
el código del estudiante con puesto mayor
pue[] Captura el resultado del método que captura Double
el puesto
CapturaDespliega acces = new Se crea un objeto de clase CapturaDespliega
CapturaDespliega();
CapturaDespliega llamado acces.
Asignatura cap_dat_txt = new Se crea un objeto de la clase Asignatura Asignatura
Asignatura();
llamado cap_dat_txt.
acces.getCantidad(); Invocación al método que indica la cantidad int
de estudiantes
Estudiante [] estud= new Se crea un objeto de la clase Estudiante Estudiante
Estudiante[n];
llamado estud[]
acces.captura_teclado(); Invocación al método que captura los datos String
que se ingresan por teclado
estud[i]=new Constructor el cual tiene como argumentos, Estudiante
Estudiante(no,c,puest);
el nombre, código, puesto
on Variable que captura el resultado del Estudiante
estudiante con el mayor puesto
on.mayor(estud,n); Método que captura el estudiante con Estudiante
mayor puesto.
h.no(); Método que captura el nombre del String
estudiante con puesto mayor
h.c(); Método que captura el código del String
estudiante con puesto mayor
cap_dat_txt.capturar(nomb,co,pue); Se lee el archivo y se verifica el código para String
desplegar cual es la materia correspondiente
Segunda Clase (Main de la Parte “b”): Principal2

import java.io.*; //declaración de las librerías utilizadas

import java.util.*;
import javax.swing.*;
import java.lang.String;
class Principal2
{
public static void main(String[] args)throws IOException
{
try
{
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr); //flujo de datos
int i;
String dat;
CapturaDespliega acces = new CapturaDespliega();
Asignatura cap_dat_txt = new Asignatura();

int n=acces.getCantidad();
Estudiante [] estud= new Estudiante[n];
String no = new String();
String c = new String();
String m = new String();

JOptionPane.showMessageDialog(null,"Ingrese los datos

separados por una coma ',' :"); //se ingresan los datos
for(i=0;i<n;i++) //ciclo que controla la cantidad
de estudiantes
{
dat = acces.captura_teclado();
String[] r = dat.split(","); //parte el String y los
guarda en un vector
int k = r.length-2; //calcula la longitud del String
y le resta 2
Double[] vect_notas = new Double[k];
//parte el String StringTokenizer tokens = new StringTokenizer(dat,",");
//ciclo para capturar… while(tokens.hasMoreTokens())
//el nombre y cedula {
no = tokens.nextToken(); //guarda el nombre
c = tokens.nextToken(); //guarda la cedula
int j=0;
//ciclo para almacenar las notas while(tokens.hasMoreTokens())
{
m=tokens.nextToken();
//se guarda en vector y se convierte en Double
vect_notas[j]=Double.parseDouble(m);
j++;
}
estud[i]=new Estudiante(no,c,vect_notas);
}
}
Estudiante on =estud[0];
 String as = on.compara(estud,n); //invocación al método
donde se comparan las cedulas…
acces.imprimir(as); //invocación al método para imprimir
}
catch(Exception e){
JOptionPane.showMessageDialog(null," ****Error en la
captura****");}
}
}

Este main es muy similar al anterior, ya que ambos realizan funciones semejantes en la
captura de datos. A diferencia del anterior donde el dato del puesto se guarda en una variable tipo
vector donde solamente se utiliza una posición; obviamente la primera para guardar ese dato, en
éste caso el valor de las notas se guarda en una variable tipo vector pero sus posiciones pueden
abarcar una o más de una posiciones; de acuerdo a la cantidad de notas. Los datos como el
nombre se guardan de la misma manera en ambos casos; y respecto al código y la cedula también
se guardan de iguales.

Clase 3: CapturaDespliega
import javax.swing.*; //librerías utilizadas
import java.io.*;
class CapturaDespliega
{
String texto,valores; //declaracion de las variables utilizadas
InputStreamReader isr=new InputStreamReader(System.in); //flujo de datos
BufferedReader br=new BufferedReader(isr);

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

public int getCantidad() //método que indica la cantidad de estudiantes

{
try {
texto = JOptionPane.showInputDialog(null,"Indique cantidad de
estudiantes:",JOptionPane.QUESTION_MESSAGE); //se ingresa la cantidad
int num = Integer.parseInt(texto); //se convierte a entero
return(num); //retorna el valor al main
}
catch (Exception e)
{
JOptionPane.showMessageDialog(null," ****Error en la
captura****");}
return(0);
}

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

public String captura_teclado()throws IOException //método donde se capturan los

datos por el teclado
 {
try
{
valores = JOptionPane.showInputDialog(null,"Datos del
estudiante:",JOptionPane.QUESTION_MESSAGE); //se ingresan los datos
}
catch(Exception e){
JOptionPane.showMessageDialog(null," ****Error en la
captura****");}
return(valores); //retorna los datos capturados
}

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

public void imprimir(String imp) // método que imprime los resultados finales
de ambos main
{
JOptionPane.showMessageDialog(null,imp); //impresión de resultados
}

//*************************************************************************************
}

Tabla que representa las diversas variables, métodos, etc. en la clase CapturaDespliega.

VARIABLE Ó MÉTODO DESCRIPCIÓN TIPO

texto Guarda la cantidad de estudiantes String
que se desean
valores Guarda los datos que se ingresan por String
teclado
num Guarda la cantidad de estudiantes int
pero el valor convertido en entero.
public int getCantidad() Método que indica la cantidad de int
estudiantes
public String captura_teclado() Método donde se capturan los datos String
por el teclado
public void imprimir(String imp) Método que imprime los resultados void
finales de ambos main
Clase 4: Asignatura
import java.io.*; //librerías utilizadas
import javax.swing.*;
public class Asignatura
{
public String capturar(String n,String co,Double p[]) //lee el archivo y compara
el código con las líneas leídas del archivo
{
String datos="datos.txt"; //declaración de las variables utilizadas
String ret=null;
String r=null;
int u=0,g=0;
try {
FileReader arch1 = new FileReader(datos); //flujo para leer el
archivo
BufferedReader in = new BufferedReader(arch1);

String s = new String();

while((s = in.readLine())!= null) //lectura por línea del archivo
{
int val = s.indexOf(co); //se compara si en cada línea leída
del archive se encuentra el código del estudiante con el mayor puesto
if(val>=0)
{
ret=s; //se guarda la línea leída si se encuentra
u=1;
}
else
g=0;
}
in.close(); //se cierra el archivo leído
//Se guarda en una sola variable los resultados para luego retornarlos e invocar al
método de impresión.
r="\n\t\t***DATOS DEL ESTUDIANTE QUE OCUPA EL PRIMER PUESTO***";
r=r+"\n\nEl nombre del estudiante es: "+n;
if((u==1)&&(g==0))
r=r+"\nEl código y nombre de la materia es: "+ret;
else
r=r+"\nEsta materia no existe";

r=r+"\nEl puesto del estudiante es: "+p[0];

}
catch(Exception e){
JOptionPane.showMessageDialog(null," ****Error en la
captura****");}
return(r); //se retorna la variable que contiene todos los resultados
}
}
Tabla que representa las diversas variables, métodos, etc. en la clase Asignatura.

VARIABLE Ó MÉTODO DESCRIPCIÓN TIPO

datos Guarda el nombre del archivo que se va a leer String
ret Guarda la línea en caso de encontrar el código String
r Guarda todos los resultados concatenados para String
retornarlos al main e invocar al método de
impresión
u,g Variables cuya función es verificar si el código int
se encontró en alguna línea del archivo.
s Guarda las líneas leídas del archivo String
val Guarda el valor resultado de la comparación int
del código con las líneas del archivo. Si es
mayor que “0” existió.
public String Método que contiene como argumentos el String
capturar(String n,String
co,Double p[]) nombre, código y puesto del estudiante con el
mayor puesto; donde también se lee el archivo
para comparar los códigos y desplegar el
respectivo nombre de la materia.

Clase 5: Estudiante
import java.io.*; //librerías utilizadas
import javax.swing.*;
class Estudiante
{

private String nombre;

private String codigo;
private Double[] puesto;
int i,pos;

InputStreamReader isr=new InputStreamReader(System .in); //flujo de datos

BufferedReader br=new BufferedReader(isr);

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

public Estudiante(String no,String c,Double puest[])//constructor que almacena

el nombre, código, puesto o notas de acuerdo al caso
{
this.nombre = no;
this.codigo = c;
this.puesto=puest;
}

//***************************************************************
public String no() //almacena el nombre
{
return(this.nombre); //retorna nombre
}

//***************************************************************
 public String c() //almacena el código
{
return( this.codigo); //retorna código
}
//***************************************************************
public Double[] puest() //almacena puesto o notas de acuerdo al caso
{
return(this.puesto); //retorna puesto o notas de acuerdo al caso
}

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

public Estudiante mayor(Estudiante estud[],int n) //método que busca el

estudiante de mayor puesto
{
Estudiante may = estud[0];
for(i=0;i<n;i++)
{
if(estud[i].puesto[0]<=may.puesto[0]) //condición que verifica el
mayor puesto
{
may=estud[i];
}
}
return(may); //retorna el mayor
}

//***************************************************************
public String compara(Estudiante estud[],int n) //compara las cedulas de los
estudiantes con la cedula ingresada para sacarle el promedio de sus notas.
{
int k,l=0,mi=1,mo=1; //declaración de las variables
String nom_verd=new String();
Double prom=0.0;
String c=null;

String cedula = JOptionPane.showInputDialog(null,"Ingrese la cedula del

estudiante para obtener su promedio:",JOptionPane.QUESTION_MESSAGE); //se ingresa la
cedula
for(int i=0;i<n;i++)
{
if((estud[i].codigo).equals(cedula)) //compara las cedulas
{
double cont=0.0;
l = estud[i].puesto.length; //se calcula la longitud del
vector que contiene las notas
for(k=0;k<l;k++){
cont = cont + estud[i].puesto[k];}//suma de las notas
prom=cont/l; //se saca el promedio
nom_verd = estud[i].nombre; //se guarda el nombre de la
persona que se le calculó el promedio
mi=0;
}
else
mo=1;
}
//Se guarda en una sola variable los resultados para luego retornarlos e invocar al
método de impresión.
if((mi!=0)&&(mo==1))
c="La cedula ingresada no existe";

else
{
 c="*****Datos del estudiante del cual se ingresó la
cédula*****\n\n";

c=c+"Nombre del estudiante: "+nom_verd;

c=c+"\nCédula del estudiante: "+cedula;
c=c+"\nPromedio del estudiante: "+prom;
}
return(c); //se retorna la variable que contiene todos los resultados
}
}

Tabla que representa las diversas variables, métodos, etc. en la clase Estudiante.

VARIABLE Ó MÉTODO DESCRIPCIÓN TIPO

nombre Guarda los nombre de los String
estudiantes
codigo Guarda los códigos de los String
estudiantes
Double[] puesto Guarda el puesto o notas de Double
los estudiantes
i Controla el ciclo de la cantidad int
de estudiantes
may Contiene los mismos datos que Estudiante
el objeto estud[]
k Controla el ciclo que procesa Int
las notas para sumarlas
l Guarda la longitud del vector int
que contiene las notas
nom_verd Guarda el nombre del String
estudiante del cual se ingresó
la cedula
mi,mo Verifican si la cedula existió o int
no
c Guarda todos los resultados String
concatenados para retornarlos
al main e invocar al método de
impresión
public Estudiante(String Constructor que almacena el Estudiante
no,String c,Double puest[])
nombre, código, puesto o
notas de acuerdo al caso
public String no() Método que guarda el nombre String
específicamente
public String c() Método que guarda el código String
específicamente
public Double[] puest() Método que guarda el puesto Double
específicamente
 public Estudiante Método que calcula el Estudiante
mayor(Estudiante
estud[],int n) estudiante con mayor puesto,
el cual cuenta con los
argumentos como el objeto
estud[] y la cantidad de
estudiantes n.
public String Método que compara las String
compara(Estudiante
estud[],int n) cedulas de los estudiantes con
la cedula ingresada para
sacarle el promedio de sus
notas. Contiene como
argumentos el objeto estud[] y
la cantidad de estudiantes n.

Este archivo es donde se encuentran los códigos con los respectivos nombres de las materias.
Nota: Estos códigos no son los que representan verdaderamente a éstas materias.

RESULTADOS DE LA EJECUCION:

Este primer ejemplo muestra la parte “a” del laboratorio.

,
Este mensaje indica que los datos se deben ingresar separados por coma “ ”.
Datos del estudiante 1 Datos del estudiante 2

Datos del estudiante 3

Resultado Final
Este ejemplo muestra la parte “b” del laboratorio.

Al igual que el main anterior éste mensaje indica que los datos se deben ingresar separados por
,
coma “ ”.

Datos del estudiante 1 Datos del estudiante 2

Datos del estudiante 3

A continuación se ingresa la cédula del estudiante al cual se le va a sacar su promedio

Resultado Final
 CONCLUSIÓN

Este informe de laboratorio muestra el uso de encapsulamiento en las clases; ya que éste
mecanismo hace unir en la Clase las características y comportamientos; es decir, las variables y
métodos. En fin es tener todo esto es una sola entidad.

La utilidad del encapsulamiento va por la facilidad para manejar la complejidad, ya que

tendremos a las Clases como cajas negras donde sólo se conoce el comportamiento pero no los
detalles internos, en consecuencia interesa conocer solo lo qué hace la Clase, pero no será necesa-
rio saber cómo lo hace.

El encapsulamiento es algo que debe estar entre las prácticas de todo desarrollador de
software. Con el tiempo una va ganado más y más experiencia y esto se vuelve algo natural en el
proceso de diseño de software. La experiencia de cuando usar y cuando no se va ganando con el
tiempo pero haciendo un buen análisis antes de empezar a desarrollar ayuda mucho.