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

Hola Adrián, veo que es tu primer hilo en el foro, por lo tanto me toca darte la bienvenida.

He de decirte primeramente que tu pregunta es muy interesante. También he de decirte que esa práctica de probar de distintas maneras un código, es la mejor forma de aprender, así que adelante con ello.

Bueno, yendo a la pregunta que formulaste, no quisiera adelantarme mucho a lo que todavía no se ha visto en el curso. El curso tiene una lógica y un orden progresivo bien pensado para ir incorporando sistemáticamente los conocimientos. De todos modos hagamos un análisis de lo que se ha hecho en ese código para ir sacando conclusiones.

Tenemos 3 clases: Persona, Taxi, y TaxiCond.
La clase Persona tiene dos campos de instancia: nombre (tipo String), y edad (tipo int).
La clase Taxi tiene tres campos de instancia de tipo String: ciudad, matricula, y distrito, y un campos de instancia de tipo int: tipoMotor.
La clase TaxiCond tiene dos campos de instancia: vehiculoTaxi (que es de tipo Taxi), y conductorTaxi (que es de tipo Persona).

Recordemos cómo es el Constructor de la clase TaxiCond:

   /* Ejemplo - aprenderaprogramar.com */

    //Constructor

    public TaxiCond (Taxi objetoTaxi, Persona objetoPersona) {

         //Creamos un objeto Taxi con los mismos datos del Taxi recibido como parámetro

         vehiculoTaxi = new Taxi (objetoTaxi.getMatricula(), objetoTaxi.getDistrito(), objetoTaxi.getTipoMotor() );

         //Creamos un objeto Persona con los mismos datos de la Persona recibidos como parámetro

        conductorTaxi = new Persona (objetoPersona.getNombre() );     }
Entonces, vemos que el Constructor recibe como parámetros dos objetos: un objeto tipo Taxi, y un objeto tipo Persona.

Y aquí viene algo importante: con esos objetos recibidos como parámetros se crean NUEVOS objetos, y esos nuevos objetos serán los campos de instancia del objeto tipo TaxiCond. Son NUEVOS objetos, no son una referencia a los objetos que recibimos como parámetros.

Recordemos algo:
La clase TaxiCond tiene 2 campos de instancia: un objeto tipo Taxi que se llama vehiculoTaxi, y un objeto tipo Persona que se llama conductorTaxi.

Analicemos la siguiente línea de código del Constructor de esta clase:

vehiculoTaxi = new Taxi (objetoTaxi.getMatricula(), objetoTaxi.getDistrito(), objetoTaxi.getTipoMotor() );

vehiculoTaxi es el campo de instancia (tipo Taxi). El signo '=' nos dice que se va a realizar una asignación sobre él. Ahora bien ¿qué se le asigna? se le asigna un nuevo objeto (por eso la sentencia 'new') de un objeto tipo Taxi. En esa instanciación de un objeto tipo Taxi se pasan 3 parámetros al constructor de la clase Taxi: 2 tipo String, y uno tipo int ¿Cómo me doy cuenta de ello?

porque:
objetoTaxi.getMatricula() me devuelve un String que corresponde a la matrícula del objeto tipo Taxi que pasé como parámetro.
objetoTaxi.getDistrito() me devuelve un String que corresponde al distrito del objeto tipo Taxi que pasé como parámetro.
objetoTaxi.getTipoMotor() me devuelve un int que corresponde al tipo de motor del objeto tipo Taxi que pasé como parámetro.
 
Por lo tanto:
new Taxi (objetoTaxi.getMatricula(), objetoTaxi.getDistrito(), objetoTaxi.getTipoMotor() );
crea un nuevo objeto Taxi, con los mismos valores del objeto tipo Taxi que recibimos como parámetro. Y luego la referencia de ese nuevo objeto Taxi creado, se la asigna al campo de instancia vehiculoTaxi perteneciente al objeto tipo TaxiCond.

Entonces, quiero remarcar lo siguiente:
El objeto tipo Taxi que pasamos como parámetro a la clase TaxiCond, nos servirá para tomar los valores de sus atributos, y CREAR un NUEVO objeto tipo Taxi que será vehiculoTaxi.
Por lo tanto el objeto vehiculoTaxi es independiente del objeto Taxi recibido como parámetro.

Lo mismo sucede con el parámetro conductorTaxi del objeto TaxiCond.

Analízalo y cualquier duda, estamos aquí para ayudarte.

Hola !

Estuve revisando tu ejercicio y esta muy bien ! Cumple con lo que se pide en la consigna.

Igualmente quiero hacerte dos observaciones para mejorar tu código:

1) Para cumplir con la convención de cómo nombrar los métodos deberías renombrar el método 'setapellidos' por 'setApellidos'. Seguramente fue un error de tipeo ya que los demás métodos están muy bien nombrados.

2) En la declaración de los campos de instancia figuran:

   private String nombre;
   private String apellidos;
   private int edad;
   private boolean casado;
   private String DNI;
   private String especialidad;
   private int x, y;
Fíjate que los campos int x e int y, no son campos de la clase Medico, de hecho no tenemos métodos set ni get para ellos. Los atributos x e y son simplemente atributos que solo servirán para calcular un resultado en uno de los método del objeto. Por lo tanto los atributos x e y no deberían declararse como campos de instancia. De esta manera los campos de instancia deberían ser solamente:

   private String nombre;
   private String apellidos;
   private int edad;
   private boolean casado;
   private String DNI;
   private String especialidad;
los atributos x e y deberían declararse y utilizarse dentro del método CalculoParaMultiploEdad() solamente. De esta manera el método nos quedaría:

   public void CalculoParaMultiploEdad(){
       
      int x=edad%5;
      int y=5-x;
       System.out.println ("El medico de nombre " +nombre+ " con especialidad "+especialidad+ " Tendra una edad multiplo de 5 dentro de "+y+"años:");
       
    }

Hola Iván, bienvenido al foro.

Estuve analizando el código que has publicado y lo veo muy bien!
Igualmente voy a hacerte una observación para que corrijas en tu código:

En el método setCasado deberías utilizar en la asignación el parámetro que recibe el método. De esta manera el método debería quedar:

    public void setCasado (Boolean valorCasado) {
        casado = valorCasado; //El estado civil indicado
    }
Analízalo y cualquier duda aquí estamos para ayudarte.

Hola Luis:

Veo que es tu primera pregunta que publicas en el foro, así que me toca hacer de anfitrión y darte la bienvenida.

Antes que nada una recomendación para el futuro: cuando quieras poner en los foros tus soluciones para un ejercicios o una pregunta (como en este caso) crea un Nuevo Tema. De ese modo mantenemos más ordenado el foro evitando mezclar respuestas de personas distintas en un mismo hilo.
¿Cómo hacer para crear un Nuevo Tema?. Una vez que te logueas en el foro, entras en "Aprender a programar desde cero", y haz click en "NUEVO TEMA".
No olvides de escribir en el título del nuevo tema a qué ejercicio se refiere tu publicación.

Ahora sí, vayamos a la pregunta que hacías:

Verás, es interesante tu pregunta de cómo inciciar un atributo (boolean) por defecto. En el caso de los ejercicios que tratamos en el curso por lo general nos especifican de qué manera debemos considerarlos por defecto, es decir ya es un dato que se nos da, y por lo general (por no decir siempre) se considerará que un atributo de tipo boolean se inicializará como false.
De todos modos en un futuro cuando trabajemos de programadores, cuando analizemos un problema por resolver, no solo determinaremos cuáles serán los atributos necesarios que habrá que declarar, sino también cómo se deben considerar sus "valores por defecto". No siempre será false, o no siempre será true, dependerá del contexto.

Veámos con un ejemplo: Supongamos que tenemos una clase llamada Trabajador, donde además de tener atributos como ser: nombre (tipo String), apellido (tipo String), edad (tipo int), tenemos dos atributos de tipo boolean: un atributo llamado 'esSoltero', y el otro atributo llamado 'mereceRenovarseContrato'.

El atributo esSoltero lo inicializamos por defecto como false. Es decir que consideremos a todos los objetos tipo Trabajadores como solteros, y que para cambiar su estado tengamos que establecer el nuevo estado civil a través de un método set. Es decir, hay que realizar una acción conciente llamando a un método set para cambiar su estado civil a true. Y esto es lo que sucede en la realidad, todos nacemos solteros hasta que en algún momento realizamos una acción y cambiamos de estado civil.

Al atributo merceRenovarseContrato lo consideraremos por defecto como true, ya que consideraremos que si es un trabajador que ya trabaja en la empresa, por defecto es eficiente, cumplidor, honesto etc etc. Entonces si hubiera que cancelarle su contrato laboral por alguna razón, que sea mediante una acción exprofesa (llamando a un método set) que cambie el valor del atributo a false.

Con estos dos ejemplos de cómo considerar los valores por defecto quiero ejemplificarte que si es false o true será una decisión que tomemos nosotros cuando tengamos que decidir cuál es la opción que más se adecue al contexto del problema que estemos resolviendo.

Pero sin irnos tan lejos, en estos ejercicios que resolveremos en la parte incial del curso, por lo general se considera que un atributo tipo boolean se inicializa por defecto en false (suele ser un dato que se nos da).

Espero haber podido orientarte con la duda planteada. Si no es así házmelo saber y seguimos desmenuzando el tema.

Hola Angel.

Revisé tu ejercicio y lo veo bien.

Respecto al nombre de los parámetros recibidos por el método setTipoFluido y setCombustible, haría la misma observación y corrección que te hice en el ejercicio anterior.
https://www.aprenderaprogramar.com/foros/index.php?topic=2812.0

Ahora bien, respecto del método dimeSiMotorEsParaAgua():
El método no debe recibir parámetro. La decisión si el motor (sobre el que estamos llamando el método) es para agua o no es para agua, la debemos tomar en base al valor del campo de instancia tipoBomba.
Recordemos que en el ejercicio anterior si el valor que tenía el campo tipoBomba era igual a 1, entonces el motor era para agua.

Por lo tanto haciendo esta corrección, el método dimeSiMotorEsParaAgua() quedaría:

    public boolean dimeSiMotorEsParaAgua(){
        boolean motorEsParaAgua = false;

        if(tipoBomba == 1){
            motorEsParaAgua = true;
        }
       
        return motorEsParaAgua;
    }
Analízalo y cualquier duda estamos aquí para ayudarte.

Hola Angel.

Estuve revisando tu ejercicio. Veo que están muy bien construidos los métodos set y get, así como el constructor.
Respecto del método comprobarDimensiones haría los siguientes observaciones:
*) Este método no debe recibir parámetros. De la lectura del enunciado del ejercicio propuesto se interpreta que se trata de un método tipo procedimiento que en base a los atributos establecidos con los métodos set se debe sacar por consola uno u otro mensaje. Es decir: no en base a valores arbitrarios, sino en base a los propios atributos de la rueda.
*) por otro lado, cambié dos signos de desigualdades para que cumpla con lo que se pide en el ejercicio.

Transcribo el método corregido:

    public void comprobarDimensiones()
    {
        if(diametro>1.4){
            System.out.println("La rueda es para un vehículo grande");
        }
        else if(diametro <= 1.4 && diametro>0.8 ){
            System.out.println("La rueda es para un vehículo mediano");
        }
        else{
            System.out.println("La rueda es para un vehículo pequeño"); }

        if (diametro>1.4 && grosor<0.4 || diametro <= 1.4 && diametro>0.8 && grosor<0.25 ){

            System.out.println("El grosor para esta rueda es inferior al reccomendado");
        }

    }
}
Analízalo y cualquier duda estamos aquí para ayudarte.

Perfecto Ronal! Todas las respuestas correctas.
A seguir adelante.

Hola:

El ejercicio está muy bien! Si embargo para que funcione con todas las posibilidades habría que hacer un pequeño cambio.

Este cambio te va a permitir que cuando las dos palabras tengan las misma cantidad de letras siga funcionando (actualmente no lo hace).

El cambio es reemplazar el "else if" , por "else" ¿por qué? porque cuando las dos palabras tienen las misma cantidad de letras no entra ni al "if", ni al "else if", ya que no cumple ninguna de las dos condiciones y el programa se interrumpe.
Por lo tanto, si reemplazamos el "else if" por "else", si la cantidad de letras de las palabras es la misma entrará al else y hará las asignaciones correspondientes.

He aquí la modificación:

package ejemplo;

/*
programa que compara dos cadenas de texto letra por letra

*/
import java.util.Scanner;

public class ComparaLetras {
   
    public ComparaLetras(){
        //Constructor vacio
    }
   
    public static void main(String [] Argumentos){
       
        System.out.println("Programa que compara letras");
        String captura1 = "";
        Scanner escaner1 = new Scanner(System.in);
        String captura2 = "";
        Scanner escaner2 = new Scanner(System.in);
       
        captura1 = escaner1.nextLine();
        captura2 = escaner2.nextLine();
       
        int cadenaMenor=0, cadenaMayor=0, posicion=0;
        //Comparamos la longitud de las cadenas
        if(captura1.length()<captura2.length()){
            cadenaMenor = captura1.length();
            posicion = 1;
            cadenaMayor = captura2.length();
        }else{
            cadenaMenor = captura2.length();
            posicion = 2;
            cadenaMayor = captura1.length();
        }
        for(int  contador = 0 ; contador < cadenaMayor; contador++){
            if(contador < cadenaMenor){
                System.out.println("Comparacion"+(contador+1)+" ¿igual en las dos letras? "
                        +captura1.substring(contador, contador+1).equals(captura2.substring(contador, contador+1)));
            }else{
                System.out.println("La palabra "+posicion+" no tiene letra "+(contador + 1));
            }
        }
    }
}
Analízalo y cualquier duda estamos aquí para ayudarte.

Hola Matru:

Revisé tu ejercicio y por mi parte lo veo perfecto. Ninguna observación para hacerte. A seguir adelante!

Hola Ronal:

Estuve revisando tu ejercicio y por mi parte lo veo perfecto.
A seguir adelante entonces!