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.

R//: 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.
R//: 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.
R//: verdadero.
d) Una variable de tipo primitivo puede usarse para invocar un
método.
R//: 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.
R//: 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 }).
R//: verdadero.
g) Las variables locales de tipo primitivo se inicializan de manera
predeterminada.
R//: 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.
 R//: verdadero
i) Cualquier clase que contenga public static void main(String[]
args) puede usarse para ejecutar una aplicación.
R//: 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.
R//: 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.
R//: 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?
R//: 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?
R//:
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 es 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.
Constructor Java por defecto
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 pará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?
R//: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.
R//: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
no es positiva, debe establecerse
no es positivo, debe establecerse
prueba llamada PruebaFactura, que
clase Factura.
R//:
un valor double. Si la cantidad
en 0. Si el precio por artículo
en 0.0. Escriba una aplicación de
demuestre las capacidades de la

1. public class Factura

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

1. public class Fecha

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

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;
}
}
3.5 (Palabra clave new) ¿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 new. La palabra clave new comienza una expresion del creacion de
instancia de una clase, la cual crea un objeto del tipo especificado a la
derecha del new. 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.
3.7 (Variables de instancia) 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
3.9 (Uso de una clase sin importarla) 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.

3.11 (Clase Cuenta modificada) 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());
}
}
}

3.13 (La clase Empleado) 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();
}
}

3.15 (Eliminar código duplicado en el método main) 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