Java Ejercicio resuelto constructores con parámetros y sin parámetros CU00642B

[javalopez]

Buenas noches, antes que nada quiero agradecerles por todas las devoluciones que tan gentilmente me dan a cada ejercicio que les envío.
Hoy he realizado el ejercicio cuu00642b y me gustaría que vean el código y me indiquen si hay cosas que corregir. Muchas gracias!

Código: [Seleccionar]

public class SalonCasa{
    private int numeroDeTelevisores;
    private String tipoSalon;

    public SalonCasa(){
        numeroDeTelevisores=0;
        tipoSalon="Desconocido";
    }

    public SalonCasa (int valorNumeroDeTelevisores, String valorTipoSalon) {
        numeroDeTelevisores=valorNumeroDeTelevisores;
        tipoSalon=valorTipoSalon;
    }

    public void setNumeroDeTelevisores(int valorNumeroDeTelevisores){numeroDeTelevisores=valorNumeroDeTelevisores;}

    public void setTipoSalon(String valorTipoSalon){tipoSalon=valorTipoSalon;}

    public int getNumeroDeTelevisores(){return numeroDeTelevisores;}

    public String getTipoSalon(){return tipoSalon;}

}


public class CocinaCasa{

    private boolean esIndependiente;
    private int numeroDeFuegos;

    public CocinaCasa(){
        esIndependiente=false;
        numeroDeFuegos=0;
    }

    public CocinaCasa(boolean valorEsIndependiente, int valorNumeroDeFuegos){
        esIndependiente=valorEsIndependiente;
        numeroDeFuegos=valorNumeroDeFuegos;
    }

    public void setEsIndependiente(boolean valorEsIndependiente){esIndependiente=valorEsIndependiente;}

    public void setNumeroDeFuegos(int valorNumeroDeFuegos){numeroDeFuegos=valorNumeroDeFuegos;}

    public boolean getEsIndependiente(){return esIndependiente;}

    public int getNumeroDeFuegos(){return numeroDeFuegos;}
}



public class Casa{
    private double superficie;
    private String direccion;
    private SalonCasa salonCasa;
    private CocinaCasa cocinaCasa;

    public Casa(){//constructor sin parametros
        superficie=0;
        direccion="";
        salonCasa=new SalonCasa();
        cocinaCasa=new CocinaCasa();
    }

    public Casa(double valorSuperficie,String valorDireccion, SalonCasa objetoSalonCasa, CocinaCasa objetoCocinaCasa){
        superficie=valorSuperficie;
        direccion=valorDireccion;
        salonCasa=new SalonCasa(objetoSalonCasa.getNumeroDeTelevisores(),objetoSalonCasa.getTipoSalon());
        cocinaCasa=new CocinaCasa(objetoCocinaCasa.getEsIndependiente(), objetoCocinaCasa.getNumeroDeFuegos());
    }

    //Metodos que ingresan informacion
    public void setSuperficieCasa(double valorSuperficie){
        superficie=valorSuperficie;
    }

    public void setDireccionCasa(String valorDireccion){
        direccion=valorDireccion;
    }

    //metodo que devuelve la información sobre el objeto Casa.
    public String getDatosCasa(){
        int numeroDeTelevisores=salonCasa.getNumeroDeTelevisores();
        String tipoSalon=salonCasa.getTipoSalon();
        boolean esIndependiente=cocinaCasa.getEsIndependiente();
        int numeroDeFuegos=cocinaCasa.getNumeroDeFuegos();
        String datosCasa="El objeto Casa, presenta las siguientes características: Se encuentra ubicada en la calle: " +direccion+ ". Cantidad de metros cubiertos: " +superficie+ ". Cantidad de televisores: " +numeroDeTelevisores+ ". Tipo de salon: " +tipoSalon+ ". La cocina es independiente: " +esIndependiente+ ". El artefacto cocina posee " +numeroDeFuegos+ " fuegos.";
        System.out.println (datosCasa);
        return datosCasa;
    }
}

[RaGa]

Hola javalopez:

He estado revisando tu código y en mi opinión considero que está perfecto! Destaco como siempre la buena organización interna de las clases, el hecho de que nombras parámetros, métodos, y clases según convención, y los comentarios que vas agregando en el código.

Te hago una sugerencia para tus próximas publicaciones así las clases quedan mejor presentadas: asegúrate que entre [ code ] [ /code ] vaya el código de una sola clase.

Por ejemplo en el caso de este ejercicio, las tres clases hubieran quedado:

[ code ]  aquí iría el código de la clase SalonCasa [ /code ]

[ code ]  aquí iría el código de la clase CocinaCasa [ /code ]

[ code ]  aquí iría el código de la clase Casa [ /code ]

De esta manera la publicación se presenta más ordenado sin que estén los tres códigos juntos.

Volviendo al ejercicio. Aprovechando que lo resolviste correctamente, te planteo un ejercicio dentro del ejercicio.
Supongamos que hago un cambio en la clase Casa que codificaste. Supongamos que ese cambio consiste en cambiar el Constructor con parámetros de tal manera que quede así:

Código: [Seleccionar]

public Casa(double valorSuperficie,String valorDireccion, SalonCasa objetoSalonCasa, CocinaCasa objetoCocinaCasa){
        superficie=valorSuperficie;
        direccion=valorDireccion;
        salonCasa= objetoSalonCasa;
        cocinaCasa= objetoCocinaCasa;
Pregunta: ¿cuál es la diferencia? ¿qué implicancias trae este cambio?

Saludos!

[javalopez]

Buenas tardes RaGa, la diferencia va a residir en los constructores de las clases SalonCasa y CocinaCasa, para el ejemplo que tu me envías, los constructores de estas clases no deberían recibir parámetros para poder crear el objeto y no dar error al intentar compilar el código.
Para que funcione bien el código que tu me envías las clases SalonCasa y CocinaCasa deberían tener constructores como:

Código: [Seleccionar]

public SalonCasa(){
        numeroDeTelevisores=0;
        tipoSalon="Desconocido";
    }

Código: [Seleccionar]

public CocinaCasa(){
        esIndependiente=false;
        numeroDeFuegos=0;
    }
Espero haber dado en el clavo!

Saludos!

[RaGa]

Hola javalopez:

Creo no aclaré (y pido disculpas por ello), es que en este "ejercicio bis" tanto la clase SalonCasa como la clase CocinaCasa quedaban exactamente iguales a lo que publicaste, lo único que cambiaba era el Constructor con parámetros de la clase Casa que es a donde apuntaba mi pregunta.

Paso a explicar la diferencia para que lo analices:

Constructor con parámetros de la clase Casa (original)

Código: [Seleccionar]

public Casa(double valorSuperficie,String valorDireccion, SalonCasa objetoSalonCasa, CocinaCasa objetoCocinaCasa){
        superficie=valorSuperficie;
        direccion=valorDireccion;
        salonCasa=new SalonCasa(objetoSalonCasa.getNumeroDeTelevisores(),objetoSalonCasa.getTipoSalon());
        cocinaCasa=new CocinaCasa(objetoCocinaCasa.getEsIndependiente(), objetoCocinaCasa.getNumeroDeFuegos());
    }
Constructor con parámetros de la clase Casa (modificado)

Código: [Seleccionar]

public Casa(double valorSuperficie,String valorDireccion, SalonCasa objetoSalonCasa, CocinaCasa objetoCocinaCasa){
        superficie=valorSuperficie;
        direccion=valorDireccion;
        salonCasa= objetoSalonCasa;
        cocinaCasa= objetoCocinaCasa;
la diferencia si te fijas bien, está en la asignación que le hacemos a los campos de instancia tipo objeto, que son salonCasa y cocinaCasa.

El Constructor recibe entre otros parámetros, un objeto llamado objetoSalonCasa, y en la siguiente línea (del Constructor original):

Código: [Seleccionar]

salonCasa=new SalonCasa(objetoSalonCasa.getNumeroDeTelevisores(),objetoSalonCasa.getTipoSalon());
al campo de instancia salonCasa se le asigna un nuevo objeto. ¿Cómo sé que se le asigna un nuevo objeto? porque después del signo '=' fíjate que se utiliza la sentencia new y se le pasan todos los parámetros necesarios para que el constructor de la clase SalonCasa instancie un nuevo objeto.

(lo mismo sucede con el campo de instancia cocinaCasa).

Ahora bien, en el Constructor modificado, la asignación que se hace al campo de instancia salonCasa es la siguiente:

Código: [Seleccionar]

salonCasa= objetoSalonCasa;
como vemos, no se instancia un nuevo objeto (no aparece la sentencia new). Lo que se hace es asignarle la referencia del objeto objetoSalonCasa a salonCasa.
Vale decir que luego de esta asignación salonCasa apuntará al mismo objeto que apunta objetoSalonCasa. Entonces: no creamos un nuevo objeto sino que al objeto objetoSalonCasa lo referenciamos (lo apuntamos) tanto con objetoSalonCasa, como con salonCasa.

Como conclusión:
Con el Constructor original, finalmente tendremos dos objetos: un objeto objetoSalonCasa y otro objeto salonCasa, ambos objetos serán tipo SalonCasa.
Con el Constructor modificado, solo tendremos un solo objeto pero referenciado con dos referencias: objetoSalonCasa y salonCasa. Las dos referencias hacen alusión al mismo objeto tipo SalonCasa.

Analízalo y culaquier duda acá estamos para ayudarte.

(Antes de finalizar el post, temo haberme adelantado con esta pregunta que te hice a temas que tal vez aún no hayas visto en el curso respecto de "referencia de objetos". Si es así, dejamos esto pendiente y volvemos sobre ello más adelante).