CU00643B - Paso de objetos como parámetros a un método o constructor en Java

[Hquinn]

Hola!!!

Estoy con el ejercicio este y me salta un error y no consigo ver en que me he equivocado, aparte que tengo una pregunta tonta xD

Copio el código:

Código de SalonCasa

Código: [Seleccionar]

public class SalonCasa{
   
    //ATRIBUTOS
    private int numeroDeTelevisores;
    private String tipoSalon;
   
    //CONSTRUCTOR 1: Sin parámetros
    public SalonCasa(){
        numeroDeTelevisores = 0;
        tipoSalon = "desconocido";
    }
   
    //CONSTRUCTOR 2: Con parámetros
    public SalonCasa(int valorNumeroTelevisores, String valorTipoSalon){
        numeroDeTelevisores = valorNumeroTelevisores;
        tipoSalon = valorTipoSalon;
    }
   
    //Método SETTER para fijar el numero de televisores
    public void setNumeroTelevisores(int valorNumeroTelevisores){
        numeroDeTelevisores = valorNumeroTelevisores;
    }
   
    //Método SETTER para fijar el tipo de salón
    public void setTipoSalon(String valorTipoSalon){
        tipoSalon = valorTipoSalon;
    }
   
    //Método GETTER para obtener el numero de televisores
    public int getNumeroTelevisores(){
        return numeroDeTelevisores;
    }
   
    //Método GETTER para obtener el tipo de Salon
    public String getTipoSalon(){
        return tipoSalon;
    }
   
   
}

Código de CocinaCasa

Código: [Seleccionar]

public class CocinaCasa{

    //ATRIBUTOS
    private boolean esIndependiente;
    private int numeroDeFuegos;
   
    //CONSTRUCTOR 1: Sin parámetros
    public CocinaCasa(){
        esIndependiente = false;
        numeroDeFuegos = 0;
    }
   
    //CONSTRUCTOR 2: Con parámetros
    public CocinaCasa(boolean valorEsIndependiente, int valorNumeroFuegos){
        esIndependiente = valorEsIndependiente;
        numeroDeFuegos = valorNumeroFuegos;
    }
   
    //Método SETTER para fijar si la cocina es o no independiente
    public void setEsIndependiente(boolean valorEsIndependiente){
        esIndependiente = valorEsIndependiente;
    }
   
    //Método SETTER para fijar el número de fuegos
    public void setNumeroFuegos(int valorNumeroFuegos){
        numeroDeFuegos = valorNumeroFuegos;
    }
   
    //Método GETTER para obtener si la cocina es o no independiente
    public boolean getEsIndependiente(){
        return esIndependiente;
    }
   
    //Método GETTER para obtener el número de fuegos
    public int getNumeroFuegos(){
        return numeroDeFuegos;
    }
   
   
   
   
   
}

Código de Casa

Código: [Seleccionar]

public class Casa{
   
    //ATRIBUTOS
    private double superficie;
    private String direccion;
    private SalonCasa salonCasa;
    private CocinaCasa cocina;
   
    //CONSTRUCTOR 1: Sin atributos
    public Casa(){
        superficie = 0.0;
        direccion = "desconocida";
        salonCasa = new SalonCasa();
        cocina = new CocinaCasa();
    }
   
    //CONSTRUCTOR 2: Con atributos
    public Casa (SalonCasa objetoSalonCasa, CocinaCasa objetoCocina){
    superficie = 132.00;
    direccion = "Avenida Vilallonga, 3";
    salonCasa = new SalonCasa(objetoSalonCasa.getNumeroTelevisores(), objetoSalonCasa.getTipoSalon());
    cocina = new CocinaCasa(objetoCocina.getNumeroFuegos(), objetoCocina.getEsIndependiente());
}
   
}

Obvio aún no he terminado pero he compilado para probar y me salta este error:
"incompatible types: int cannot be converted to boolean." Entiendo bien lo que dice pero no encuentro ni de coña donde está el error.

Me marca en cocina = new CocinaCasa(objetoCocina.getNumeroFuegos(), objetoCocina.getEsIndependiente());

Otra duda que tengo es:
Si no pongo el constructor 1, pasa algo?

Gracias!!

[Kabuto]

El error creo que se debe a que no respetas el orden de los parámetros que pasas.

El constructor de Cocina Casa espera primero un booleano y luego un entero
Pero tu en esta línea se los estás pasando en otro orden:

Código: [Seleccionar]

cocina = new CocinaCasa(objetoCocina.getNumeroFuegos(), objetoCocina.getEsIndependiente());
Cambialo así:

Código: [Seleccionar]

cocina = new CocinaCasa(objetoCocina.getEsIndependiente(), objetoCocina.getNumeroFuegos());
Es decir un constructor declarado como Constructor (int, boolean) es diferente de Constructor(boolean, int).

Aunque se llamasen exactamente iguales, Java los diferenciaría por el orden de los parámetros que espera recibir.

[Hquinn]

Mil gracias, Kabuto!! Ahora le veo el sentido a la frase que me decía xD

Funciona perfecto Voy a continuar!

Gracias otra vez!

[Kabuto]

De nada, un placer 

Es importante saber que en Java (y otros lenguajes) los métodos (ya sean constructores, funciones, procedimientos..) no solo se distinguen por el nombre que les damos, si no también por el tipo, orden y cantidad de parámetros que le indicamos que tiene que recibir.

De hecho, en una clase podemos tener definidos métodos con el mismo nombre y al lenguaje no le importará que los nombres se repitan, siempre y cuando varíen el tipo, orden y/o la cantidad de parámetros que recibirán.
Así, podríamos tener declarados:

miMetodo(int n){...};
miMetodo(double n){...};
miMetodo(float n){...};
miMetodo(String s){...};
miMetodo(boolean b){...};
miMetodo(int n, int m){...};
miMetodo(int n, int m, boolean b){...};
etc...

Podríamos repetir el nombre "miMetodo" tantas veces como quisieramos, que Java ejecutará un código u otro según los parámetros que le pasemos cuando hagamos la llamada al método.
No es recomendable hacer esto porque obviamente se presta a confusiones.

Sin embargo, en determinados casos puede tener sentido hacerlo y de hecho en la misma API de Java podemos encontrar multitud de métodos con el mismo nombre pero que reciben distinto número de parámetros. Eso sí, son métodos que hacen prácticamente lo mismo, por eso tiene sentido que se llamen igual.

En el caso concreto de los constructores (que son métodos en realidad), es totalmente normal crear varios con el mismo nombre pero recibiendo más o menos parámetros.
Lo normal, como tú mismo has hecho ya en tu código, es tener como mínimo el constructor básico que no recibe parámetros, y otro que recibe tantos parámetros como atributos tenga la clase (al menos los atributos que dependan de la información que proporciona el usuario).
Pero podría tener más. Supongamos una clase con 6 atributos por ejemplo, pues podrías tener constructores que solo recibe un parámetro, que recibe dos, que recibe tres, que recibe cuatro....y los otros atributos que no se reciben los inicializas tú en el código.

Como digo, esto se podría hacer y a Java le parecerá válido y correcto. Otra cosa es que a ti como programador te interese o no "complicar" tu código con tantos constructores. Sobre todo si luego vas a compartir tu clase con otros programadores, por muy bien que la documentes y expliques cada método y constructor, para el que no creó ese código le resultará confuso encontrarse con tantos constructores.

Siempre habrá casos concretos que pueda interesar tener algún constructor más de los dos habituales (con y sin parámetros), pero por lo general lo ideal es tener solo esos dos.


Antes preguntabas, si había algún problema en no poner el "constructor 1", el "básico" que no recibe parámetros.
No pasa nada si no lo pones, Java ya crea un constructor por "defecto" para este caso.
Pero es buena costumbre de programador crearlo tú, y además así te aseguras de que los atributos se inicializan a unos valores conocidos por ti, por ejemplo los típicos de "0" para los numéricos, cadena vacía "" para los String y espacio en blanco ' ' para los tipo char.

Esto te puede evitar luego sorpresas raras.

[Hquinn]

Que explicación tan genial!!

Me dan ganas de enmarcarla xD muchas gracias!

Me ha quedado super claro