Universidad de Panamá

Centro Regional Universitario de Veraguas

Facultad de Informática, Electrónica y Comunicaciones

Carrera: Licenciatura en Informática Educativa y Empresarial

Trabajo de programación IV

Tema
Laboratorio #5 - Encapsulación

Profesor:
Diego Santimateo G.

Integrantes:

Enocjahaziel Carrasco 9-726-1139

José García 9-728-1643

Fecha:

Octubre 24 de 2008
 INTRODUCCIÓN.

Presentaremos un programa en Java estrictamente orientado a objetos

que 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.
El programa determina el nombre del estudiante con mayor puesto y
despliega la descripción de la asignatura con mayor calificación.
Las Clases utilizadas en este laboratorio fueron:

1- Captura_despliega: utilizada para capturar los datos y

desplegar la información requerida.

2- Asignatura: Se utilizo para abrir y leer el archivo de texto que

contenía las códigos y las descripciones de cada asignatura.

3- Estudiante: Utilizada para asignar la información capturada a

cada objeto correspondiente y contiene métodos para buscar el
mayor puesto y calcular el promedio, se crean objetos vectores
de tipo doubles para almacenar las notas de cada estudiante.

4- Main_principal: Hace el llamado de los métodos que están

dentro de las clases Estudiante, Captura_despliega, Asignatura
, Crea una variable de instancia de tipo Captura_despliega y
crea un objeto vector de tipo Estudiante.

5- Main_principal2: Hace el llamado de los métodos que están

dentro de las clases Estudiante, Captura_despliega, Asignatura,
Crea una variable de instancia de tipo Captura_despliega, crea
un objeto vector de tipo Estudiante y crea un objeto vector de
tipo Double
 Estructura de Desarrollo

Este Laboratorio se realizo utilizando la información facilitada por el profesor y se

hiso paso a paso según la establecido en las copias del problema ,
En la primera parte del laboratorio, En el primer punto se creo una clase para
capturar y desplegar la información para n Estudiantes de un grupo llamada
(Captura_despliega),otra clase para la información del estudiante
llamada(Estudiante) y la tercera para la manejar la información de asignatura
(asignatura).

El programa determinaba el estudiante de mayor puesto y también la descripción

de la asignatura con mayor calificación, para buscar la descripción de la
asignatura creamos un nuevo archivo con el editor de texto el cual contenía el
código de diferentes asignaturas y su respectiva descripción.

En el segundo punto del laboratorio adicionamos otro método dentro de la clase

Estudiante para calcular la calificación promedio de un estudiante. Después
añadimos a la clase Captura_despliega otros métodos para capturar las m notas
de n estudiantes con su nombre y cédula en donde tuvimos que crear un arrays de
tipo double y pasarlo a la clase estudiante. Luego creamos otro main para
controlar la nueva ejecución en donde capturábamos una cédula de un estudiante
para poder calcular su promedio.
Descripción
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 re-
curra 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 cons-
truir 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 activi-
dad 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.

Es importante que usted haga una revisión y análisis de la solución de

estos problemas para que tenga claridad en los conceptos; interfaz,
abstracción, encapsulación, clase, objeto, método y mensaje. Note que el
método que determina el promedio y el que busca la persona de mejor puesto
de honor deben devolver objetos estudiantes.
 Marco teórico

Variables estáticas o de clase

Son propias únicamente de la clase y no de los objetos que pueden crearse de la misma, por
lo tanto, sus valores son compartidos por todos los objetos de la clase. Van precedidas del
modificador static.

Para invocar a una variable estática no se necesita crear un objeto de la clase en la que se
define:

•Sise invoca desde la clase en la que se encuentra definido, basta con escribir su
nombre.

•Si se le invoca desde una clase distinta, debe anteponerse a su nombre, el de la clase
en la que se encuentra seguido del operador punto (.) <NombreClase>.variableEstatica

Abstracción

La abstracción consiste en captar las características esenciales de un objeto, así como su

comportamiento. Por ejemplo, en el caso de los automóviles, ¿Qué características podemos
abstraer de los automóviles? O lo que es lo mismo ¿Qué características semejantes tienen
todos los automóviles? Todos tendrán una marca, un modelo, número de chasis, peso,
llantas, puertas, ventanas, etc. Y en cuanto a su comportamiento todos los automóviles
podrán acelerar, frenar, retroceder, etc.

En los lenguajes de programación orientada a objetos, el concepto de Clase es la

representación y el mecanismo por el cual se gestionan las abstracciones.

Encapsulamiento

El encapsulamiento consiste en unir en la Clase las características y comportamientos, esto

es, las variables y métodos. Es tener todo esto es una sola entidad. En los lenguajes
estructurados esto era imposible. Es evidente que el encapsulamiento se logra gracias a la
abstracción y el ocultamiento que veremos a continuación.

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á necesario saber cómo lo hace.
Ocultamiento

Es la capacidad de ocultar los detalles internos del comportamiento de una Clase y exponer
sólo los detalles que sean necesarios para el resto del sistema.

El ocultamiento permite 2 cosas: restringir y controlar el uso de la Clase. Restringir porque

habrá cierto comportamiento privado de la Clase que no podrá ser accedido por otras
Clases. Y controlar porque daremos ciertos mecanismos para modificar el estado de nuestra
Clase y es en estos mecanismos dónde se validarán que algunas condiciones se cumplan.
En Java el ocultamiento se logra usando las palabras reservadas: public, private y protected
delante de las variables y métodos.
 Presentación de las clases

Clase Main_principal

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

class Main_principal {

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

Captura_despliega acceso = new Captura_despliega();

int n = acceso.getCant();
String dato;

Estudiante[] persona= new Estudiante[n];

for(int i=0;i<n;i++)
{
dato = acceso.Captura_dato();
String[] datos = dato.split(","); //separa las cadenas a partir de las comas

int puesto = Integer.parseInt(datos[2].trim());

persona[i] = new Estudiante(datos[0],datos[1],puesto);
}

Estudiante est1 = new Estudiante();

Asignatura est2 = new Asignatura();
Estudiante datest = est1.get_mayorpuesto(persona,n);
String des = est2.leer_txt(datest);
acceso.despliega(datest,des);

} //fin main
}
 Clase Main_principal2
import java.lang.*;
import java.io.*;
import javax.swing.*;

class Main_principal2 {

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

String dato,dato1,nueva;
Captura_despliega acceso = new Captura_despliega();

int n = acceso.getCant();
Estudiante persona[] = new Estudiante[n];

int x = acceso.getcantidad();
double notas[] = new double[x];//objeto vector para almacenar las notas

for(int i=0;i<n;i++)
{
dato = acceso.get_nombre();
dato1 = acceso.get_cedula();

for(int c=0;c<x;c++)//proceso para asignar las notas al vector

{
notas[c] = acceso.Captura_nota();
}

persona[i] = new Estudiante(dato,dato1,notas,x);

}
Estudiante est1 = new Estudiante();
nueva = acceso.get_cedula2(); //cédula a buscar
Estudiante data = est1.get_promedio(nueva,persona,n,x);
acceso.despliega2(data,x);

} //fin main
}
 Clase Estudiante
import java.lang.*;
import java.io.*;
import javax.swing.*;

class Estudiante{ // Las variables de instancia son privadas

private String nombre;
private String cedula;
private String codigo;
private int puesto;
private String dato;
private double notas[];
private double promedio;
//----------------------------------------------------------------------------
public Estudiante(){ //1 constructor

}
//-----------------------------------------------------------------------------
public Estudiante(String nom,String ced,double n[] ,int x){ //2 Constructor
this.nombre = nom;
this.cedula = ced;
this.notas = new double[x];//crea un objeto vector con la cantidad para
almacenar las n notas

for(int i=0;i<n.length;i++)//proceso para asignar cada nota al objeto nuevo.

{
notas[i] = n[i];
}

}
//------------------------------------------------------------------------------
public Estudiante(String nom,String cod,int puest){ //3 Constructor
this.nombre = nom;
this.codigo = cod;
this.puesto = puest;
}
//-------------------------------------------------------------------------------
// método para buscar el estudiante con mayor puesto
public Estudiante get_mayorpuesto(Estudiante vec[],int n){
Estudiante may = vec[0];
int mayor = may.get_puesto();

for (int i=1;i<n;i++)

{
if(vec[i].get_puesto() < mayor)
{
 may = vec[i];
mayor = may.get_puesto();
}
}
return(may);
}
//--------------------------------------------------------------------------------
// método para calcular el promedio del estudiante con la cedula determinada
public Estudiante get_promedio(String nueva,Estudiante per[],int n,int x){
Estudiante elegido = null;
for (int i=0;i<n;i++)
{
if((nueva.compareTo(per[i].get_cedula()))==0)
{ double[] notas = per[i].get_notas();
double sum = notas[0];
for(int c=1;c<x;c++)
{
sum = sum + notas[c];
}
elegido = per[i];
elegido.promedio = sum/x;
}
}
return(elegido);
}
//-----------------------------------------------------------------------------------
public String get_nombre(){
return(nombre);
}
//-----------------------------------------------------------------------------------
public String get_cedula(){
return(cedula);
}
//-----------------------------------------------------------------------------------
public String get_codigo(){
return(codigo);
}
//-----------------------------------------------------------------------------------
public int get_puesto(){
return(puesto);
}
//-----------------------------------------------------------------------------------
public double[] get_notas(){
return(notas);
}
//-----------------------------------------------------------------------------------
public double get_promedio(){
return(promedio);
}
//-----------------------------------------------------------------------------------
}// fin Estudiante
Clase Captura_Despliega
import java.lang.*;
import java.io.*;
import javax.swing.*;

class Captura_despliega{ // Las variables de instancia son privadas

private String dato;
private String cant;
private int numero;
private String nota;
private double not;
private String nombre;
private String cedula;
//---------------------------------------------------------------------------------------------------
public Captura_despliega(){ //Constructor

}
//---------------------------------------------------------------------------------------------------
public int getCant(){
this.cant = JOptionPane.showInputDialog(null,"Introduzca la cantidad de
objetos","MENU",JOptionPane.QUESTION_MESSAGE);
this.numero = Integer.parseInt(cant.trim());
return(numero);
}
//---------------------------------------------------------------------------------------------------
public String Captura_dato(){
this.dato = JOptionPane.showInputDialog(null,"Separe con una coma los datos: \n
Nombre:, Codigo Asig:, Puesto acad: ","MENU",JOptionPane.QUESTION_MESSAGE);
return(dato);
}
//---------------------------------------------------------------------------------------------------
public int getcantidad(){
String cantidad = JOptionPane.showInputDialog(null,"Introduzca la cantidad de
notas","MENU",JOptionPane.QUESTION_MESSAGE);
int n = Integer.parseInt(cantidad.trim());
return(n);
}
//---------------------------------------------------------------------------------------------------
public double Captura_nota(){
this.nota = JOptionPane.showInputDialog(null,"Introduzca la nota:
","MENU",JOptionPane.QUESTION_MESSAGE);
double not =Double.valueOf(nota).doubleValue();
return(not);
}
//---------------------------------------------------------------------------------------------------
public String get_nombre(){
 this.nombre = JOptionPane.showInputDialog(null,"Introduzca el nombre:
","MENU",JOptionPane.QUESTION_MESSAGE);
return(nombre);
}
//---------------------------------------------------------------------------------------------------
public String get_cedula(){
this.cedula = JOptionPane.showInputDialog(null,"Introduzca la cedula:
","MENU",JOptionPane.QUESTION_MESSAGE);
return(cedula);
}
//-----------------------------------------------
public String get_cedula2(){
this.cedula = JOptionPane.showInputDialog(null,"Introduzca la cédula a buscar :
","MENU",JOptionPane.QUESTION_MESSAGE);
return(cedula);
}

//---------------------------------------------------------------------------------------------------
public void despliega(Estudiante datos,String des){
System.out.println("******** Estudiante con mayor puesto *********");
System.out.println("\nNombre del Estudiante: "+datos.get_nombre());
System.out.println("\nCodigo de la Asignatura: " +datos.get_codigo());
System.out.println("\nDescripcion de la Asignatura: " +des);
System.out.println("\nPuesto Academico: " +datos.get_puesto());
System.out.println("\n******** --------- *********");
}
//---------------------------------------------------------------------------------------------------
public void despliega2(Estudiante data,int x){
double[] nota = data.get_notas();

if(data != null)
{
System.out.println("******** La cedula introducida pertenece a: *********");
System.out.println("\nNombre : "+data.get_nombre());
System.out.println("\nCedula : " +data.get_cedula());
nota = data.get_notas();
for(int v=0;v<x;v++)
{
System.out.println("\nNotas : "+nota[v]);
}
System.out.println("\nPromedio: " +data.get_promedio());
System.out.println("\n******** --------- *********");
}
else
{ System.out.println("La cedula introducida es Incorrecta");}
}
//---------------------------------------------------------------------------------------------------
}// fin de Clase Captura_Despliega
Clase Asignatura
import java.lang.*;
import java.io.*;
import javax.swing.*;

class Asignatura{ // Las variables de instancia son privadas

//-----------------------------------------------------------------------------
public Asignatura(){ //Constructor

}
//-----------------------------------------------------------------------------
public String leer_txt(Estudiante est)throws IOException{
String des = "";
RandomAccessFile XmlFile = new RandomAccessFile ("registro.txt", "r" );

String line = "";

int z=0;
while ((line = XmlFile.readLine()) != null)
{
String[] dat = line.split(" ");//para separar el String en cadenas
System.out.println(line);
if(dat[0].compareTo(est.get_codigo())==0)
{
des = dat[1];
z=1;
}
}
if(z==0)
des = "El código de asignatura es Incorrecto";

return(des);
}
//-------------------------------------------------------------------------------
}// fin de Asignatura
*************************************************************************
Archivo de Texto
*Nombre: Registro.txt
Cogido Materia
1101 Matemática
1102 español
1103 Ingles
1104 Biología
1105 programación
**********************************************************************

Ejecución del Programa

Con el Primer Main (Main_Principal)
 Ejecución del Programa
Con el Segundo Main (Main_Principal2)
 Conclusión

En conclusión de este trabajo pensamos que la mejor manera de poder hacer algo que
no sabes es leyendo y preguntando porque sino te frustras.
En este trabajo vemos una manera de encapsular información de un objeto y la
manera mas sencilla para capturar datos desde una clase aparte la cual funciona para
cualquiera que sea la aplicación.
Creemos que este laboratorio ha sido de gran ayuda en el tema de arrays ,la mima fue
una de las complicaciones que enfrentamos en este laboratorio, para poder asociar el
vector de las notas con los demás atributos del objeto estudiante, tuvimos que leer y
preguntar tanto en Internet como al profesor.