Java - Solución a un ejercicio en Java

   
Vista:

Solución a un ejercicio en Java

Publicado por Jack (2 intervenciones) el 18/12/2013 20:25:49
Hola amigos. Tengo un problema y es que no puedo solucionar este ejercicio de Java. ¿Alguien podría echarme una mano?:

Las tareas a realizar se centrarán en la creación de instancias de la clase Persona, la definición y utilización de métodos básicos tanto para Persona como para ES, y también el trabajo con constructores y parámetros.
Construye un proyecto usando el IDE NetBeans, en lenguaje Java, que defina la clase Persona, inicialmente tal y como se define a continuación:
public class Persona{
String nombre;
int edad;
float altura;
String ocupacion;
String telefono;

String getNombre(){
return this.nombre;
}

void setNombre(String nombre){
this.nombre=nombre;
}
}

Añade a la clase Persona del proyecto creado en el punto anterior los métodos consultores o de acceso (también llamados métodos get o simplemente getters) y métodos modificadores (también llamados métodos set o simplemente setters) que faltan para poder consultar y modificar el valor de todos los atributos de una persona. Para ello observa cómo se han creado los métodos del atributo nombre y determina los parámetros y resultado de los demás atributos.

Crea ahora un método constructor, sin parámetros, para la clase Persona , que cree una instancia de tipo Persona con los siguientes valores "por defecto" a sus atributos:

nombre <-- "Sin nombre"
edad <-- 0
altura <-- 0.0
ocupacion <-- "Sin determinar"
telefono <-- "000000000"
La idea es que sea una especie de "persona recién nacida", que existe, pero de la que aún no tenemos información.

Crea un nuevo constructor con parámetros para la clase Persona que inicialice los atributos del objeto con los valores que se le pasen como parámetros al invocar al constructor para crear un nuevo objeto, mediante el operador new. De momento aquí no tienes que crear el objeto ni usar new, sólo tienes que definir el método para que posteriormente eso sea posible.

Crea, dentro del mismo proyecto, una clase ES que usaremos para controlar la entrada y salida por consola (teclado y pantalla, en este caso). Se trata de que esta clase sirva como almacén de métodos útiles para realizar las operaciones de entrada salida, usando para la entrada la clase Scanner y sus métodos, encargándose de controlar los errores de entrada/salida que se pueden presentar mediante la captura y tratamiento de las excepciones que sean necesarias. En concreto, la clase ES debe contener:

Un método que permita introducir valores correctos de cada uno de los principales tipos básicos, de forma que si el valor introducido por teclado no se corresponde con el tipo esperado, se mande un mensaje de error al usuario, y se vuelva a solicitar el número, hasta que se introduzca un valor correcto. Eso implica la declaración de al menos los siguientes métodos:

leeEntero() para leer números int. Debe devolver, por tanto, un valor int válido.
leeEnteroLargo() para leer números long. Debe devolver, por tanto, un valor long válido.
leeReal() para leer números float. Debe devolver, por tanto, un valor float válido.
leeRealLargo() para leer números double. Debe devolver, por tanto, un valor double válido.

Un método leeRespuesta() para leer la respuesta a preguntas de respuesta Sí o No, del tipo "¿Desea continuar? (S/N): ". Debe devolver un carácter válido, pero sólo se aceptarán como válidos 'S', 's', 'N' y 'n'.

Un método leeCadena() que recoja un String leído desde teclado. Debe devolver por tanto el String leído.

Una versión adicional de cada uno de los métodos anteriores que permita pasarle como argumento un String con el mensaje que debe escribirse en pantalla solicitando al usuario el dato que el método va a leer. Por ejemplo, un método que pueda invocar como leeEntero("Introducir la edad de la persona: "); de forma que primero escribirá ese mensaje indicado como parámetro, luego esperará a que el usuario introduzca un número por teclado, comprobará si es un int válido, y si lo es, será lo que devolverá. Si no es válido, lo indicará con un mensaje de error, como antes, y volverá a solicitar la introducción del dato.

Una versión adicional para los métodos de lectura de números, que permita indicar como parámetro un valor mínimo aceptable, de forma que cualquier número introducido que sea menor que el mínimo, aunque sea un número correcto para ese tipo, sea descartado, indicando el motivo al usuario en un mensaje adecuado. Estos métodos permitirán también la introducción de un mensaje como parámetro para solicitar el dato.

Una versión adicional para los métodos de lectura de números, que permita indicar como parámetros tanto un valor mínimo como un valor máximo aceptables, de forma que cualquier número introducico que sea menor que el mínimo, o mayor que el máximo, aunque sea un número correcto para ese tipo, sea descartado, indicando el motivo al usuario en un mensaje adecuado. Estos métodos permitirán también la introducción de un mensaje como parámetro para solicitar el dato.

Un par de métodos equivalentes a System.out.print() y a System.out.println() que hagan exactamente lo mismo que hacen estos métodos, pero cuya escritura sea mucho más breve: ES.msg() y ES.msgln() serían respectivamente los nombres de estos nuevos métodos.

Crea una clase principal, que será la que usará las clases Persona y ES y sus métodos, con un método main() que ofrezca un menú como el siguiente:

Gestión de Personas.
================================
1.- Crear una nueva persona sin datos.
2.- Crear una nueva persona con datos conocidos.
3.- Asignar nombre a una persona.
4.- Asignar edad a una persona.
5.- Asignar altura a una persona.
6.- Mostrar por pantalla los datos de una persona.

0.- Salir de la aplicación.
================================
Introduzca la opción elegida:

Debes implementar la funcionalidad de cada una de las opciones del menú.

Para ello usaremos dos variables de tipo Persona, que llamaremos personaVacia y personaConDatos, usándose la primera para la opción 1 y la segunda para la opción 2.

Las opciones que asignan un valor (3 a 5) podrán hacerlo para cualquiera de las dos variables a tu elección, pero procura usar ambas variables entre esas opciones, que deben leer por teclado el valor a asignar, solicitándolo convenientemente al usuario, y asignarlo usando el método set correspondiente.

Estas opciones, antes de asignar el valor, comprobarán si el atributo tiene o no uno de los valores que se asignan por defecto a una persona vacía, y que aparecen en el punto 3 de la tarea. Si es así, escribirá sin más el nuevo valor. Sin embargo, si el atributo ya tenía cualquier otro valor distinto de los indicados por defecto, debe solicitar confirmación antes de sobreescribir el valor que había con el nuevo valor leído.

La opción de mostrar por pantalla los datos de una persona, lo hará mostrando uno a uno el valor de cada atributo recogido con el método get correspondiente, junto a un texto que indique de qué valor se trata.

Naturalmente, tras realizar cualquiera de las opciones de la 1 a la 6, el menú debe volverse a mostrar, permitiendo elegir una nueva opción, hasta que se introduzca la opción 0 para salir.
Incluye comentarios Javadoc para que sea posible generar de forma totalmente automática una documentación completa de las clases Persona y ES, incluyendo documentación completa de todos sus métodos.

Muchas gracias.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
-1
Responder
Imágen de perfil de OverDaRt

Solución a un ejercicio en Java

Publicado por OverDaRt (2 intervenciones) el 22/12/2013 21:36:12
En cuanto a la clase Persona tus constructores serían así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
private String nombre;
    private int edad;
    private float altura;
    private String ocupacion;
    private String telefono;
 
    //COnstructor sin parametros
    public Persona()
    {
        nombre="";
        edad=0;
        altura=0;
        ocupacion="Sin determinar";
        telefono="000000000";
 
    }
 
    //COnstructor con parametros
    public Persona(String nombre,int edad,float altura,String ocupacion,String telefono)
    {
        this.nombre=nombre;
        this.edad=edad;
        this.altura=altura;
        this.telefono=telefono;
        this.ocupacion=ocupacion;
    }
 
    String getNombre()
    {
        return this.nombre;
    }
 
    void setNombre(String nombre)
    {
        this.nombre=nombre;
    }


Faltan los get y sets de los demás paramétros, solo te pongo el de nombre y el método toString para imprimir la Persona por pantalla.

Respecto a la clase ES el método para leer un entero sería algo parecido a esto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class ES
{
    Scanner sc;
 
    public ES()
    {
        //Inicializa Scanner para leer de teclado
        sc= new Scanner(System.in);
 
    }
 
    /*Lee un entero de teclado y genera una excepción en caso de fallo como por 
    ejemplo introducir algo que no sean números, esta excepción se propaga al 
    método llamador, es decir que si usas en el Main leerEntero deberas capturar 
    con try catch en el main esta excepcion*/
    public int leeEntero() throws InputMismatchException
    {
         return sc.nextInt();
 
    }
}

EL menú lo puedes implementar con un DO WHile, no te he hecho todo el código por el mismo motivo que nadie te ha contestado aún , a programar se aprende PROGRAMANDO si esperas que te demos todo hecho no vas a aprender nada, investiga por tu cuenta si no sale algo, vuelve a investigar , a probar cosas a buscar ejemplos...
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Piercing

Solución a un ejercicio en Java

Publicado por Piercing (3 intervenciones) el 23/12/2013 15:17:20
Buenas tardes, pues yo estoy realizando la misma tarea, pero me he atascado en el punto donde hay que pasarle a los métodos constructores los parámetros recogidos por teclado para poder almacenarlos dependiendo del constructor al que se llame.
He creado la clase Persona con los métodos consultores:

1ª Parte

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/**
 *
 * @author carlos
 */
//punto 1
public class Persona {
    //estados o atributos de la calse
 
    private String nombre;
    private int edad;
    private float altura;
    private String ocupacion;
    private String telefono;
    //punto 3 | constructor vacio que no recibe ningún parámetro, inicializa las variables
    //con el mismo nombre de la clase, empezando por mayúsculas, y no retorna nada
    //con esto creamos una persona
 
    public Persona() {
        nombre = "Sin nombre";
        edad = 0;
        altura = (float) 0.0;
        ocupacion = "Sin determinar";
        telefono = "000000000";
    }
    //punto 4
 
    public Persona(String nombre, int edad, float altura, String ocupacion, String telefono) {
        this.nombre = nombre;
        this.edad = edad;
        this.altura = altura;
        this.ocupacion = ocupacion;
        this.telefono = telefono;
    }
 
    //consultar--> get
    public String getNombre() {
        return this.nombre;
    }
    //cambiar o modificar -->set
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    public int getEdad() {
        return this.edad;
    }
 
    public void setEdad(int edad) {
        this.edad = edad;
    }
 
    public float getAltura() {
        return this.altura;
    }
 
    public void setAltura(float altura) {
        this.altura = altura;
    }
 
    public String getOcupacion() {
        return this.ocupacion;
    }
 
    public void setOcupacion(String ocupacion) {
        this.ocupacion = ocupacion;
    }
 
    public String getTelefono() {
        return this.telefono;
    }
 
    public void setTelefono(String telefono) {
        this.telefono = telefono;
    }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Piercing

Solución a un ejercicio en Java

Publicado por Piercing (3 intervenciones) el 23/12/2013 15:19:38
2ª Parte:

A continuación he creado la claseES con los métodos que solicita el enunciado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
import java.util.InputMismatchException;
import java.util.Scanner;
 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author carlos
 */
public class ES {
 
    private static Scanner teclado = new Scanner(System.in);
 
    public static int leeEntero() {
        int entero = 0;
        boolean bien = false;
 
        do {
            try {
                entero = teclado.nextInt();
 
                bien = true;
            }
            catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero entero");
                System.out.println("Vuelva a introducir el valor: ");
            }
        } while (bien == false);
        return entero;
    }
 
    public static int leeEntero(String mensaje) {
        int entero = 0;
        boolean bien = false;
 
        do {
            try {
                System.out.println(mensaje);
                entero = teclado.nextInt();
                bien = true;
            } //si se produce una exception de tipos de datos
            catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero entero");
            }
        } while (bien == false);
        return entero;
    }
 
    public static int leeEntero(String mensaje, int min) {
        int entero = 0;
        boolean bien = false;
 
 
 
        do {
            try {
                System.out.println(mensaje);
                entero = teclado.nextInt();
                if (entero >= min) {
                    bien = true;
                } else {
                    System.out.println("Error, debe ser mayor o igual que " + min);
                    bien = false;
                }
            } //si se produce una exception de tipos de datos
            catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero entero");
            }
        } while (bien == false);
        return entero;
    }
 
    public static int leeEntero(String mensaje, int min, int max) {
        int entero = 0;
        boolean bien = false;
        min = 1;
        max = 120;
 
 
        do {
            try {
                System.out.println(mensaje);
                entero = teclado.nextInt();
                if (entero >= min && entero <= max) {
                    bien = true;
                } else {
                    System.out.println("Error, debe ser mayor o igual que " + min + " y menor o igual que " + max);
                    bien = false;
                }
            } //si se produce una exception de tipos de datos
            catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero entero");
            }
        } while (bien == false);
        return entero;
    }
 
    public static long leeEnteroLargo() {
        long enterolargo = 0;
        boolean bien = false;
 
        do {
            try {
                enterolargo = teclado.nextLong();
                bien = true;
            } catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero entero largo");
                System.out.println("Vuelva a introducir el valor: ");
            }
        } while (bien == false);
        return enterolargo;
 
    }
 
    public static long leeEnteroLargo(String mensaje) {
        long enterolargo = 0;
        boolean bien = false;
 
        do {
            try {
                System.out.println(mensaje);
                enterolargo = teclado.nextLong();
                bien = true;
            } catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero entero largo");
                System.out.println("Vuelva a introducir el valor: ");
            }
        } while (bien == false);
        return enterolargo;
 
    }
 
    public static long leeEnteroLargo(String mensaje, long min) {
        long enterolargo = 0;
        boolean bien = false;
 
 
        do {
            try {
                System.out.println(mensaje);
                enterolargo = teclado.nextLong();
                if (enterolargo >= min) {
                    bien = true;
                } else {
                    System.out.println("Error, debe ser mayor o igual que " + min);
                    bien = false;
                }
                bien = true;
            } catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero entero largo");
            }
        } while (bien == false);
        return enterolargo;
 
    }
 
    public static long leeEnteroLargo(String mensaje, long min, long max) {
        long enterolargo = 0;
        boolean bien = false;
 
 
        do {
            try {
                System.out.println(mensaje);
                enterolargo = teclado.nextLong();
                if (enterolargo >= min && enterolargo <= max) {
                    bien = true;
                } else {
                    System.out.println("Error, debe ser mayor o igual que " + min + " y menor o igual que " + max);
                    bien = false;
                }
                bien = true;
            } catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero entero largo");
            }
        } while (bien == false);
        return enterolargo;
 
    }
 
    public static float leeReal() {
        float real = 0;
        boolean bien = false;
 
        do {
            try {
                real = teclado.nextFloat();
                bien = true;
            } catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero real");
                System.out.println("Vuelva a introducir el valor: ");
            }
        } while (bien == false);
        return real;
    }
 
    public static float leeReal(String mensaje) {
        float real = 0;
        boolean bien = false;
 
        do {
            try {
                System.out.println(mensaje);
                real = teclado.nextFloat();
                bien = true;
            } catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero real");
            }
        } while (bien == false);
        return real;
 
    }
 
    public static float leeReal(String mensaje, float min) {
        float real = 0;
        boolean bien = false;
 
 
        do {
            try {
                System.out.println(mensaje);
                real = teclado.nextFloat();
                if (real >= min) {
                    bien = true;
                } else {
                    System.out.println("Error, debe ser mayor o igual que " + min);
                    bien = false;
                }
            } //si se produce una exception de tipos de datos
            catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero real");
            }
        } while (bien == false);
        return real;
    }
 
    public static float leeReal(String mensaje, float min, float max) {
        float real = 0;
        boolean bien = false;
 
 
        do {
            try {
                System.out.println(mensaje);
                real = teclado.nextFloat();
                if (real >= min && real <= max) {
                    bien = true;
                } else {
                    System.out.println("Error, debe ser mayor o igual que " + min + " y menor o igual que " + max);
                    bien = false;
                }
                bien = true;
            } catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero real");
            }
        } while (bien == false);
        return real;
    }
 
    public static double leeRealLargo() {
        double realargo = 0;
        boolean bien = false;
 
        do {
            try {
                realargo = teclado.nextDouble();
                bien = true;
            } catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero real largo");
                System.out.println("Vuelva a introducir el valor: ");
 
            }
        } while (bien == false);
        return realargo;
    }
 
    public static double leeRealLargo(String mensaje) {
        double realargo = 0;
        boolean bien = false;
 
        do {
            try {
                System.out.println(mensaje);
                realargo = teclado.nextDouble();
                bien = true;
            } catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero real largo");
            }
        } while (bien == false);
        return realargo;
    }
 
    public static double leeRealLargo(String mensaje, double min) {
        double realargo = 0;
        boolean bien = false;
        min = 100.5;
 
 
        do {
            try {
                System.out.println(mensaje);
                realargo = teclado.nextDouble();
                if (realargo >= min) {
                    bien = true;
                } else {
                    System.out.println("Error, debe ser mayor o igual que " + min);
                    bien = false;
                }
            } //si se produce una exception de tipos de datos
            catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero real largo");
            }
        } while (bien == false);
        return realargo;
    }
 
    public static double leeRealLargo(String mensaje, double min, double max) {
        double realargo = 0;
        boolean bien = false;
        min = 100.5;
        max = 1000.5;
 
        do {
            try {
                System.out.println(mensaje);
                realargo = teclado.nextDouble();
                if (realargo >= min && realargo <= max) {
                    bien = true;
                } else {
                    System.out.println("Error, debe ser mayor o igual que " + min + " y menor o igual que " + max);
                    bien = false;
                }
            } //si se produce una exception de tipos de datos
            catch (InputMismatchException e) {
                teclado.nextLine();
                bien = false;
                System.out.println("Tiene que ser un numero real largo");
            }
        } while (bien == false);
        return realargo;
    }
 
    public static char leeRespuesta() {
        char respuesta = ' ';
        String linea;
        boolean bien = false;
 
        do {
            try {
                linea = teclado.nextLine();
                linea = linea.toUpperCase();
                respuesta = linea.charAt(0);
                if (respuesta != 'S' && respuesta != 'N') {
                    bien = false;
                } else {
                    bien = true;
                }
            } catch (InputMismatchException e) {
                bien = false;
                System.out.println("Tiene que ser una S o una s o una n o una N");
 
            }
        } while (bien == false);
        return respuesta;
    }
 
    public static char leeRespuesta(String mensaje) {
        char respuesta = ' ';
        String linea;
        boolean bien = false;
 
        do {
            try {
                System.out.println(mensaje);
                linea = teclado.nextLine();
                linea = linea.toUpperCase();
                respuesta = linea.charAt(0);
                if (respuesta != 'S' && respuesta != 'N') {
                    bien = false;
                } else {
                    bien = true;
                }
            } catch (InputMismatchException e) {
                bien = false;
                System.out.println("Vuelva a introducir el valor: ");
            }
        } while (bien == false);
        return respuesta;
    }
 
    public static String leeCadena() {
        String linea = "";
        boolean bien = false;
 
        do {
            try {
                linea = teclado.nextLine();
                bien = true;
            } catch (InputMismatchException e) {
                bien = false;
                System.out.println("Tiene que ser una cadena de caracteres");
                System.out.println("Vuelva a introducir el valor: ");
 
            }
        } while (bien == false);
        return linea;
    }
 
    public static String leeCadena(String mensaje) {
        String linea = "";
        boolean bien = false;
 
        do {
            try {
                System.out.println(mensaje);
                linea = teclado.nextLine();
                bien = true;
            } catch (InputMismatchException e) {
                bien = false;
                System.out.println("Vuelva a introducir el valor: ");
            }
        } while (bien == false);
        return linea;
    }
 
    public static void msgln() {
        System.out.println();
    }
 
    public static void msgln(String cadena) {
        System.out.println(cadena);
    }
 
    public static void msg(String cadena) {
        System.out.print(cadena);
    }
 
    public static void msg() {
        System.out.println();
    }
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Piercing

Solución a un ejercicio en Java

Publicado por Piercing (3 intervenciones) el 23/12/2013 15:20:51
3º Parte

Y por último nuestra clase principal main, y es aquí donde tengo el atasco, que no se como construir el menú mediante el cual recogemos los datos del usuario para pasárselos a los métodos correspondientes y que estos a su vez nos devuelvan sus valores para cada uno de los apartados del menú Gestión de Personas, espero haberme explicado.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
import java.util.Scanner;
 
/**
 *
 * @author carlos
 */
public class Principal {
 
    private static Scanner sc = new Scanner(System.in);
 
    public static void main(String[] args) {
 
        int entero = 0;
        long elargo;
        float real = 0;
        double rlargo;
        String lrespuesta;
        String lcadena;
        int opcion;
        int minEntero = 0;
        int maxEntero = 100;
        float minReal = (float) 1.5;
        float maxReal = (float) 2.4;
 
        //instanciamos dos objetos de la clase Persona
        Persona personaConDatos = new Persona();
        Persona personaVacia = new Persona();
 
 
 
        ES.msgln("Gestión de Personas");
        ES.msgln("============================");
        ES.msgln("1.- Crear una nueva persona sin datos");
        ES.msgln("2.- Crear una nueva persona con datos conocidos");
        ES.msgln("3.- Asignar nombre a una persona");
        ES.msgln("4.- Asignar edad a una persona");
        ES.msgln("5.- Asignar altura a una persona");
        ES.msgln("6.- Asignar nombre a una persona");
        ES.msgln();
        ES.msgln("0.- Mostrar por pantalla los datos de una persona. ");
        ES.msgln("============================");
        ES.msg("Introduzca la opción elegida:  ");
 
 
 
        opcion = sc.nextInt();
        switch (opcion) {
            case 1:
                ES.msg("Introduzca el nombre: ");
                lcadena = sc.nextLine();
                ES.leeCadena(lcadena);
 
                personaVacia.setNombre(lcadena);
 
                /* ES.leeEntero("Introduzca la edad: ");
                
                personaVacia.setEdad(entero);
                
                ES.leeReal("Introduzca la altura: ", minReal, maxReal);
                real = sc.nextFloat();
                personaVacia.setAltura(real);
                
                ES.msgln("Introduzca ocupación: ");
                lcadena= sc.nextLine();
                ES.leeCadena(lcadena);
                personaVacia.setOcupacion(lcadena);
                
                ES.msgln("Introduzca el teléfono: ");
                lcadena= sc.nextLine();
                ES.leeCadena(lcadena);
                personaVacia.setTelefono(lcadena);
                
                 */
                ES.msgln("Quieres continuar?: S/N");
                lrespuesta = sc.nextLine();
                ES.leeRespuesta(lrespuesta);
                System.out.println("Datos de la persona " + personaVacia.getNombre() + personaVacia.getOcupacion()
                        + personaVacia.getTelefono() + personaVacia.getAltura() + personaVacia.getEdad());
 
 
 
                ;
                break;
 
 
            case 2:
                ;
                break;
            case 3:
                ;
                break;
            case 4:
                ;
                break;
            case 5:
                ;
                break;
            case 6:
                ;
                break;
            case 0:
                ;
                break;
 
 
        }
 
    }
}


Como veis lo tengo todo mangas por hombros y no se como meterle mano, alguna ayuda para poder seguir avanzando.
Gracias de antemano y Feliz Navidad !!!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Solución a un ejercicio en Java

Publicado por Jose (1 intervención) el 09/01/2014 17:50:30
Lo estás haciendo con algún IDE por ejemplo Netbeans? donde te marca el fallo?
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar