Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Buenas!

En el ejercicio de este capitulo, se trata de contestar preguntas. El enunciado es el siguiente:

Crea un objeto de tipo Combinador y prueba a ejecutar los dos métodos disponibles pasando distintos parámetros: cadenas con más de tres caracteres, una cadena con más de tres y otra con menos de tres y ambas con menos de tres caracteres. Fíjate en el resultado que ofrece el método CombinadoSiempre cuando se le pasan como parámetros dos cadenas vacías. ¿Te parece lógico el resultado?
En la clase tenemos definidos dos atributos o campos. ¿Tienen utilidad conocida a la vista del código de la clase? ¿Se usan en los métodos que tenemos definidos?

Bueno. . . aquí vamos:

package Combinacion;

public class Fusion {
    public Fusion(){} 
   
    public String pegate(String valor1, String valor2){
         if (valor1.length() >= 3 && valor2.length() >= 3){
         String combinacion = valor1.substring(0, 3) + " " + valor2.substring(0, 3);
         return combinacion;   
         }
         else { return "No aporta cadenas válidas"; }       
    }
   
    public String CombinadoSiempre (String valor_texto1, String valor_texto2) {
        int longitud_texto1 = 3; 
        int longitud_texto2 = 3;
        String CombinadoSiempre = "";
        if (valor_texto1.length() < 3) {       
            longitud_texto1 = valor_texto1.length();
        }
        if (valor_texto2.length() < 3) { longitud_texto2 = valor_texto2.length(); }
CombinadoSiempre = valor_texto1.substring (0,longitud_texto1)+" "+ valor_texto2.substring (0, longitud_texto2);
return CombinadoSiempre;
    }     
}

En el primer método dice que si valor1 y valor2 es mayor o igual a 3, procede con la combinación de caracteres.. si no es así, devuelve un mensaje diciendo que "No aporta cadenas validas".

Mientras que en el segundo método:

* Se igualan a 3, en variables diferentes, las longitudes máximas de cada palabra.
* Se iguala una variable String a un espacio vacio(se inicializa al parecer con "").
* En el primer método dice que si valor1 y valor2 es mayor o igual a 3, procede con la combinación de caracteres. Mientras que en el segundo método ejecuta.
* Cuenta la cantidad de caracteres de cada variable (valor_texto1 y valor_texto2) con length() para saber si es menor a 3. Si es menor a 3, se procede a almacenar el resultado del length() en la variable longitud_texto.
* En la variable String (CombinadoSiempre) finalmente se procede la mezcla con el numero de caracteres que saco de cada palabra.
 

Prueba 1: parámetros con cadenas con mas de tres caracteres.

A los dos métodos les escribí las cadenas "PowerBuilder" y "VisualStudio".

Resultado:



¿Tiene lógica la respuesta?

Si tiene lógica.. las dos cadenas de texto eran mayor de 3 caracteres ... condición del primer método Combinador (o Pegate ), mientras que en el segundo método (CombinadoSiempre), da igual la cantidad de caracteres que tenga, igual se ejecuta la mezcla.


Prueba 2:: parámetros con cadena de mas de 3 caracteres y otra con menos de 3.

A los dos métodos les escribí las cadenas "PowerBuilder" y "C#".

Resultado:



¿Tiene lógica la respuesta?

Tambíen tiene lógica. En el primer método, como mi segunda cadena de caracteres tan solo tiene 2 letras, no se cumple la segunda condicion del if:

if (valor1.length() >= 3 && valor2.length() >= 3)

Consecuencia a esto, su return del "no aportar caracteres validos".
 
En el segundo método, todo se vale como ya sabemos... la mezcla va, porque va.


Prueba 3: Ambos parámetros con menos de 3 caracteres...

Creo que no hace falta ver... el resultado de esto es igual al anterior... el primer método devolvera "No aporta cadenas válidas", mientras que el segundo siempre combinara.

Fíjate en el resultado que ofrece el método CombinadoSiempre cuando se le pasan como parámetros dos cadenas vacías. ¿Te parece lógico el resultado?

Pues si. Java considera los espacios como caracteres... el método CombinadoSiempre, siempre va a combinar lo que le des como parámetro... hasta espacios.

En la clase tenemos definidos dos atributos o campos. ¿Tienen utilidad conocida a la vista del código de la clase? ¿Se usan en los métodos que tenemos definidos?

Nunca se usan los atributos... a mi clase si se ve bien, no le declare ni un atributo y funciona todo normal. El constructor, vi que siempre se le debe crear, no importa que este vació. La verdad, opino yo que los atributos declarados en esta clase son inutiles ya que nunca se usan en ningún método...

Ruego y agradezco sus correcciones!!! mil gracias!

Hola!! buenas noches!!!

Aquí les traigo otro ejercicio, sobre la clase Math y sus funciones! API Java!!. El enunciado dice asi:

Crea una clase denominada miniCalculadoraEjemplo que tenga dos métodos (basados en el uso de métodos de la clase Math): un método valorAbsoluto que recibe un número de tipo double y devuelva su valor absoluto, y otro método raizCuadrada que reciba un número de tipo double y devuelva su raíz cuadrada.

Un ejercicio bastante sencillo! Aquí mi clase miniCalculadoraEjemplo:

package miniCalculadora;

public class miniCalculadoraEjemplo {
    public miniCalculadoraEjemplo(){}
   
    public double valorAbsoluto(double abs){
        return Math.abs(abs);
    }
   
    public double raizCuadrada(double num){
        return Math.sqrt(num);
    }
}
Muy util la informacion sobre el API java! Muchas gracias de nuevo!

Saludos!

Aquí traigo otro ejercicio mas! uso de clases que utilizan objetos de otras clases. Aquí el enunciado:

Define tres clases: Casa, SalonCasa y CocinaCasa. La clase SalonCasa debe tener como atributos numeroDeTelevisores (int) y tipoSalon (String) y disponer de un constructor que los inicialice a 0 y “desconocido”. La clase CocinaCasa debe tener como atributos esIndependiente (boolean) y numeroDeFuegos (int) y un constructor que los inicialice a false y 0. La clase Casa tendrá los siguientes atributos de clase: superficie (double), direccion (String), salonCasa (tipo SalonCasa) y cocina (tipo CocinaCasa). Define un constructor para la clase Casa que establezca a unos valores de defecto los atributos simples y que cree nuevos objetos si se trata de atributos objeto.

Aquí la clase SalonCasa:

package Home;

public class SalonCasa {
    private int numeroDeTelevisores;
    private String tipoSalon;
   
    public SalonCasa(){
        numeroDeTelevisores = 0;
        tipoSalon = "desconocido";
    }
   
    public void setNumeroDeTelevisores(int ingresoNumeroDeTelevisores){
        numeroDeTelevisores = ingresoNumeroDeTelevisores;
    }
   
    public void setTipoSalon(String ingresoTipoSalon){
        tipoSalon = ingresoTipoSalon;
    }
   
    public int getNumeroDeTelevisores(){
        return numeroDeTelevisores;
    }
   
    public String getTipoSalon(String ingresoTipoSalon){
        return tipoSalon;
    }
}

La clase CocinaCasa:

package Home;

public class CocinaCasa {
    private boolean esIndependiente;
    private int numeroDeFuegos;
   
    public CocinaCasa(){
        esIndependiente = false;
        numeroDeFuegos = 0;
    }
   
    public void setEsIndependiente(boolean ingresoIndependiente){
        esIndependiente = ingresoIndependiente;
    }
   
    public void setNumeroDeFuegos(int ingresoNumeroDeFuego){
        numeroDeFuegos = ingresoNumeroDeFuego;
    }
   
    public boolean getEsIndependiente(){
        return esIndependiente;
    }
   
    public int getNumeroDeFuegos(){
        return numeroDeFuegos;
    }
}
Y por ultimo... la clase Casa:

package Home;

public class Casa {
    private double superficie;
    private String direccion;
    private SalonCasa salonCasa;
    private CocinaCasa cocina;
   
    public Casa(){
        superficie = 0;
        direccion = "Desconocido";
        salonCasa = new SalonCasa();
        cocina = new CocinaCasa();
    }
   
    public void setSuperficie(double ingresoSuperficie){
        superficie = ingresoSuperficie;
    }
   
    public void setDireccion(String ingresoDireccion){
        direccion = ingresoDireccion;
    }
   
    public double getSuperficie(){
        return superficie;
    }
   
    public String getDireccion(){
        return direccion;
    }
}
Los setters y getters, los coloque por el tema de consulta y configuracion de atributos. Ademas en la entrega del ejercicio del capitulo pasado, habia leido que cualquiera clase que use atributos, se le debe colocar sus getter y setters.

Muchas Gracias nuevamente

Muy buenas tardes

Hoy tengo que quedarme en la U hasta las 3:00 PM... y bueno decidí invertir el tiempo en este curso!, no entregue nada en el día de ayer por estar ocupado con asignaciones. Hoy les entrego el siguiente ejercicio que dice así:

Define una clase Bombero considerando los siguientes atributos de clase: nombre (String), apellidos (String), edad (int), casado (boolean), especialista (boolean). Define un constructor que reciba los parámetros necesarios para la inicialización y los métodos para poder establecer y obtener los valores de los atributos. Compila el código para comprobar que no presenta errores, crea un objeto y comprueba que se inicializa correctamente consultando el valor de sus atributos después de haber creado el objeto.

Aquí mi clase Bombero:


package Bomber;

public class Bombero {
   private String nombre, apellido;
   private int edad;
   private boolean casado, especialista;

   public Bombero(String vNombre, String vApellido, int vEdad, boolean vCasado, boolean vEspecialista){
       nombre = vNombre;
       apellido = vApellido;
       edad = vEdad;
       casado = vCasado;
       especialista = vEspecialista;
   }

   public void setNombre(String ingresoNombre){
       nombre = ingresoNombre;
   }
   
   public void setApellido(String ingresoApellido){
       apellido = ingresoApellido;
   }
   
   public void setEdad(int ingresoEdad){
       edad = ingresoEdad;
   }
   
   public void setCasado(boolean ingresoCasado){
       casado = ingresoCasado;
   }
   
   public void setEspecialista(boolean ingresoEspecialista){
       especialista = ingresoEspecialista;
   }

   public String getNombre(){
       return nombre;
   }

   public String getApellido(){
       return apellido;
   }

   public int getEdad(){
       return edad;
   }

   public boolean getCasado(){
       return casado;
   }

   public boolean getEspecialista(){
       return especialista;
   }
}

Por lo que pude comprender en este capitulo, ahora se quiere inicializar los atributos del constructor con las variables que se encuentran en el parámetro del mismo (Si lo he dicho mal, corrijanme .), use netbeans... se que no debo tocar el main por ahora pero quise efectuar una prueba para ver como esta vez funcionaria. Ahora al parecer (Tomando como ejemplo el problema del disco musical https://www.aprenderaprogramar.com/foros/index.php?topic=2064.0), si antes escribía por ejemplo Disco1 = new DiscoMusical();, ahora como el constructor tiene parámetros... debe ser Disco1 = new DiscoMusical("", "", 0, "", false)... Ahora al hacer esto estaría incializando mis variables de esta forma (de mas decir que también podría añadirle la info directamente sin usar ningún setter).

Aquí mi clase main (recalco, solo probaba):

package Bomber;

public class Main {

    public static void main(String[ ]args){
        Bombero bombero1;
        bombero1 = new Bombero("Daniel", "Phillips", 19, false, true);
        System.out.println(bombero1.getNombre());
        System.out.println(bombero1.getApellido());
        System.out.println(bombero1.getEdad());
        System.out.println(bombero1.getCasado());
        System.out.println(bombero1.getEspecialista());
    }
}
Y aquí la ejecución:



A decir verdad, algo nuevo para este servidor...! de mas decir que si tengo algún error, o desean ampliarme, aquí estaré para leer sus comentarios.

Muchas gracias de nuevo por sus cursos

Buenas noches!!

Vengo tambien a presentarles el ejercicio sobre switch en java!!! Enunciado:

Considera estás desarrollando un programa Java donde necesitas trabajar con objetos de tipo Motor (que representa el motor de una bomba para mover fluidos). Define una clase Motor considerando los siguientes atributos de clase: tipoBomba (int), tipoFluido (String), combustible (String). Define un constructor asignando unos valores de defecto a los atributos y los métodos para poder establecer y obtener los valores de los atributos. Crea un método tipo procedimiento denominado dimeTipoMotor() donde a través de un condicional switch hagas lo siguiente:

a) Si el tipo de motor es 0, mostrar un mensaje por consola indicando “No hay establecido un valor definido para el tipo de bomba”.

b) Si el tipo de motor es 1, mostrar un mensaje por consola indicando “La bomba es una bomba de agua”.

c) Si el tipo de motor es 2, mostrar un mensaje por consola indicando “La bomba es una bomba de gasolina”.

d) Si el tipo de motor es 3, mostrar un mensaje por consola indicando “La bomba es una bomba de hormigón”.

e) Si el tipo de motor es 4,mostrar un mensaje por consola indicando “La bomba es una bomba de pasta alimenticia”.

f) Si no se cumple ninguno de los valores anteriores mostrar el mensaje “No existe un valor válido para tipo de bomba”.

Aqui el codigo!

package Motorsito;

public class Motor {
    int tipoBomba;
    String tipoFluido, combustible;
   
    public Motor(){
        tipoBomba = 0;
        tipoFluido = "";
        combustible = "";
    }
   
    public void setTipoBomba(int ingresoTipoBomba){
        tipoBomba = ingresoTipoBomba;
    }
   
    public void setTipoFluido(String ingresoTipoFluido){
        tipoFluido = ingresoTipoFluido;
    }
   
    public void setCombustible(String ingresoCombustible){
        combustible = ingresoCombustible;
    }
   
    public void dimeTipoMotor(){       
        switch(tipoBomba){
            case 0:
                System.out.println("“No hay establecido un valor definido para el tipo de bomba”.");
            break;
            case 1:
                System.out.println("La bomba es una bomba de agua.");
            break;
            case 2:
                System.out.println("La bomba es una bomba de gasolina.");
            break;
            case 3:
                System.out.println("La bomba es una bomba de hormigón.");
            break;
            case 4:
                System.out.println("La bomba es una bomba de pasta alimenticia.");
            break;
            default:
                System.out.println("No existe un valor válido para tipo de bomba.");
            break;
        }
    }
   
    public int getTipoBomba(){
        return tipoBomba;
    }
   
    public String getTipoFluido(){
        return tipoFluido;
    }
   
    public String getCombustible(){
        return combustible;
    }
   
}
Se le agradecería comentar cualquier error... mil gracias ..

Buenas noches

Aquí les dejo la entrega del ejercicio sobre los operadores lógicos.

Dadas las variables de tipo int con valores A = 5, B = 3, C = -12 indicar si la evaluación de estas expresiones daría como resultado verdadero o falso:

1. A > 3  Verdadero
2. B < C  Falso
3. A * B == 15 Verdadero
4. C / B == -10 Falso
5. (A+B == 8 ) && (A-B == 2) Verdadero
6. A > 3 && B > 3 && C < 3  Falso
7. A > C Verdadero
8. B != C Verdadero
9. A * B == -30 Falso
10. C/B == -4 Verdadero
11. (A+B == 8 ) || (A-B == 6) Verdadero
12.  A > 3 && B >= 3 && C < -3 Verdadero
13. A < C Falso
14. A == 3 Falso
15. C/B < A Verdadero
16. A + B + C == 5 Falso

Entrenamiento mental >.<, Cualquier errorsillo, se le agradecería ayuda y explicación.
Gracias!

Buenos días

En esta oportunidad, quiero presentarles mi código sobre el siguiente ejercicio:

Considera estás desarrollando un programa Java donde necesitas trabajar con objetos de tipo Medico (que representa a un médico de un hospital). Define una clase Medico considerando los siguientes atributos de clase: nombre (String), apellidos (String), edad (int), casado (boolean), numeroDocumentoIdentidad (String), especialidad (String). Define un constructor asignando unos valores de defecto a los atributos y los métodos para poder establecer y obtener los valores de los atributos. En cada método, incluye una instrucción para que se muestre por consola un mensaje informando del cambio. Por ejemplo si cambia la especialidad del médico, debe aparecer un mensaje que diga: “Ha cambiado la especialidad del médico de nombre … . La nueva especialidad es: …”.

Hice 1 objeto medico, para no hacer tan extenso el código. Por cierto, tome nota y separe las clases. Una clase es el "Medico", la otra clase es el "Main"... vi a otro en este foro crear una clase para la lectura.. Decidí ponerlo a prueba con este código, aquí va:

Clase Main:
package MediCenter;

public class MainMedico {
    static String dato[] = new String [4];
    static int num;
    static boolean salir = false, ingresado = false, ok = false;
    static Medico medico1;
    static char elige;
   
    public static void main (String[]args){
        medico1 = new Medico();
       
        System.out.println("Buenas tardes.");
        do{
            System.out.println("Elija una de las siguientes opciones que desea realizar: ");
            System.out.println("Ingrese A para ingresar datos del medico.");
            System.out.println("Ingrese B para salir del programa.");
            elige = LeerDato.LeerCaracter();
            switch (elige){
                case 'A':
                case 'a':
                    ingresadorDato();                   
                break;
                case 'B':
                case 'b':
                    salir = true;
                break;
                default:
                    System.out.println("Caracter invalido.");
                break;
                }
        }while(salir == false);     
    }
   
    public static void ingresadorDato(){
        System.out.println("<---------------------------->");
        if (ok == false){
        System.out.println("Ingrese el nombre del medico: ");
        dato[0] = LeerDato.LeerCadena();
        System.out.println("Ingrese el apellido del medico: ");
        dato[1] = LeerDato.LeerCadena();
        System.out.println("¿Cuál es la edad del medico?: ");
        num = LeerDato.LeerNumero();
        System.out.println("Ingrese el numero de identidad del medico: ");
        dato[2] = LeerDato.LeerCadena();       
        System.out.println("Ingrese la especialidad del medico: ");
        dato[3] = LeerDato.LeerCadena();
        System.out.println("¿Es casado?: ");
        ingresado = LeerDato.LeerBooleano();
        medico1.setNombre(dato[0]);
        medico1.setApellido(dato[1]);
        medico1.setNumeroDocumentoIdentidad(dato[2]);
        medico1.setEspecialidad(dato[3]);
        medico1.setEdad(num);
        medico1.setCasado(ingresado);
        ok = true;
        }   
        else if (ok == true){
        System.out.println("Ingresa el nuevo nombre del medico: ");
        dato[0] = LeerDato.LeerCadena();
        System.out.println(medico1.getNombre() + " ahora se llama: " + dato[0] + ".");
        System.out.println("Ingresa el nuevo apellido de " + dato[0] + ".");
        dato[1] = LeerDato.LeerCadena();
        System.out.println("Antes el apellido de " + dato[0] + " era " + medico1.getApellido() + ", ahora su apellido es: " + dato[1] + ".");
        System.out.println("Ingresa la nueva edad de " + dato[0] + ".");
        num = LeerDato.LeerNumero();
        System.out.println(dato[0] + " tenia " + medico1.getEdad() + ",ahora tiene: " + num);
        System.out.println("Ingrese el nuevo numero de identidad de " + dato[0] + ".");
        dato[2] = LeerDato.LeerCadena();
        System.out.println(dato[0] + ", con numero de identidad: " + medico1.getNumeroDocumentoIdentidad() + "... ahora cambio a " + dato[2] + ".");
        System.out.println("Ingrese la nueva especialidad de " + dato[0] + ".");
        dato[3] = LeerDato.LeerCadena();
        System.out.println("La vieja especialidad de " + dato[0] + " era " + medico1.getEspecialidad() + ", ahora a cambiado a " + dato[3] + ".");
        medico1.setNombre(dato[0]);
        medico1.setApellido(dato[1]);
        medico1.setNumeroDocumentoIdentidad(dato[2]);
        medico1.setEspecialidad(dato[3]);
        medico1.setEdad(num);
        medico1.setCasado(ingresado);
        }
        System.out.println("<---------------------------->");
    }   
}
Clase medico
package MediCenter;

public class Medico {
    private String nombre, apellido, numeroDocumentoIdentidad, especialidad;
    private int edad;
    private boolean casado;
   
    public Medico(){
        nombre = "";
        apellido = "";
        numeroDocumentoIdentidad = "";
        especialidad = "";
        edad = 0;
        casado = false;
    }
   
    public void setNombre(String ingresoNombre){
        nombre = ingresoNombre;       
    }
   
    public void setApellido(String ingresoApellido){
        apellido = ingresoApellido;
    }
   
    public void setNumeroDocumentoIdentidad (String ingresoNumeroDocumentoIdentidad){
        numeroDocumentoIdentidad = ingresoNumeroDocumentoIdentidad;
    }
   
    public void setEspecialidad (String ingresoEspecialidad){
        especialidad = ingresoEspecialidad;
    }
   
    public void setEdad(int ingresoEdad){
        edad = ingresoEdad;
    }
   
    public void setCasado(boolean ingresoCasado){
        casado = ingresoCasado;
    }
   
    public String getNombre(){
        return nombre;
    }
   
    public String getApellido(){
        return apellido;
    }
   
    public String getNumeroDocumentoIdentidad(){
        return numeroDocumentoIdentidad;
    }
   
    public String getEspecialidad(){
        return especialidad;
    }
   
    public int getEdad(){
        return edad;
    }
   
    public boolean getCasado(){
        return casado;
    }
   
}

Clase LeerDato
package MediCenter;
import java.util.Scanner;

public class LeerDato {
    public LeerDato(){           
    }
   
    static char LeerCaracter(){
        Scanner in = new Scanner (System.in);
        char opcion = in.next().charAt(0);
        return opcion;
    }
   
    static String LeerCadena(){
        Scanner in = new Scanner (System.in);
        String dato = in.nextLine();
        return dato;
    }
   
    static int LeerNumero(){
        Scanner in = new Scanner (System.in);
        int num = in.nextInt();
        return num;
    }
   
    static boolean LeerBooleano(){
        Scanner in = new Scanner (System.in);
        boolean lel = in.nextBoolean();
        return lel;
    }
}
Intente primero ponerle los mensajes en la clase Medico como dice de insertarselo a cada método, pero no se me hacia posible manejar los objetos ahí... yo entendí que se deseaba insertarse los mensajes en cada método, no se si de esta forma es incorrecta o no. Aquí la ejecución:





Aquí hay por cierto, un misterio... se trata de los arreglos. Yo inicialize mi arreglo con 3 espacios originalmente, pero algo raro pasa... me suelta un "OutOfBonds", cosa que no debería ocurrir, porque con 3 estaría teniendo 4 espacios en realidad, forzosamente me vi obligado a cambiárselo a 4, que funciono:

0 = nombre
1 = apellido
2 = numero de identidad
3 = especialidad

Hace tiempo atras (no mucho) me sucedió que mi nextLine(); me dejaba un espacio, suponte que estoy insertando datos y me sale así la ejecución:

Ingrese nombre y apellido:
Cristian Grey
Ingrese cedula:
Ingrese Sexo:
Masculino
...
...

No me dejaba insertarle la cédula (en este ejemplo, originalmente era con libros) La solución que me dieron fue, volver a escribir abajo in.nextLine();... que funciono. Yo la verdad no creo que eso funcionara así, O quizá mi código se tomaba un espacio, quisiera saber porque sucedía esto (Y perdone que les aborde el tema de esta forma :S)

package ejemplo2;
import java.util.Scanner;
public class Ejemplo2 {
public static class inventario{
static String titulo[] = new String [25];
static String fecha_pub[] = new String [20];
static String autor[] = new String [30];
static int num = 0;
static int pedido = 0;
static float precio_venta = 0;
}
public static void main(String[] args) {
Scanner in = new Scanner (System.in);
int total = 0;
boolean A = false;
String b[] = new String [21];
char resp;
do {
System.out.println("Total libros: \n" + (total = total + 1));
System.out.println("¿Cual es el titulo?: ");
inventario.titulo[total] = in.nextLine();
System.out.println("Cual es la fecha de publicacion?: ");
inventario.fecha_pub[total] = in.nextLine();
System.out.println("Quien es el autor?");
inventario.autor[total] = in.nextLine();
System.out.println("¿Cuantos libros existen?: ");
inventario.num = in.nextInt();
System.out.println("¿Cuantos ejemplares existen pedidos?");
inventario.pedido = in.nextInt();
System.out.println("¿Cual es el precio de venta?");
inventario.precio_venta = in.nextFloat();
System.out.println("Imprimiendo...");
    System.out.println("Titulo del libro "+ total +" : "+ inventario.titulo[total]);
    System.out.println("Fecha de publicacion del libro " + total + " : " + inventario.fecha_pub[total]);
    System.out.println("Autor de "+ inventario.titulo[total] + " : " + inventario.autor[total]);
    System.out.println("Numero de libros existentes: " + inventario.num);
    System.out.println("Ejemplares pedidos: " + inventario.pedido);
    System.out.println("Precio de venta: " + inventario.precio_venta);
System.out.println("¿Hay mas libros?");
resp = in.next().charAt(0);
in.nextLine();   // <------------ La solución del problema
if (resp == 'N' ||  resp == 'n'){
A = true;
}
}while (A != true);   
}
}
Mil gracias y espero con ansias sus respuestas!

Hola a todos!!!

Vengo a hacer una entrega de este ejercicio con el siguiente enunciado:

Considera estás desarrollando un programa Java donde necesitas trabajar con objetos de tipo DiscoMusical. Define las signaturas para métodos dentro dicha clase e indica si deberán ser procedimientos o funciones para los siguientes objetivos planteados:

1) Obtener la duración de una canción expresada como un número decimal en minutos (por ejemplo podría ser 3,22 minutos) recibiendo como dato el número de canción dentro del disco.

2) Pedir a un administrador de una compañía discográfica que introduzca la duración de todas las canciones (dichas duraciones se almacenarán como información del objeto). Es decir, el método se encargará de saludar al usuario y pedirle que vaya introduciendo una por una la duración de las canciones.

3) Obtener la duración del disco completo (suma de las duraciones de cada una de las canciones).

4) Añadir una canción al disco recibiendo como información para ello el título de la canción y su duración (se añadirá como última canción en el disco. Si el disco tenía por ejemplo 10 canciones, al añadirse una canción pasará a tener 11).

Bien, hice el programa a mi estilo (pero claro, siguiendo según entendí el enunciado lo que piden!) Nos están pidiendo ahora ingresar los datos de cada disco al programa... Imagine un menú donde el usuario elija que acción realizar y demás! para los temas musicales, decidí crear un arreglo para los nombres, y otro arreglo para la duración de cada canción (Un arreglo bidimensional... también podía ser...) para el menú, cree una variable char para que el usuario ingresara la opción que quería ejecutar, al elegir el usuario la opción, use algo que no suelo utilizar... en la Universidad la profe se enojaba porque no me veía usarlo nada... se trata de la sentencia Switch, decidí usarlo por practica, razón principal porque sigo el curso! los arreglos tendrán un máximo de 20 espacios.

El constructor contrendra las variables nombreDisco, autor, formato, indiceCancion, duracion, nombreCancion y duracionCancion. Sera los atributos que contendrá cada objeto que creemos.

Aquí presento el código:
package DiscMan;
import java.util.Scanner;

public class DiscoMusical {
    private String nombreDisco, autor, formato, nombreCancion[];
    private int indiceCancion;
    private double duracion, duracionCancion[];
    private static int salir, elige, num, full;
    private static char opcion;
   
    public DiscoMusical(){
        nombreDisco = "";
        autor = "";
        formato = "";
        duracion = 0;
        indiceCancion = 0;
        nombreCancion = new String [20];
        duracionCancion = new double [20];
    }
   
   
    public static void main (String[]args){
    String data;
    int can = 0;
    DiscoMusical Disco1, Disco2, Disco3;   
    Disco1 = new DiscoMusical();
    Disco2 = new DiscoMusical();
    Disco3 = new DiscoMusical();
    Scanner in = new Scanner(System.in);   
    do{
        System.out.println("Bienvenido seas a este programa, ¿que actividad deseas ejecutar?");
        System.out.println("Ingresa A para añadir datos al disco.");
        System.out.println("Ingrese B para añadir una cancion al disco.");
        System.out.println("Ingrese C para obtener la duracion total del disco y sus datos.");
        System.out.println("Ingrese D para salir del programa");
        opcion = in.next().charAt(0);
        switch(opcion){
            case 'A':
            case 'a':
                System.out.println("***************************************************");
                System.out.println("A cual de los 3 discos deseas añadirle informacion?");
                elige = in.nextInt();
                if (elige == 1){
                    System.out.println("Has elegido el disco 1!");
                    System.out.println("Ingesa el nombre del disco 1: ");
                    data = in.next();
                    Disco1.setNombreDisco(data);
                    System.out.println("Ingresa el autor del disco 1: ");
                    data = in.next();
                    Disco1.setAutor(data);
                    System.out.println("Ingresa el formato del disco 1: ");
                    data = in.next();
                    Disco1.setFormato(data);
                    System.out.println("<------------------------------------------------->");
                    System.out.println("Ahora ingrese, ¿cuantas canciones tiene el albúm?: ");
                    num = in.nextInt();
                    if (num > 20) {
                        System.out.println("Solo se pueden almacenar un maximo de 20 canciones.");
                    }
                    else {
                    Disco1.setIndiceCancion(num);
                    can = 0;
                    for (int i = 0; i < Disco1.getIndiceCancion(); i++){
                        can++;
                        System.out.println("Ingrese el nombre de la cancion " + can + " :");
                        Disco1.nombreCancion[i] = in.next();
                        System.out.println("Ingrese la duracion de la cancion " + can + " :");
                        Disco1.duracionCancion[i] = in.nextDouble();
                        Disco1.duracion = Disco1.duracion + Disco1.duracionCancion[i];
                    }
                    full++;
                    }
                    System.out.println("Ingreso exitoso.");
                    System.out.println("***************************************************");
                }
                else if (elige == 2) {
                    System.out.println("Has elegido el disco 2!");
                    System.out.println("Ingesa el nombre del disco 2: ");
                    data = in.next();
                    Disco2.setNombreDisco(data);
                    System.out.println("Ingresa el autor del disco 2: ");
                    data = in.next();
                    Disco2.setAutor(data);
                    System.out.println("Ingresa el formato del disco 2: ");
                    data = in.next();
                    Disco2.setFormato(data);
                    System.out.println("<------------------------------------------------->");
                    System.out.println("Ahora ingrese, ¿cuantas canciones tiene el albúm?: ");
                    num = in.nextInt();
                    if (num > 20) {
                        System.out.println("Solo se pueden almacenar un maximo de 20 canciones.");
                    }
                    else {
                    Disco2.setIndiceCancion(num);
                    can = 0;
                    for (int i = 0; i < Disco2.getIndiceCancion(); i++){
                        can++;
                        System.out.println("Ingrese el nombre de la cancion " + can + " :");
                        Disco2.nombreCancion[i] = in.next();
                        System.out.println("Ingrese la duracion de la cancion " + can + " :");
                        Disco2.duracionCancion[i] = in.nextDouble();
                        Disco2.duracion = Disco2.duracion + Disco2.duracionCancion[i];
                    }
                    full++;
                    }
                    System.out.println("Ingreso exitoso.");
                    System.out.println("***************************************************");
                }
                else if (elige == 3){
                    System.out.println("Has elegido el disco 3!");
                    System.out.println("Ingesa el nombre del disco 3: ");
                    data = in.next();
                    Disco3.setNombreDisco(data);
                    System.out.println("Ingresa el autor del disco 3: ");
                    data = in.next();
                    Disco3.setAutor(data);
                    System.out.println("Ingresa el formato del disco 3: ");
                    data = in.next();
                    Disco3.setFormato(data);
                    System.out.println("<------------------------------------------------->");
                    System.out.println("Ahora ingrese, ¿cuantas canciones tiene el albúm?: ");
                    num = in.nextInt();
                    if (num > 20) {
                        System.out.println("Solo se pueden almacenar un maximo de 20 canciones.");
                    }
                    else {
                    Disco3.setIndiceCancion(num);
                    can = 0;
                    for (int i = 0; i < Disco3.getIndiceCancion(); i++){
                        can++;
                        System.out.println("Ingrese el nombre de la cancion " + can + " :");
                        Disco3.nombreCancion[i] = in.next();
                        System.out.println("Ingrese la duracion de la cancion " + can + " :");
                        Disco3.duracionCancion[i] = in.nextDouble();
                        Disco3.duracion = Disco3.duracion + Disco3.duracionCancion[i];
                    }
                    full++;
                    }
                    System.out.println("Ingreso exitoso.");
                    System.out.println("***************************************************");
                }
                else
                    System.out.println("No se encuentra el disco.");
                System.out.println("***************************************************");
            break;
            case 'B':
            case 'b':   
                System.out.println("Elige a cual disco quieres agregarle una nueva cancion: ");
                elige = in.nextInt();
                if (elige == 1){
                    if (Disco1.indiceCancion >= 20){
                        System.out.println("Se ha llegado al limite de canciones.");
                    }
                    else{
                    System.out.println("***************************************************");
                    Disco1.indiceCancion++;
                    System.out.println("Ingrese el nombre de la nueva cancion: ");
                    Disco1.nombreCancion[Disco1.indiceCancion] = in.next();
                    System.out.println("Ingrese la duracion de la nueva cancion: ");
                    Disco1.duracionCancion[Disco1.indiceCancion] = in.nextDouble();
                    Disco1.duracion = Disco1.duracion + Disco1.duracionCancion[Disco1.indiceCancion];
                    System.out.println("***************************************************");
                    }
                }
                else if (elige == 2){
                    if (Disco2.indiceCancion >= 20){
                        System.out.println("Se ha llegado al limite de canciones.");
                    }
                    else{
                    System.out.println("***************************************************");
                    Disco2.indiceCancion++;
                    System.out.println("Ingrese el nombre de la nueva cancion: ");
                    Disco2.nombreCancion[Disco2.indiceCancion] = in.next();
                    System.out.println("Ingrese la duracion de la nueva cancion: ");
                    Disco2.duracionCancion[Disco2.indiceCancion] = in.nextDouble();
                    Disco2.duracion = Disco2.duracion + Disco2.duracionCancion[Disco2.indiceCancion];
                    System.out.println("***************************************************");
                    }
                }
                else if (elige == 3){
                    if (Disco3.indiceCancion >= 20){
                        System.out.println("Se ha llegado al limite de canciones.");
                    }
                    else{
                    System.out.println("***************************************************");
                    Disco3.indiceCancion++;
                    System.out.println("Ingrese el nombre de la nueva cancion: ");
                    Disco3.nombreCancion[Disco3.indiceCancion] = in.next();
                    System.out.println("Ingrese la duracion de la nueva cancion: ");
                    Disco3.duracionCancion[Disco3.indiceCancion] = in.nextDouble();
                    Disco3.duracion = Disco3.duracion + Disco1.duracionCancion[Disco3.indiceCancion];
                    System.out.println("***************************************************");
                    }
                }
                else
                    System.out.println("No se encuentra el disco.");
                System.out.println("***************************************************");                         
            break;
            case 'C':
            case 'c':
                System.out.println("***************************************************");
                System.out.println("¿A cual disco quieres elegir para ser su informacion?: ");
                elige = in.nextInt();
                if(elige == 1){
                   System.out.println(Disco1.getNombreDisco());
                   System.out.println(Disco1.getAutor());
                   System.out.println(Disco1.getFormato());
                   System.out.println("Duracion del disco 1: " + Disco1.duracion);
                   System.out.println("Canciones del disco ( canciones: " + Disco1.getIndiceCancion() + "): ");
                   for(int i = 0; i <= Disco1.getIndiceCancion(); i++){
                       System.out.println(Disco1.nombreCancion[i]);
                   }
                   System.out.println("***************************************************");
                }
                else if (elige == 2){
                   System.out.println(Disco2.getNombreDisco());
                   System.out.println(Disco2.getAutor());
                   System.out.println(Disco2.getFormato());
                   System.out.println("Duracion del disco 1: " + Disco2.duracion);
                   System.out.println("Canciones del disco ( canciones: " + Disco2.getIndiceCancion() + "): ");
                   for(int i = 0; i <= Disco2.getIndiceCancion(); i++){
                       System.out.println(Disco2.nombreCancion[i]);
                   }
                   System.out.println("***************************************************");
                }
                else if (elige == 3){
                   System.out.println(Disco3.getNombreDisco());
                   System.out.println(Disco3.getAutor());
                   System.out.println(Disco3.getFormato());
                   System.out.println("Duracion del disco 1: " + Disco3.duracion);
                   System.out.println("Canciones del disco ( canciones: " + Disco3.getIndiceCancion() + "): ");
                   for(int i = 0; i <= Disco3.getIndiceCancion(); i++){
                       System.out.println(Disco3.nombreCancion[i]);
                   }
                   System.out.println("***************************************************");
                }
                else
                    System.out.println("No se encuentra el disco.");
                System.out.println("***************************************************");
            break;
            case 'D':
            case 'd':
                salir++;
            break;
            default:
                System.out.println("El caracter que has introducido no es valido.");
            break;
        }
    }while(salir < 1);
    System.out.println("Gracias por tu atencion. <( º c º )> ");
    }
   
    public void setNombreDisco(String ingresoNombreDisco){
        nombreDisco = ingresoNombreDisco;
    }
   
    public void setAutor(String ingresoAutor){
        autor = ingresoAutor;
    }
   
    public void setFormato(String ingresoFormato){
        formato = ingresoFormato;
    }
   
    public void setIndiceCancion(int ingresoIndiceCancion){
        indiceCancion = ingresoIndiceCancion;
    }
   
    public int getIndiceCancion(){
        return indiceCancion;
    }
   
    public String getNombreDisco(){
        return nombreDisco;
    }
   
    public String getAutor(){
        return autor;
    }
   
    public String getFormato(){
        return formato;
    }
}

Utilize metodos y funciones a la vez como se puede apreciar... tengo un pequeño inconveniente a la hora de imprimir mi arreglo... a continuación se muestra:



Aquí se puede apreciar la ejecución del menú principal del programa.




*Elegimos la primera opción, claramente porque no tenemos ningún dato en el disco. Si apretáramos de una vez la tecla C se nos imprimiría todos los datos vacíos (o nulos).

*Como acto siguiente nuestro programa nos preguntara cual disco vamos a ingresarle los datos... aquí como podemos apreciar, estamos eligiendo uno de los 3 objetos ya creados de la clase DiscoMusical. Si llegáramos a teclear un numero mayor a 3, nuestro programa respondería mandando el siguiente mensaje: "No se encuentra el disco.".

*Luego de ingresar los datos, el programa nos preguntara cuantas canciones nuestro disco tendrá. Esto sera el indice de los arreglos que declare mas arriba....





Aquí como se puede ver, elegimos la opción B que es agregar una canción mas al disco. Aquí lo que se necesitaba hacer era sumarle 1 a nuestra variable indiceCancion del objeto para poder agregarle un dato mas. Cada vez que aprieto B se le sumara, hasta el limite que es 20.




Aqui solo se ve cuando le estamos añadiendo datos al objeto 2.


Bueno, aquí va el pequeño inconveniente y las preguntas:



*Mi duración... tiene un montón de números a la derecha! En visual basic, para no imprimir esos numerotes, uso la funcion format.. en powerbuilder también (que por cierto es super similar al visual basic):

Visual Basic: textbox1.text = Format(total,"#.00")
PowerBuilder: st_num.text = String(total, "#.00")

Mi pregunta seria, ¿que escribo para que java me redondee a dos decimales?

*El programa me cuenta bien las canciones que he agregado, me imprime todos los nombres... pero, ¿Porque me sale ese null?, la verdad busque y busque cual pudo ser ese error... pero no pude ver que hice mal... si igualo la variable i del for a 1 me imprimira 2 canciones en vez de las 3... :S

Agradecería mucho su ayuda! Muchas gracias por cierto, yo no sabia como manejar perfectamente las clases, constructores y demás!! Gracias a ustedes mi duda se ha esclarecido !! 

Hola a todos los presentes, soy yo de nuevo!! Mi clase estará bien??... el encabezado es así:

"Considera estás desarrollando un programa Java donde necesitas trabajar con objetos de tipo Persona. Define una clase Persona análoga a la que hemos visto para taxis, pero en este caso considerando los siguientes atributos de clase: nombre (String), apellidos (String), edad (int), casado (boolean), numeroDocumentoIdentidad (String). Define un constructor y los métodos para poder establecer y obtener los valores de los atributos."

Mi código:


package Person;
public class persona {
    private String nombre, apellido, NumeroDocumentoIdentidad;
    private int edad;
    private boolean casado;
   
    public persona(){
        nombre = "";
        apellido = "";
        NumeroDocumentoIdentidad = "";
        edad = 0;
        casado = false;
    }
   
    public void setNombre (String IngresoNombre){
     nombre = IngresoNombre;   
    }
   
    public void setApellido (String IngresoApellido){
        apellido = IngresoApellido;
    }
   
    public void setNumeroDocumentoIdentidad (String IngresoIdentidad){
        NumeroDocumentoIdentidad = IngresoIdentidad;
    }
   
    public void setEdad (int IngresoEdad){
        edad = IngresoEdad;
    }
   
    public void setEstadoCivil (boolean IngresoCasado){
        casado = IngresoCasado;
    }
   
    public String getNombre () {
        return nombre;
    }
   
   public String getApellido() {
       return apellido;
   }
   
   public String getIdentidad () {
       return NumeroDocumentoIdentidad;
   }
   
   public int getEdad(){
       return edad;
   }
   
   public boolean getEstadoCivil(){
       return casado;
   }
}

Si tengo algo erróneo o me quieran ampliar el concepto!! agradecería mil veces su respuesta.

Muchas gracias por su cooperación!!!