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

TemaLaboratorio #5 - Encapsulación

Profesor:Diego Santimateo G.

Integrantes:

Enocjahaziel Carrasco 9-726-1139José 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 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.

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:

Si se 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_principal2import 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 Estudianteimport 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 EstudianteClase 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 Asignaturaimport 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 Materia1101 1102 1103 1104 1105

MatemáticaespañolInglesBiologíaprogramación

**********************************************************************

Ejecución del ProgramaCon el Primer Main (Main_Principal)

Ejecución del ProgramaCon 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.