Republica de Panamá

Centro Regional Universitario de

Veraguas

Licenciatura de Ingeniería en
Informática

Programación III

Laboratorio #3

Tema: Array de Objetos, variables

de clases, variables de instancias y
métodos estáticos.

Pertenece a:

Norberto Delgado
9-731-110
Profesor: Diego Santimateo

II Semestre del año 2008

 Introducción
Una variable de instancia es la que se da en el momento en
que se crea un nuevo objeto de una clase.
En las variables de instancia es el lugar en donde guardar los
atributos de un objeto particular.
Las variables de instancias de se dan por igual para los
objetos de una misma clase.
Las variables de clase son similares a las variables de
instancia, con la excepción de que los valores que guardan son
los mismos para todos los objetos de una determinada clase.
Los Arrays se usan para organizar la información de objetos
definidos por el programador los cuales pueden ser accedidos
en cualquier momento del programa.
Los métodos estáticos se declaran en una clase no para ser
utilizados como mensajes a los objetos sino para producir
acciones que no están asociadas a ningún objeto en particular.
El siguiente laboratorio nos da una mejor idea de cómo
trabajar con estas variables, con el array de objetos y los
métodos estáticos.
 Semana #6
Práctica
Array de Objetos, variables de clases, variables
de instancias y métodos estáticos.

Escriba una clase denominada Estudiante con los

siguientes atributos: nombre, cédula y edad. Adicione
un constructor a su clase para inicializar las variables
de instancia. Incluya un método que devuelva el
nombre, otro que devuelva la cédula y otro que
devuelva la edad.

import java.io.*;
class AccesoEstudiante
{
//Comprobacion de acceso Public por defaul

public static void main (String [] arg) throws

IOException
{
try{
InputStreamReader isr=new
InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.print("introduce el nombre: ");
String n=br.readLine();
System.out.print("introduce la cedula: ");
String c=br.readLine();
System.out.print("introduce la edad: ");
 String e=br.readLine();
int num=Integer.parseInt(e);
Estudiante persona=new Estudiante(n,c,num);
persona.obtener_nombre();
persona.obtener_edad();
persona.obtener_cedula();
}
catch(Exception e)
{
System.out.println("\nError en la captura de los
dtos");
}
}
}

class Estudiante {
String cedula;
String nombre;
int edad;

public Estudiante(String nom, String ced, int edd)

{
this.nombre=nom;
this.cedula=ced;
this.edad=edd;
}
public void obtener_nombre()
{
System.out.println("********_______********");
System.out.println("\nel nombre de la persona es
===>:"+nombre);
System.out.println("********_______********");
}
public void obtener_cedula()
{
System.out.println("********_______********");
System.out.println("\nla cedula de la persona es
===>:"+cedula);
System.out.println("********_______********");
}
public void obtener_edad()
{
System.out.println("********_______********");
System.out.println("\nla edad de la persona es
===>:"+edad);
System.out.println("********_______********");

}
}//fin Estudiante

2. Construya una clase Principal (la que contiene al

main) que capture datos de dos estudiantes ¿debe
crear un objeto (Estudiante) para cada conjunto de
datos??? y despliegue los valores de cada estudiante
(...si no usa la clase Estudiante, NO está en el camino
correcto...) obviamente usando los métodos que
pueden acceder a las variables de instancia.¿Pudo
notar cómo se distingue un objeto estudiante de otro?
Explique en detalle.

import java.io.*;
class AccesoPrincipa2{
//Comprobacion de acceso Public por defaul

public static void main (String [] arg) throws

IOException
{
try{
int i;
for(i=0;i<2;i=i+1)
{
InputStreamReader isr=new
InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.print("\n introduce el nombre de la
persona ["+(i+1)+"] :");
String o=br.readLine();
System.out.print("\n introduce la cedula de la
persona ["+(i+1)+"] :");
String c=br.readLine();
System.out.print("\n introduce la edad de la
persona ["+(i+1)+"] :");
String e=br.readLine();
Int num=Integer.parseInt(e);

Principal2 persona=new Principal2(o,c,num);

persona.obtener_nombre();
persona.obtener_edad();
persona.obtener_cedula();
}
catch(Exception e)
{
System.out.println("\nError en la captura de los
datos");
}
}
}

class Principal2 {
String cedula;
String nombre;
int edad;

public Principal2(String nom, String ced, int edd)

{
this.nombre=nom;
this.cedula=ced;
this.edad=edd;
}

public void obtener_nombre()

{
System.out.println("********_______********");
System.out.println("\nel nombre de la persona es
===>:"+nombre);
System.out.println("********_______********");
}
public void obtener_cedula()
{
System.out.println("********_______********");
System.out.println("\nla cedula de la persona es
===>:"+cedula);
System.out.println("********_______********");
}
public void obtener_edad()
{
System.out.println("********_______********");
System.out.println("\nla edad de la persona es
===>:"+edad);
System.out.println("********_______********");
}

}//fin Estudiante

3. Modifique su clase Principal para que determine

cuál es el nombre del estudiante de mayor edad.

import java.io.*;
class AccesoPrincipal3{
//Comprobacion de acceso Public por defaul
public static void main (String [] arg) throws
IOException
{
int may=0;
String nombre="";
try
{
for(int i=0;i<2;i=i+1)
{
InputStreamReader isr=new
InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.print("\n introduce el nombre de la
persona ["+(i+1)+"] :");
String o=br.readLine();
System.out.print("\n introduce la cedula de la
persona ["+(i+1)+"] :");
String c=br.readLine();
System.out.print("\n introduce la edad de la
persona ["+(i+1)+"] :");
String e=br.readLine();
int num=Integer.parseInt(e) ;
if(num>may)
{
may=num;
nombre=o;
}
Principal2 persona=new Principal2(o,c,num);
System.out.println("\nDatos de la persona
["+(i+1)+"]");
persona.obtener_nombre();
persona.obtener_edad();
persona.obtener_cedula();
}
System.out.println("\nEl nombre de la persona de
mayor edad es ==> "+nombre);
}
catch(Exception e)
{
System.out.println("\nError en la captura de los
datos");
}
}
}
class Principal3 {
String cedula;
String nombre;
int edad;

public Principal3(String nom, String ced, int edd)

{
this.nombre=nom;
this.cedula=ced;
this.edad=edd;
}

public void obtener_nombre()

{
System.out.println("********_______********");
System.out.println("\nel nombre de la persona es
===>:"+nombre);
System.out.println("********_______********");
}
public void obtener_cedula()
{
System.out.println("********_______********");
System.out.println("\nla cedula de la persona es
===>:"+cedula);
 System.out.println("********_______********");
}
public void obtener_edad()
{
System.out.println("********_______********");
System.out.println("\nla edad de la persona es
===>:"+edad);
System.out.println("********_______********");
}
}//fin Estudiante3

4. Acto seguido …, NO calcule la mayor edad en

Principal, elabore un método en la clase Estudiante
que haga ese trabajo. Describa en detalle cuáles
fueron las diferencias entre los puntos 3 y 4, comente
con otros compañer@s ...¿están todos de
acuerdo?¿dónde hay diferencia de opiniones? ¿hay
varias versiones y todas funcionan? ¿cuál es más fácil
de entender? ¿puedes ayudar a alguien a comprender
lo que hacemos?, entonces, manos a la obra.

import java.io.*;
class AccesoPrincipal4{
//Comprobacion de acceso Public por defaul

public static void main (String [] arg) throws

IOException
{
try{
int i=0;
int may=0;
String nombre="";
for(i=0;i<2;i++)
{
InputStreamReader isr=new
InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.print("\n introduce el nombre de la
persona ["+(i+1)+"] :");
String o=br.readLine();
System.out.print("\n introduce la cedula de la
persona ["+(i+1)+"] :");
String c=br.readLine();
System.out.print("\n introduce la edad de la
persona ["+(i+1)+"] :");
String e=br.readLine();
int num=Integer.parseInt(e) ;
Principal4 persona=new Principal4(o,c,num);
System.out.println("\nDatos del estudiante
["+(i+1)+"]");
persona.obtener_nombre();
persona.obtener_edad();
persona.obtener_cedula();
may=persona.obtener_mayor(may,num,o);
if(i==1)
persona.imprime();
}
}
catch(Exception e)
{
System.out.println("\nError en la captura de los
datos");
}
}
}

class Principal4 {
String cedula;
String nombre;
int edad;
String tera;

public Principal4(String nom, String ced, int edd)

{
this.nombre=nom;
this.cedula=ced;
this.edad=edd;
}

public int obtener_mayor(int ma,int var, String dat )

{
if(var>ma)
ma=var;
this.tera=dat;
return(ma);
}
public void obtener_nombre()
{
System.out.println("********_______********");
System.out.println("\nel nombre de la persona es
===>:"+nombre);
System.out.println("********_______********");
}
public void obtener_cedula()
{
System.out.println("********_______********");
System.out.println("\nla cedula de la persona es
===>:"+cedula);
System.out.println("********_______********");
}
public void obtener_edad()
{
System.out.println("********_______********");
System.out.println("\nla edad de la persona es
===>:"+edad);
System.out.println("********_______********");
}
public void imprime()
{
System.out.println("la persona de mayor edad es
===> "+tera);
}
}//fin Estudiante
5. Analice el siguiente código y modifíquelo para que
la clase Principal lea los datos de N Estudiantes (ojo:
ahora no son solo dos) y despliegue el nombre del que
tiene mayor edad. (Revise los apuntes de este curso
ya están en Synergeia)

class UsaPersona1 {

public static void main(String[] args) {

Persona [] esasper = new Persona [4]; //
arreglo de objetos
 esasper[0] = new Persona("Angel", 21);
esasper[1] = new Persona("Maria", 20);
esasper[2] = new Persona("Rosa", 25);
esasper[3] = new Persona("Pedro", 19);

Persona mayorper = esasper[0];

int mayor = mayorper.getEdad();

for (int i = 1; i < 4; i++) {

if(esasper[i].getEdad() > mayor ){
mayorper = esasper[i];
mayor = mayorper.getEdad();
}
}
System.out.println("Persona de mayor
edad...\n" );
System.out.println(mayorper.getNombre() +
", " + mayorper.getEdad() );
}
}
import java.io.*;
class AccesoPrincipal5
{
//Comprobacion de acceso Public por defaul

public static void main (String [] arg) throws

IOException
{
try{
int i,may=0;
int mayor;
InputStreamReader isr=new
InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.println("introduce la cantidad de
estudiantes que desea conocer: ");
String est=br.readLine();
int n=Integer.parseInt(est);
Principal5[] persona=new Principal5[n];
for(i=0;i<n;i++)
{
System.out.print("\n introduce el nombre de la
persona ["+(i+1)+"] : ");
String o=br.readLine();
System.out.print("\n introduce la cedula de la
persona ["+(i+1)+"] : ");
String c=br.readLine();
System.out.print("\n introduce la edad de la
persona ["+(i+1)+"] : ");
String e=br.readLine();
int num=Integer.parseInt(e) ;
persona[i]=new Principal5(o,c,num);
}
for(i=0;i<n;i++)
{
persona[i].obtener_nombre();
persona[i].obtener_edad();
persona[i].obtener_cedula();
}

Principal5 mayorper = persona[0];

mayor = mayorper.getedad();

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

if(persona[i].getedad() > mayor ){
mayorper = persona[i];
mayor = mayorper.getedad();
 }
}

}
System.out.println("\nPersona de mayor edad..." );
System.out.println(mayorper.getnombre() + ", " +
mayorper.getedad() );

catch(Exception e)
{
System.out.println("\nError en la captura de los
datos"+e);
}
}
}

class Principal5 {
String cedula;
String nombre;
int edad,tera;

public Principal5(String nom, String ced, int edd)

{
this.nombre=nom;
this.cedula=ced;
this.edad=edd;
}
public void obtener_nombre()
{
System.out.println("********_______********");
System.out.println("\nel nombre de la persona es
===>:"+nombre);
System.out.println("********_______********");
}
public void obtener_cedula()
{
System.out.println("********_______********");
System.out.println("\nla cedula de la persona es
===>:"+cedula);
System.out.println("********_______********");
}
public void obtener_edad()
{
System.out.println("********_______********");
System.out.println("\nla edad de la persona es
===>:"+edad);
System.out.println("********_______********");
}
public int getedad()
{
return(edad);
}
public String getnombre()
{
return(nombre);
}
}//fin Estudiante
6. En algunas oportunidades conviene tener una
variable cuyo valor sea el mismo para todos los
objetos que son creados. En estos casos se utiliza una
variable de clase que debe ser estática (static), la
cual está en un área de memoria común a todos los
objetos, en consecuencia, se mantiene el mismo valor
de la variable para todos los objetos de la clase. Por
ejemplo, asuma que quiere calcular la suma de las
edades, entonces, se puede crear una variable de
clase:
private static int suma;
Use el constructor para actualizar la suma de las
edades cada vez que se crea un Estudiante, adicione
un método que devuelva el valor de la suma y calcule
en Principal, la edad promedio de los estudiantes. ¿ya
tiene un método para desplegar el promedio? Toni
Piza, un estudiante de informática como ustedes, les
da algunas ideas en:
http://aprendiendojava.blogspot.com/2005/05/el-
modificador-static.html
import java.io.*;
class AccesoPrincipal6
{
//Comprobacion de acceso Public por defaul

public static void main (String [] arg) throws

IOException
{
try
{
int i,may=0,aux=0;
InputStreamReader isr=new
InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.print("\nIntroduzca la cantidad de
estudiantes que desea evaluar:");
String est=br.readLine();
int n=Integer.parseInt(est);
Principal6[] persona=new Principal6[n];
for(i=0;i<n;i++)
{
System.out.print("\n introduce el nombre de la
persona ["+(i+1)+"] :");
String o=br.readLine();
System.out.print("\n introduce la cedula de la
persona ["+(i+1)+"] :");
String c=br.readLine();
System.out.print("\n introduce la edad de la
persona ["+(i+1)+"] :");
String e=br.readLine();
int num=Integer.parseInt(e) ;
persona[i]=new Principal6(o,c,num);
}
for(i=0;i<n;i++)
{
System.out.println("\nDatos del estudiante
"+(i+1)+"");
persona[i].obtener_nombre();
persona[i].obtener_edad();
persona[i].obtener_cedula();
}

float prom=persona[0].devuelve_suma()/n;
persona[0].despliega_prom(prom);
}
catch(Exception e)
{
System.out.println("\nError en la captura de los
datos");
}
}
}
class Principal6 {
String cedula;
String nombre;
private static float suma=0;
int edad;
public Principal6(String nom, String ced, int edd)
{
this.nombre=nom;
this.cedula=ced;
this.edad=edd;
this.suma=this.suma+edd;
}
public void obtener_nombre()
{
System.out.println("********_______********");
System.out.println("\nel nombre de la persona es
===>:"+nombre);
System.out.println("********_______********");
}
public void obtener_cedula()
{
System.out.println("********_______********");
System.out.println("\nla cedula de la persona es
===>:"+cedula);
System.out.println("********_______********");
}
public void obtener_edad()
{
System.out.println("********_______********");
System.out.println("\nla edad de la persona es
===>:"+edad);
System.out.println("********_______********");
}
public float devuelve_suma()
{
return(suma);
}
public void despliega_prom(float pro)
{
System.out.println("\nEl promedio de las edades es
==> "+pro);
}
}
7. Con el modificador de acceso static hacemos que
la variable sea global a los objetos. ¿Podemos hacer lo
mismo con un método?. Para que un método pueda
ser declarado estático; (ver
http://www.leepoint.net/notes-
java/flow/methods/50static-methods.html)
a) no debe acceder a variables de la clase que no
sean estáticas (pero sí puede crear variables dentro de
su bloque de código)
b) sólo puede llamar a métodos estáticos.
En ese sentido, el método que usamos para conseguir
la suma (getSuma) cumple los requisitos, pues sólo
accede a suma, que es una variable estática. Esto nos
permitirá usar la sintaxis Estudiante.getSuma()
(Nótese que se usa la clase) para conseguir la suma
de las edades, sin hacer referencia a un objeto
específico. Haga los cambios necesarios y pruebe su
método estático getSuma.

import java.io.*;
class AccesoPrincipal7
{
//Comprobacion de acceso Public por defaul

public static void main (String [] arg) throws

IOException
{
try
{
int i,may=0,aux=0;
InputStreamReader isr=new
InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.print("\nIntroduzca la cantidad de
estudiantes que desea evaluar:");
String est=br.readLine();
int n=Integer.parseInt(est);
Principal7[] persona=new Principal7[n];
for(i=0;i<n;i++)
{
System.out.print("\n introduce el nombre de la
persona ["+(i+1)+"] : ");
String o=br.readLine();
System.out.print("\n introduce la cedula de la
persona ["+(i+1)+"] : ");
String c=br.readLine();
System.out.print("\n introduce la edad de la
persona ["+(i+1)+"] : ");
String e=br.readLine();
int num=Integer.parseInt(e) ;
persona[i]=new Principal7(o,c,num);
}
for(i=0;i<n;i++)
{
System.out.println("\nDatos del estudiante
"+(i+1)+"");
persona[i].obtener_nombre();
persona[i].obtener_edad();
persona[i].obtener_cedula();
}
Principal7.devuelve_suma();

}
catch(Exception e)
{
System.out.println("\nError en la captura de los
datos");
}
}
}

class Principal7
{
String nombre;
String cedula;
int edad;
private static float suma=0;

public Principal7 (String nomb,String cedu,int eda)

{
this.nombre=nomb;
this.cedula=cedu;
this.edad=eda;
this.suma=this.suma+edad;
}
public void obtener_nombre()
 {
System.out.println("********_______********");
System.out.println("\nel nombre de la persona es
===>:"+nombre);
System.out.println("********_______********");
}
public void obtener_cedula()
{
System.out.println("********_______********");
System.out.println("\nla cedula de la persona es
===>:"+cedula);
System.out.println("********_______********");
}
public void obtener_edad()
{
System.out.println("********_______********");
System.out.println("\nla edad de la persona es
===>:"+edad);
System.out.println("********_______********");
}
public static void devuelve_suma()
{
System.out.println("\nLa suma de las edades es ==>
"+suma);
}
}
 Conclusión
Este trabajo consto de una serie de problemas de los
cuales se creaban objetos en variables de instancias,
lo que fue la implementación de el flujo de datos se
destaco mas en ellos y por ende por esa parte esta
nueva implantación de programas se ve la sucesión de
lo que estamos haciendo referente al avance de la
programación orientada a objetos.
Lo que fue en si los programas me gusto lo que fue la
creación de objetos en las variables de instancia y
sobre todo el uso de los constructores.
Lo mas importante fue que cada problema llevaba al
problema siguiente y por ende se hacia la necesidad
de entender el problema anterior para así resolver el
que le seguía.