Taller de programación orientada a objetos;

Tercer capitulo

Presentado por

Laura solanggi Caicedo varón 20172005010

Michael Steven López 20172005147

Presentado a:

 Julio cortes Trujillo

Universidad distrital francisco José de caldas

Facultad: ingeniería

Proyecto curricular: ingeniería electrónica

Bogotá d.c.

2018
 3.2 Conteste con verdadero o falso a cada una de las siguientes
proposiciones; en caso de ser falso, explique por qué.

a) Por convención, los nombres de los métodos empiezan con la

primera letra en mayúscula y todas las palabras subsiguientes en el
nombre empiezan con la primera letra en mayúscula.

Falso. Por convención, los nombres de los métodos empiezan

con una primera letra en minúscula y todas las palabras
subsiguientes en el nombre empiezan con una letra en mayúscula.
b) Una declaración import no es obligatoria cuando una clase en un
paquete utiliza a otra clase en el mismo paquete.
verdadero.
c) Los paréntesis vacíos que van después del nombre de un método en
la declaración del mismo indican que éste no requiere parámetros
para realizar su tarea.
verdadero.
d) Una variable de tipo primitivo puede usarse para invocar un
método.
Falso. Una variable de tipo primitivo no puede usarse
para invocar a un método; se requiere una referencia a un
objeto para invocar a los métodos de ese objeto.
e) Las variables que se declaran en el cuerpo de un método
específico se conocen como variables de instancia, y pueden
utilizarse en todos los métodos de la clase.
 Falso. Dichas variables se llaman variables locales,
y sólo se pueden utilizar en el método en el que están declaradas.
f) El cuerpo de cada método está delimitado por llaves izquierda y
derecha ({ y }).
 verdadero.
g) Las variables locales de tipo primitivo se inicializan de manera
predeterminada.
 Falso. Las variables de instancia de tipo primitivo
se inicializan de manera predeterminada. A cada variable local se
le debe asignar un valor de manera explícita.
h) Las variables de instancia de tipo por referencia se inicializan
de manera predeterminada con el valor null.
  verdadero
i) Cualquier clase que contenga public static void main(String[]
args) puede usarse para ejecutar una aplicación.
 verdadero
j) El número de argumentos en la llamada a un método debe coincidir
con el número de parámetros en la lista de parámetros de la
declaración del método.
 verdadero
k) Los valores de punto flotante que aparecen en código fuente se
conocen como literales de punto flotante, y son de tipo float de
manera predeterminada.
 Falso. Dichas literales son de tipo double de manera
predeterminada.
 3.4 Explique el propósito de un parámetro de un método. ¿Cuál es la
diferencia entre un par ámetro y un argumento?
Un parámetro representa la información adicional que
requiere un método para realizar su tarea. Cada pará- metro
requerido por un método está especificado en la declaración del
método. Un argumento es el valor actual para un parámetro del
método. Cuando se llama a un método, los valores de los argumentos
se pasan a los parámetros correspondientes del método, para que
éste pueda realizar su tarea.
 3.6 (Constructores predeterminados) ¿Qué es un constructor
predeterminado? ¿Cómo se inicializan las variables de instancia de
un objeto, si una clase s ólo tiene un constructor predeterminado?

Los paréntesis a la derecha del objeto son obligatorios, esos

paréntesis en combinación con el nombre de una clase representan
una llamada a un constructor, que e s similar a un método, pero se
utiliza sólo cuando se crea un objeto, para inicializar los datos
de éste. Cada clase que usted declare puede proporcionar un
constructor, el cual puede utilizarse para inicializar un objeto de
una clase al momento de crear ese objeto. De hecho, Java requiere
una llamada al constructor para cada objeto que se crea. La palabra
clave new llama al constructor de la clase para realizar la
inicialización.
La llamada al constructor se indica mediante el nombre de la clase,
seguido de paréntesis; el constructor debe tener el mismo nombre
que la clase. Cuando una clase sólo tiene el constructor
predeterminado, sus variables de instancia se inicializan con sus
valores predeterminados. Las variables de los tiposchar, byte,
short, int, long, float y double se inicializan con 0, las
variables de tipo boolean se inicializan confalse, y las variables
de tipo por referencia se inicializan con null.
Un constructor es un método especial de una clase que se llama
automáticamente siempre que se declara un objeto de esa clase.
La principal misión del constructor es reservar memoria e inicial
izar las variables miembros de la clase.

Si para una clase no se define ningún método constructor se crea

uno automáticamente por defecto. El constructor por defecto es un
constructor sin parámetros que no hace nada. Los atributos del
objeto son iniciados con los valores predeterminados por el
sistema.
Este tipo de constructor se lo llama como constructor no-args, ya
que no recibe pa rámetros.

Constructor Java copia

Es un constructor que recibe por parámetro un objeto del mismo tipo
de la clase, asignando atributo por atributo al nuevo objeto
generado.
 3.8 (Uso de clases sin importarlas) La mayoría de las clases
necesitan importarse antes de poder ser usadas en una aplicación
¿Por qué cualquier aplicaci ón puede utilizar las clases System y
String sin tener que importarlas primero?
La mayoría de las clases que utilizará en los programas
de Java deben importarse. Las clases System y String están en el
paquete java.lang, que se importa de manera implícita en todo
programa de Java, por lo que todos los programas pueden usar las
clases del paquete java.lang sin tener que importarlas de manera
explícita.
 3.10 Explique por qué una clase podría proporcionar un método
establecer y un método obtener para una variable de instancia.
El método establecer, almacena el nombre de un curso en
un objeto. El método obtener, obtiene el nombre del curso de un
objeto.
 3.12 (La clase Factura) Cree una clase llamada Factura que una
ferretería podría utilizar para representar una factura para un
artículo vendido en la tienda. Una Factura debe incluir cuatro
piezas de información como variables de instancia: un número de
pieza (tipo String), la descripción de la pieza (tipo String), la
cantidad de artículos de ese tipo que se van a comprar (tipo int) y
el precio por artículo (double). Su clase debe tener un constructor
que inicialice las cuatro variables de instancia. Proporcione un
método establecer y un método obtener para cada variable de
instancia. Además, proporcione un método llamado
obtenerMontoFactura, que calcule el monto de la factura (es decir,
que multiplique la cantidad de artículos por el precio de cada uno)
 y después devuelva ese monto como un valor double. Si la cantidad
no es positiva, debe establecerse en 0. Si el precio por artículo
no es positivo, debe establecerse en 0.0. Escriba una apli cación de
prueba llamada PruebaFactura, que demuestre las capacidades de la
clase Factura.

1. Factura
2. {
3.  // Variables de instancia 
4. String numDePieza; // Número de la pieza 
5. String descPieza; // Descripción de la pieza 
6. qtyArticulo; // Cantidad del artículo 
7. vlrArticulo; // Valor del artículo 
8.
9.  // Constructur personalizado 
10. Factura( String pNumDePieza , String pDescPieza , pQtyArticulo
, pVlrArticulo )
11. {
12.  // Asignación de los valores de los parámetros a las vars. de inst.
13. numDePieza = pNumDePieza;
14. descPieza = pDescPieza;
15. ( pQtyArticulo > 0 )
16. {
17. qtyArticulo = pQtyArticulo;
18. }
19. ( pVlrArticulo > 0.0 )
20. {
21. vlrArticulo = pVlrArticulo;
22. }
23. } // Fin del constructor de la clase 
24.
25.  // Método establecer para número de la pieza 
26. establecerNumDePieza( String pNumDePieza )
27. {
28. numDePieza = pNumDePieza;
29. }
30.
31.  // Método obtener para número de la pieza 
32. String obtenerNumDePieza()
33. {
34. numDePieza;
35. }
36.
37.  // Método para establecer la descripción de la pieza 
38. establecerDescPieza( String pDescPieza )
39. {
40. descPieza = pDescPieza;
41. }
42.
43.  // Método para obtener la descripción de la pieza 
44. String obtenerDescPieza()
45. {
46. descPieza;
47. }
48.
49.  // Método para establecer la cantidad de artículo 
50. establecerQtyArticulo( pQtyArticulo )
51. {
52. qtyArticulo = pQtyArticulo;
53. }
54.
55.  // Método para obtener la cantidad de artículo 
56. obtenerQtyArticulo()
57. {
58. qtyArticulo;
59. }
60.
61.  // Método para establecer valor del artículo 
62. establecerVlrArticulo( pVlrArticulo )
63. {
64. vlrArticulo = pVlrArticulo;
65. }
66.
67.  // Método para obtener el valor del artículo 
68. obtenerVlrArticulo()
69. {
70. vlrArticulo;
71. }
72.
73.  // Método Obtener Monto Factura 
74. obtenerMontoFactura()
75. {
76.  // Comprobación de que no hayan cantidad negativas 
77. ( obtenerQtyArticulo() < 0 )
78. {
79. qtyArticulo = 0;
80. }
81.
82. ( obtenerVlrArticulo() < 0.0 )
83. {
84. vlrArticulo = 0.0;
85. }
86.
87. System.out.printf( " ********** FERRETER Í A **********" );
88. System.out.printf( " ***** Factura ***** " );
89. System.out.printf( "Número de pieza: %s" , obtenerNumDePieza() );
90. System.out.printf( " Descripción de la pieza: %s" ,
obtenerDescPieza() );
91. System.out.printf( " Cantidad del artículo: %d" ,
obtenerQtyArticulo() );
92. System.out.printf( " Valor unitario del artículo: %f" ,
obtenerVlrArticulo() );
93.
94.  //Totalizar el monto de la compra 
95. System.out.printf( " El total a pagar es:
%f" , ( obtenerQtyArticulo() *obtenerVlrArticulo() ) );
96. } // fin de main 
97.} ///:~ 
controladora 
import java.util.Scanner;

public class PruebaFactura

{
// El método main inicia y finaliza la ejecución de la
aplicación
public static void main( String args[] )
{
// Variables
String cadena; // Número y descripción de la pieza
int cantidad; // Cantidad del artículo
double valor; // Valor del artículo

// Constructor personalizado. Creación de un objeto

inicializando sus
// variables de instancia
Factura factura = new Factura( "0" , "Ninguna" , 0 , 0.0 );

// Mostrar el estado actual de los atributos del objeto

'factura'
 System.out.printf( "\ nNúmero de pieza: %s" ,
factura.obtenerNumDePieza() );
System.out.printf( "\ nDescripción de la pieza: %s" ,
factura.obtenerDescPieza() );
System.out.printf( "\ nCantidad del artículo: %d" ,
factura.obtenerQtyArticulo() );
System.out.printf( "\ nValor unitario del artículo: %f" ,
factura.obtenerVlrArticulo() );

// Solicitud y obtención de los datos

// Creación de un objeto de tipo 'Scanner'
Scanner entrada = new Scanner( System.in );

// Número de pieza
System.out.print( "\ nEscriba el número de pieza: " );
cadena = entrada.nextLine();
factura.establecerNumDePieza( cadena );

//Descripción de la pieza
System.out.print( "\ nEscriba la descripción de la pieza: "
);
cadena = entrada.nextLine();
factura.establecerDescPieza( cadena );

// Cantidad del artículo

System.out.print( "\ nEscriba la cantidad del artículo: " );
cantidad = entrada.nextInt();
factura.establecerQtyArticulo( cantidad );

// Valor del artículo

System.out.print( "\ nEscriba el valor del artículo: " );
valor = entrada.nextDouble();
factura.establecerVlrArticulo( valor );

// Mostrar el monto de la factura

factura.obtenerMontoFactura();
 System.out.println();
System.out.println();

} // fin de main
} ///:~

 3.14 (La clase Fecha) Cree una clase llamada Fecha, que incluya
tres variables de instancia: un mes (tipo int), un día (tipo int) y
un año (tipo int). Su clase debe tener un constructor que
inicialice las tres variables de instancia, y debe asumir que los
valores que se proporcionan son correctos. Proporcione un método
establecer y un método obtener para cada variable de instancia.
Proporcione un método mostrarFecha, que muestre el mes, día y año,
separados por barras diagonales (/). Escriba una aplicaci ón de
prueba llamada PruebaFecha, que demuestre las capacidades de la
clase Fecha.

1. Fecha
2. {
3.  // Variables de instancia (o piezas de información)
4. dia; // Día del a ño (formato num é 
rico)
5. mes; // Mes del a 
ño (formato num 
ér ico)
6. annio; // Mes del a 
ño 

7.
8.  // Constructor para inicializar las variables de instancia 
9. Fecha( pMes , pDia , pAnnio )
10. {
11.  // Validación para el mes 
12. ( pMes > 0 )
13. {
14. ( pMes <= 12 )
15. {
16. mes = pMes;
17. }
18. }
19.
20.  // Validación para el día 
21. ( pDia > 0 )
22. {
23. ( pDia <= 31 )
24. {
25. dia = pDia;
26. }
27. }
28.
29.  // Validacion para el annio 
30. ( pAnnio >= 1929 )
31. {
32. ( pAnnio <= 2029 )
33. {
34. annio = pAnnio;
35. }
36. }
37. } // Fin del constructor 
38.
39.  // Método para establecer el mes 
40. establecerMes( pMes )
41. {
42. ( pMes > 0 )
43. {
44. ( pMes <=31 )
45. {
46. mes = pMes;
47. }
48. }
49. }
50.
51.  // Método para obtener el mes 
52. obtenerMes()
53. {
54. mes;
55. }
56.
57.  // Método para establecer el día 
58. establecerDia( pDia )
59. {
60. ( pDia > 0)
61. {
62. ( pDia <= 31 )
63. {
64. dia = pDia;
65. }
66. }
67. }
68.
69.  // Método para obtener el día 
70. obtenerDia()
71. {
72. dia;
73. }
74.
75.  // Método para establecer el a ño 
76. establecerAnnio( pAnnio )
77. {
78. ( pAnnio >= 1929 )
79. {
80. ( pAnnio <= 2029 )
81. {
82. annio = pAnnio;
83. }
84. }
85. }
86.
87.  // Método para obtener el a ño 
88. obtenerAnnio()
89. {
90. annio;
91. }
92.
93.  // Método para mostrar la fecha en formato mm / dd / aaaa 
94. mostrarFecha()
95. {
96. System.out.print( " Fecha seleccionada: " );
97. System.out.printf( " %d / %d / %d " , obtenerMes() , obtenerDia() ,
obtenerAnnio() );
98. } // fin del método mostrarFecha 
99.}
controladora

 3.16 (Calculadora de la frecuencia cardiaca esperada) Mientras se

ejercita, puede usar un monitor de frecuencia cardiaca para ver que
su corazón permanezca dentro de un rango seguro sugerido por sus
entrenadores y doctores. De acuerdo con la Asociación
Estadounidense del Corazón (AHA) (www.americanheart.org/presenter.
jhtml?identifier=4736), la fórmula para calcular su frecuencia
cardiaca máxima en pulsos por minuto es 220 menos su edad en años.
Su frecuencia cardiaca esperada tiene un rango que est á entre el 50
y el 85% de su frecuencia cardiaca máxima. [Nota: estas fórmulas
son estimaciones proporcionadas por la AHA. Las frecuencias
cardiacas máxima y esperada pueden variar con base en la salud,
condición física y sexo del individuo. Siempre debe consultar un
médico o a un profesional de la salud antes de empezar o modificar
un programa de ejercicios]. Cree una clase llamada
FrecuenciasCardiacas. Los atributos de la clase deben incluir el
primer nombre de la persona, su apellido y fecha de nacimiento (la
cual debe consistir de atributos independientes para el mes, día y
 año de nacimiento). Su clase debe tener un constructor que reciba
estos datos como par ámetros. Para cada atributo debe proveer
métodos establecer y obtener. La clase tambi én debe incluir un
método que calcule y devuelva la edad de la persona (en años), un
método que calcule y devuelva la frecuencia cardiaca m áxima de esa
persona, y otro m étodo que calcule y devuelva la frecuencia
cardiaca esperada de la persona. Escriba una aplicaci ón de Java que
pida la información de la persona, cree una instancia de un objeto
de la clase FrecuenciasCardiacas e imprima la información a partir
de ese objeto (incluyendo el primer nombre de la persona, su
apellido y fecha de nacimiento), y que después calcule e imprima la
edad de la persona en (a ños), frecuencia cardiaca m áxima y rango de
frecuencia cardiaca esperada.


public class FrecuenciaCardiaca

{
// Variables de instancia
private int edad;
private String nombreCompleto;

// Constructores
public FrecuenciaCardiaca(String nombre, int edad) {
this.nombreCompleto = nombre;
this.edad = edad;
}

public void mostrarDatos() {

// Calcular frecuencias
int fmax = 220 - this.edad;
double fesp_inicio = fmax * 0.5;
double fesp_fin = fmax * 0.85;

// Imprimir
 System.out.println("Nombre: " + this.nombreCompleto);
System.out.println("Frecuencia cardiaca máxima: " +
fmax );
String fesp = "Frecuencia cardiaca esperada (rango): [
";
fesp += fesp_inicio + "-" + fesp_fin + " ]";
System.out.println( fesp );
}

// Getters & Setters

public int getEdad() {
return this.edad;
}

public String getNombreCompleto() {

return this.nombreCompleto;
}

public void setEdad(int edad) {

this.edad = edad;
}

public void setNombreCompleto(String nombreCompleto) {

this.nombreCompleto = nombreCompleto;
}
}
¿Cuál es el prop ósito de la palabra clave new?
Explique lo que ocurre cuando se utiliza en una aplicación.
La instruccion especifica para crear un Objeto en Java es la palabra
clave . La palabra clave  comienza una expresion del creacion de
instancia de una clase , la cual crea un objeto del tipo especificado a la
derecha del . El proceso de crear nuevos objetos se conoce tambien
como crear una instancia de , o instanciar un objeto . El valor entre
parentisis despues del tipo de expresion de creacion de instancia de una
clase se utiliza para inicializar ( es decir, dar un valor a) el nuevo
objeto.
(  Explique el propósito de una variable de
instancia.
Una variable de instancia es un campo declarado dentro de la
declaraci ón de una clase sin usar la palabra reservada static. Si una
clase T tiene un campo a que es una variable de instancia, entonces una
nueva variable de instancia a es creada e inicializada a un valor por
defecto como parde de cada nuevo objeto creado de la clase T o de
cualquier clase que sea subclase de T La bariable de instancia deja de
existir cuando el objeto del cual es campo deja de ser referenciado,
después que cualquier finalizaci ón necesaria del objeto ha sido
completada
Explique cómo podría un programa
utilizar la clase Scanner sin importarla.
La mayoría de las clases que utilizará en los programas de Java deben
importarse de manera explícita. Hay una relación
especial entre las clases que se compilan en el mismo directorio. De
manera predeterminada, se considera
que dichas clases se encuentran en el mismo paquete; a éste se le conoce
como el paquete predeterminado. Las
clases en el mismo paquete se importan implícitamente en los archivos de
código fuente de las demás clases del
mismo paquete. No se requiere una declaración import cuando una clase en
un paquete usa otra clase en el mismo
paquete.

Modifique la clase Cuenta (figura 3.8) para

proporcionar un método llamado
retirar, que retire dinero de un objeto Cuenta. Asegúrese de que el monto
a retirar no exceda el saldo de Cuenta. Si
lo hace, el saldo debe permanecer sin cambio y el método debe imprimir un
mensaje que indique “El monto a retirar
excede el saldo de la cuenta ”. Modifique la clase PruebaCuenta (figura
3.9) para probar el método retirar.
import java.util.Scanner;

public class PruebaCuenta

{
public static void main(String[] args)
 {
Cuenta cuenta1 = new Cuenta("Jane Green", 50.00); Cuenta cuenta2 = new
Cuenta("John Blue", -7.53);

cuenta1.obtenerNombre(), cuenta1.obtenerSaldo());
System.out.printf("Saldo de %s: $%.2f%n%n",
cuenta2.obtenerNombre(), cuenta2.obtenerSaldo());

Scanner entrada = new Scanner(System.in);

System.out.print("Escriba el monto a depositar para cuenta1: "); //

indicador (promt)
double montoDeposito = entrada.nextDouble(); // obtiene entrada del
usuario
System.out.printf("%nsumando %.2f al saldo de cuenta1%n%n",
montoDeposito);
cuenta1.depositar(montoDeposito); // suma al saldo de cuenta1

if (cuenta2.obtenerSaldo() < cuenta1.depositar(montoDeposito) ){

System.out.printf("Saldo de %s: $%.2f%n",

cuenta1.obtenerNombre(), cuenta1.obtenerSaldo());
System.out.printf("Saldo de %s: $%.2f%n%n",
cuenta2.obtenerNombre(), cuenta2.obtenerSaldo());

System.out.print("Escriba el monto a depositar para cuenta2: ");

montoDeposito = entrada.nextDouble(); // obtiene entrada del usuario
System.out.printf("%nsumando %.2f al saldo de cuenta2%n%n",
montoDeposito);
cuenta2.depositar(montoDeposito); // suma al saldo de cuenta2

System.out.printf("Saldo de %s: $%.2f%n",

cuenta1.obtenerNombre(), cuenta1.obtenerSaldo());
System.out.printf("Saldo de %s: $%.2f%n%n", cuenta2.obtenerNombre(),
cuenta2.obtenerSaldo());
}
else {
System.out.printf("Saldo insuficiente %s: $%.2f%n%n",
cuenta2.obtenerSaldo());
}
}
}

Cree una clase llamada Empleado, que incluya tres

variables de instancia: un primer
nombre (tipo String), un apellido paterno (tipo String) y un salario
mensual (double). Su clase debe tener un constructor
que inicialice las tres variables de instancia. Proporcione un
método establecer y un método obtener para cada
variable de instancia. Si el salario mensual no es positivo, no
establezca su valor. Escriba una aplicación de prueba
llamada PruebaEmpleado, que demuestre las capacidades de la
clase Empleado. Cree dos objetos Empleado y muestre el
salario anual de cada objeto. Después, proporcione a cada Empleado un
aumento del 10% y muestre el salario anual
de cada Empleado otra vez.

package coo1;
import java.util.Scanner;
public class empleado {public class Empleado
{

String nombre;
String apellido;
double salarioMensual;

public Empleado( String pNombre , String pApellido , double

SalarioMensual )
{

nombre = pNombre;
apellido = pApellido;
if( SalarioMensual < 0.0 )
{
salarioMensual = SalarioMensual;
}
}

public void establecerNombre( String pNombre )

{
nombre = pNombre;
}

public String obtenerNombre()

{
return nombre;
}

public void establecerApellido( String pApellido )

{
apellido = pApellido;
}

public String obtenerApellido()

{
return apellido;
}

public void establecerSalarioMensual( double salario )

{
if( salario < 0.0 )
{
System.out.print( "\nEl salario escrito no es v álido." );
return;
}
salarioMensual = salario;
}

public double obtenerSalarioMensual()

{
return salarioMensual;
}

public double obtenerSalarioAnual()

{
 return obtenerSalarioMensual() * 12;
}

public double obtenerAumento()

{
return obtenerSalarioAnual() * 1.10;
}

public void mostrarResumen()

{
System.out.printf( "\nSu nombre es: %s" , obtenerNombre() );
System.out.printf( "\nSu apellido es: %s" , obtenerApellido() );
System.out.printf( "\nSu salario mensual es: %f" ,
obtenerSalarioMensual() );
System.out.printf( "\nSu salario anual sin incremento es: %f" ,
obtenerSalarioAnual() );
System.out.printf( "\nSu salario anual con incremento es: %f" ,
obtenerAumento() );
}
}

import java.util.Scanner;

public class PruebaEmpleado

{

public static void main( String args[] )

{

String nombre;
String apellido;
double salario;
String empleado1;

Empleado empleado1 = new Empleado( "Zhen" , "Gholz" , 800 );

Empleado empleado2 = new Empleado( "Larz" , "Binz" , -900 );
 Scanner entrada = new Scanner( System.in );

System.out.print( "\ nSolicitud y recepción de los datos del empleado1"

);

System.out.print( "\nEscriba su nombre: " );

nombre = entrada.nextLine();
empleado1.establecerNombre( nombre );

System.out.print( "\nEscriba su apellido: " );

apellido = entrada.nextLine();
empleado1.establecerApellido( apellido );

System.out.print( "\nEscriba su salario mensual: " );

salario = entrada.nextDouble();
empleado1.establecerSalarioMensual( salario );

System.out.print( "\nResumen para empleado1: " );

empleado1.mostrarResumen();

System.out.println( "\n\nSolicitud y recepci ón de los datos del

empleado2" );

System.out.print( "\nEscriba su nombre: " );

nombre = entrada.nextLine();
empleado2.establecerNombre( nombre );

System.out.print( "\nEscriba su apellido: " );

apellido = entrada.nextLine();
empleado2.establecerApellido( apellido );

System.out.print( "\nEscriba su salario mensual: " );

salario = entrada.nextDouble();
empleado2.establecerSalarioMensual( salario );
 System.out.print( "\nResumen para empleado2: " );
empleado2.mostrarResumen();

System.out.println();
}
}

En la
clase PruebaCuenta de la figura 3.9, el método main
contiene seis instrucciones (líneas 13-14, 15-16, 28-29, 30-31, 40-41 y
42-43), cada una de las cuales muestra en
pantalla el nombre y saldo de un objeto Cuenta. Estudie estas instrucciones
y notará que difieren sólo en el objeto
Cuenta que se está manipulando: cuenta1 o cuenta2. En este ejercicio
definirá un nuevo método mostrarCuenta que
contiene una copia de esa instrucción de salida. El parámetro del método
será un objeto Cuenta y el método imprimirá
en pantalla el nombre y saldo de ese objeto. Después usted sustituirá las
seis instrucciones duplicadas en main con
llamadas a mostrarCuenta, pasando como argumento el
objeto Cuenta específico a mostrar en pantalla.
Modifique la clase PruebaCuenta de la figura 3.9 para declarar el
siguiente método mostrarCuenta después de
la llave derecha de cierre de main y antes de la llave derecha de cierre de
la clase PruebaCuenta:
public static void mostrarCuenta(Cuenta cuentaAMostrar)
{
}
Sustituya el comentario en el cuerpo del método con una instrucción que
muestre el nombre y el saldo de
cuentaAMostrar.
Recuerde que main es un método static, por lo que puede llamarse sin tener
que crear primero un objeto de
la clase en la que se declara main. También declaramos el
método mostrarCuenta como un método static. Cuando
main necesita llamar a otro método en la misma clase sin tener que crear
primero un objeto de esa clase, el otro método
también debe declararse como static.
Una vez que complete la declaración de mostrarCuenta, modifique main para
reemplazar las instrucciones que
muestran el nombre y saldo de cada Cuenta con llamadas a mostrarCuenta; cada
una debe recibir como argumento el
objeto cuenta1 o cuenta2, según sea apropiado. Luego, pruebe la
clase PruebaCuenta actualizada para asegurarse de
que produzca la misma salida que se muestra en la figura 3.9.
1 // Fig. 3.9: PruebaCuenta.java
2 // Entrada y salida de números de punto flotante con objetos Cuenta.
3 import java.util.Scanner;
4
5 public class PruebaCuenta
6 {
7 public static void main(String[] args)
8 {
9 Cuenta cuenta1 = new Cuenta(“Jane Green”, 50.00);
10 Cuenta cuenta2 = new Cuenta(“John Blue”, -7.53);
11
12 // muestra el saldo inicial de cada objeto
13 System.out.printf(“Saldo de %s: $%.2f%n”,
14 cuenta1.obtenerNombre(), cuenta1.obtenerSaldo());
15 System.out.printf(“Saldo de %s: $%.2f%n%n”,
16 cuenta2.obtenerNombre(), cuenta2.obtenerSaldo());
17
18 // crea un objeto Scanner para obtener la entrada de la ventana de
comandos
19 Scanner entrada = new Scanner(System.in);
20
21 System.out.print(“Escriba el monto a depositar para cuenta1: “); //
indicador (promt)
22 double montoDeposito = entrada.nextDouble(); // obtiene entrada del
usuario
23 System.out.printf(“%nsumando %.2f al saldo de cuenta1%n%n”,
24 montoDeposito);
25 cuenta1.depositar(montoDeposito); // suma al saldo de cuenta1
26
27 // muestra los saldos
28 System.out.printf(“Saldo de %s: $%.2f%n”,
29 cuenta1.obtenerNombre(), cuenta1.obtenerSaldo());
30 System.out.printf(“Saldo de %s: $%.2f%n%n”,
31 cuenta2.obtenerNombre(), cuenta2.obtenerSaldo());
32
33 System.out.print(“Escriba el monto a depositar para cuenta2: “); //
indicador (promt)
34 montoDeposito = entrada.nextDouble(); // obtiene entrada del usuario
35 System.out.printf(“%nsumando %.2f al saldo de cuenta2%n%n”,
36 montoDeposito);
37 cuenta2.depositar(montoDeposito); // suma al saldo de cuenta2
38
39 // muestra los saldos
40 System.out.printf(“Saldo de %s: $%.2f%n”,
41 cuenta1.obtenerNombre(), cuenta1.obtenerSaldo());
42 System.out.printf(“Saldo de %s: $%.2f%n%n”,
43 cuenta2.obtenerNombre(), cuenta2.obtenerSaldo());
44 } // fin de main
45 } // fin de la clase PruebaCuenta