Beruflich Dokumente
Kultur Dokumente
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.
OBJETIVOS
5
Objetivo General
Objetivos Específicos
Utilizar la clase que realiza I/O sin modificarla para capturar las M notas
de los N estudiantes, sus respectivos nombres y cédulas.
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.
7
DIAGRAMA UML DE LAS CLASES
Class Principal2
Class Principal
Int k, I, j, ca, r;
Int can, I, Puesto; String Cad, cedula;
String Cad, AsigDevuelta; String[] Datos;
String[] Datos; String AsigDevuelta;
Estudiante datosmay; Float pro;
Estudiante [ ] ArregloEst; Int[] notas;
Estudiante [] ArregloEst;
Objetos -Clases
DatosEst CapturaDespliega() Objetos-Clases
Asignatura Asignatura() Capt CapturaDespliega()
EstudianteMay Estudiante() EstudianteDat Estudiante()
Aux Estudiante()
Main() Main()
8
EXPLICACIÓN DEL DIAGRAMA DE CLASES UML
9
DESCRIPCION DE LAS CLASES, METODOS Y VARIABLES
Class Principal
Class Principal
Variables de la Clase Descripción - Funcionamiento
Nombre Tipo
can int Almacena la cantidad de estudiantes de un grupo
i int Contador del ciclo for
Cad String Cadena que contiene los datos del estudiante
Almacena el puesto del estudiante, para luego
Puesto int
pasarlo al vector de tipo Estudiante.
Almacena el nombre de las asignaturas, para
AsigDevuelta String
luego guardarla en el vector de tipo estudiante.
Datos String[] Vector que contiene los datos de los estudiantes
Almacena los datos del estudiante de mayor
datosmay Estudiante
puesto.
Objetos
Nombre Clases
Objeto para acceder a los métodos de la clase
DatosEst CapturaDespliega()
CapturaDespliega(
Vector de objetos para manejar los datos del
ArregloEst Estudiante [ ]
estudiante.
Objeto para acceder a los métodos de la clase
Asignatura Asignatura()
Asignatura()
Objeto para acceder a los métodos de la clase
EstudianteMay Estudiante()
Estudiante()
10
Código fuente de Class Principal:
import java.io.*;
import java.lang.String;
class Principal{
int i;
String Cad;
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 Descripción - Funcionamiento
Nombre Tipo
Variable que obtiene y devuelve el nombre de la
NomAsig; String
asignatura que se encuentra en el archive de texto.
Variable que retorna el objeto cuando se abre el
in; BufferedReader archive. Se utiliza en el método privado de esta
clase.
Variables locales
Variable tipo objeto para almacenar cada linea del
s String
archivo.
12
Código fuente de Class Asignatura:
import java.lang.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
class Asignatura{
public Asignatura(){//constructor
}
/*********************************************************************************************/
/* Metodo AbreArch abre el archivo */
/*********************************************************************************************/
/*********************************************************************************************/
/* Metodo OpenArch abre el archivo para buscar en codigo y el nombre de la material */
/*********************************************************************************************/
13
try {
BufferedReader lee=AbreArch();
int j=0;
String linea;
String s = new String();
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);
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 Descripción - Funcionamiento
Nombre Tipo
Nombre String Almacena el nombre del estudiante
Cedula String Almacena la cedula a buscar del estudiante
codigo String Almacena el código de la materia
Puesto int Guarda el puesto del estudiante
Notas[ ] 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.
15
Este método tiene como objetivo calcular y devolver
CalPromedio el promedio de las notas del estudiante. Toma el
(Estudiante Float arreglo de objetos de tipo estudiante, a partir de
aux) este arreglo toma sus respectivas notas para
calcular el promedio.
Variables locales
Contador del ciclo for y de la cantidad de notas del
j int
estudiante.
suma int Acumula la sumatoria de las notas
Objetos
Objeto del tipo estudiante, para almacenar todos
aux Estudiante
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
/*********************************************************************************************/
/* 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);
/*********************************************************************************************/
/* Metodo DatosEstu obtiene los datos nombre,cedula y promedio */
/*********************************************************************************************/
18
for(j=0;j<aux.notas.length;j++){
suma=suma+aux.notas[j];
}
this.promedio= suma/j;
return(promedio);
/*********************************************************************************************/
/* Metodo BuscaCedula busca la cedula del estudiante */
/*********************************************************************************************/
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 Descripción - Funcionamiento
Nombre Tipo
Variable para almacenar la cadena que contiene el
CadDatos String
mensaje de nombre, cedula y código de asignatura.
20
Código fuente de Class CapturaDespliega:
import java.io.*;
import javax.swing.*;
class CapturaDespliega{
public CapturaDespliega(){
/****************************************************************************************************/
/*Metodo Cadena imprime los datos de estudiante como nombre,cedula,puesto,codigo y asignatura */
/****************************************************************************************************/
/****************************************************************************************************/
/*Metodo DespliegaDat imprime los datos de estudiante como nombre,cedula,puesto,codigo y asignatura */
/****************************************************************************************************/
/*********************************************************************************************/
21
/* Metodo CapCedula pregunta por la cedula del estudiante que se desea buscar */
/*********************************************************************************************/
/*********************************************************************************************/
/* Metodo CantEstudiante captura la cantidad de estudiane que se van a gestionar */
/*********************************************************************************************/
}
/****************************************************************************************************/
/* Metodo CapturaDat preguna por los datos del estudiante */
/****************************************************************************************************/
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 Descripción - Funcionamiento
Nombre Tipo
k 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 estudiante
Datos String[] Vector que contiene los datos de los estudiantes
Contador para almacenar las notas en el vector
r int
notas[]
Almacena la cédula a buscar devuelta por el
cedula String
método CapturaCédula()
prom float Almacena el promedio devuelto
Arreglo de objetos de la clase Estudiante, para
ArregloEst Estudiante [ ]
almacenar todos los datos del estudiante.
notas Int[ ] Arreglo de objetos para almacenar las notas
Objetos
Nombre Clases
Objeto para acceder a la clase
Capt CapturaDespliega()
CapturaDespliega()
EstudianteDat Estudiante() Objeto para acceder a los datos del estudiante
Objeto auxiliar para acceder a los datos del
aux Estudiante()
estudiante
23
Código fuente de Class Principal2:
import java.io.*;
import java.lang.String;
class Principal2{
int k = Capt.CantEstudiante();
Estudiante [] ArregloEst= new Estudiante[k];
int i,j;
int ca=0;
String Cad;
int r=0;
ca=Datos.length-2;
int [] notas=new int[ca];
for (j=2;j<Datos.length;j++)
{
notas[r] = Integer.parseInt(Datos[j]);
r++;
24
}
25
EJECUCIÓN DE LA APLICACIÓN, MODO GRÁFICO PARA I/O
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 (,)
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 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
28
REFLEXIONES INDIVIDUALES DEL LABORATORIO
29
CONCLUSIONES
qué partes de un objeto son visibles y qué partes están ocultas, es una propiedad que
Este laboratorio ha sido de mucho provecho para nosotros ya que a través del
Orientada a Objetos que nos servirán para desempeñarnos en nuestro futuro como
profesionales.
30