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

Hola César.

Muy buena explicación, hay un error de números en la cuenta final pero se entendió perfectamente el planteo.
Intuía que se trataba de cuestiones no inherentes a la propia perfomance de las clases (ya que el API de Java nos marca claramente las bondades de una y otra clase).
Entre esas cuestiones que denominaba "externas" no había tenido en cuenta que el acceso a memoria es por bloques, y es allí en donde podría explicarse esta diferencias de resultados.
Muy gráfica tu explicación y como siempre con mucha claridad conceptual.

Si hay otro aporte que clarifique este fenómeno nos sería bienvenido también.

Saludos!

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)

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)

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):

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:

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).

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í:

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!

Hola Ronal.

Felicitaciones por iniciar un hilo con tu propio ejercicio.
Estuve analizándolo y por mi parte lo veo muy bien! Destaco la buena organización del código incluyendo comentarios.

La única observación que haría es respecto a los nombres de los parámetros de los métodos set.
Por ejemplo, el método setTipoBomba:

public void setTipoBomba(int establecerTipoBomba){
        tipoBomba = establecerTipoBomba;
    }
el parámetro del método es establecerTipoBomba. El nombre parece ser más pertinente para nombrar un método que para nombrar un parámetro. Después de todo setTipoBomba lo que hace es establecer el tipo de bomba, cierto? Creo (en mi opinión) que quizás sería más apropiado renombrar el parámetro con un nombre al estilo de valorTipoBomba

public void setTipoBomba(int valorTipoBomba){
        tipoBomba = valorTipoBomba;
    }
y haría lo mismo para los demás métodos set.

Lo vienes haciendo muy bien, a seguir adelante!

Hola Ronald!

Antes de meternos directamente con el código que has publicado quisiera pedirte lo siguiente:
Cuando quieras poner en los foros tu solución para un ejercicio 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.

En otro orden de cosas (pero también por cuestiones de orden), cuando publiques los códigos, asegúrate que el código vaya entre las etiquetas [ code ] [ /code ] .
Puedes leer este link https://www.aprenderaprogramar.com/foros/index.php?topic=1460.0 donde se explica muy bien cómo realizar una publicación en el foro.

Ahora sí, vayamos a la respuesta del ejercicio que has enviado:
Has cometido dos errores, te marco las respuestas correctas:

c) A<C es Flaso.
n) (A+B==8)||(A-B==6) es Verdadero

Respecto de la (c), fíjate que A que vale 5 es mayor que C que vale -12, por lo tanto la proposición es falsa.

Respecto de la (n):
Analicémos la proposición separado las partes.
Primero hagamos la evaluación de (A+B==8) = ( 3+5  ==  8 ) lo cual es verdadero.
Ahora bien (A-B==6) = (5-3 == 6) es flaso
Por lo tanto : (verdadero)||(flaso) = verdadero

Respuesta final: verdadero.

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

Hola Ronald!

Veo que eres nuevo en el foro, así que me toca hacer las veces de anfitrión: Bienvenido! 

Antes de meternos directamente con el código que has publicado quisiera pedirte lo siguiente:
cuando quieras poner en los foros tu solución para un ejercicio 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.

En otro orden de cosas (pero también por cuestiones de orden), cuando publiques los códigos, asegúrate que el código vaya entre las etiquetas [ code ] [ /code ] .
Puedes leer este link https://www.aprenderaprogramar.com/foros/index.php?topic=1460.0 donde se explica muy bien cómo realizar una publicación en el foro.

Ahora sí, vayamos al código que has enviado.
Al código lo veo muy bien, está bien estructurado y has tenido en cuenta la convención para nombrar los campos y los métodos, muy bien por ello!
El Constructor también está perfecto , incializando todos los campos de instancia a valor por defecto.

He de hacerte una observación con respecto a la declaración de los campos de instancia. Tu declaración de campos de instancia es:

public class Medico {
    String nombre, apellido;
    String numeroDocumentoIdentidad;
    String especialidad;
    int edad;
    boolean casado;
    Medico med1 = new Medico();
¿Por qué incluyes aquí la línea ?

Medico med1 = new Medico();
No deberías crear un objeto tipo Medico en esta parte del programa, no hay razón para ello. Te sugiero la elimines.

Y para finalizar, quisiera apuntarte algo respecto del método setNombreApellido de tu código

    public void setNombreApellido(String insertarNombre, String insertarApellido){
        nombre = insertarNombre;
        System.out.println("Se ha cambiado el nombre anterior por"+nombre);
        apellido = insertarApellido;
        System.out.println("se ha cambiado el apellido anterior por"+apellido);       
    }
No sería correcto tener un método set que modificara dos campos de instancia a la vez.
Así como luego defines un método tipo función getNombre() que devuelve el campo nombre del objeto, y un método tipo función getApellido() que devuelve el campo apellido del objeto, pues entonces es correcto tener un método setNombre y un método setApellido que asignen valores a sus respectivos campos de manera independiente.
Te sugiero que desdobles esa función en dos funciones tipo procedimiento: una llamada setNombre y la otra llamada setApellido.

Hola javalopez:

Revisé tu código y he de decirte que tu ejercicio está muy bien! Felicitaciones.
Destaco sobre todo que el código está muy bien estructurado, y que has nombrado las clases, los métodos, y los parámetros respetando las convenciones.

Me resta únicamente hacerte una observación que es la siguiente:
En el constructor de la clase Casa se deberían inicializar todas los campos de instancia. Es decir que además de crear los objetos tipo SalonCasa y CocinaCasa, deberíamos inicializar el campo dirección y superficie a valores por defecto.
La consigna del ejercicio decía:

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.

De esta manera el constructor de la clase Casa quedaría:

    public Casa(){
        salonCasa=new SalonCasa();
        cocinaCasa=new CocinaCasa();
        superficie=0.0;
        direccion="";
    }
Por último destaco hayas codificado un nuevo método, el cual no se pedía en la consigna del ejercicio, celebro esa iniciativa!
El nombre del método getDatosCasa() está perfectamente elegido ya que has definido un método tipo función, donde se devuelve un atributo tipo String llamado datosCasa.
Una cuestión interesante de analizar es la siguiente: si el método tipo funcion  getDatosCasa() devuelve un String, esa debería ser su única tarea, es para lo que sirve el método, una tarea bien específica. Por lo tanto no debería exisitir aquí una línea como:

System.out.println (datosCasa);
pero por el momento dejaremos esta línea en el método.
Pero sí ten en cuenta para el futuro, que un método que imprima por consola, debería ser un método tipo procedimiento y cuya función solamente fuese esa: sacar datos por consola (no retornar datos), a la cual podríamos nombrar como mostrarDatosCasa() o un nombre similar.

Está muy bien el cambio que hiciste en convertir el método comprobarLetra en tipo procedimiento.

Sin embargo, fíjate que tal como está tu clase ahora, si las palabras tienen distinta cantidad de letras, no se indica por consola que "La palabraX no tiene letra N".
Eso es debido a lo que te indiqué en el post anterior. ¿Recuerdas que tenías dos if (con sus respectivos else) seguidos en tu código?. Debías borrar el primer if con sus respectivo else. Tu borraste el segundo if con su else (que era el que funcionaba bien).

Analicemos ese segundo if que funciona correctamente:

if (palabra_1.length() < palabra_2.length()) {
            limiteInf = palabra_1.length();
            text = 1;
            limiteSup = palabra_2.length();
        } else {
            limiteInf = palabra_2.length();
            text = 2;
            limiteSup = palabra_1.length();
        }
Fíjate que si la longitud de la plabra_1 es menor a la longitud de la palabra_2 , pues entonces a la variable limiteInf se le asigna la longitud de la palabra_1 , y a la variable limiteSup se le asigna la longitud de la la palabra_2

(el else haría lo contrario).

Por lo tanto la clase completa nos quedaría:

package ejercicioscu00662b;
public class VerificarLetra {

    public void comprobarLetra(String palabra_1, String palabra_2) {
        int limiteSup;
        int limiteInf;
        int text;

        if (palabra_1.length() < palabra_2.length()) {
            limiteInf = palabra_1.length();
            text = 1;
            limiteSup = palabra_2.length();
        } else {
            limiteInf = palabra_2.length();
            text = 2;
            limiteSup = palabra_1.length();
        }
        for (int i = 0; i < limiteSup; i++) {
            if (i < limiteInf) {
                System.out.println("¿Letra " + (i + 1) + " igual en las dos palabras? " + (palabra_1.substring(i, i + 1).equals(palabra_2.substring(i, i + 1))));
            } else {
                System.out.println("La palabra " + text + " no tiene letra " + (i + 1));
            }
        }

    }
}

Analízalo, y cualquier duda acá estamos para ayudarte!

Un método puede llamar a otro método? Si, eso es posible. Sin embargo ten en cuenta a estas alturas del curso lo siguiente: en programación orientada a objetos cada método tendrá una tarea bien definida y específica.

Fíjate lo que sucede por ejemplo en este ejercicio. Tomemos por ejemplo el método setNombre(String valorNombre). Este método tiene como tarea establecer el nombre del objeto tipo Medico con el valor que se pasa como argumento, y nada más que eso. Su tarea es bien definida y específica.
Lo mismo sucede con el método getEspecialidad(). Su tarea consiste en devolver un atributo tipo String que contiene la especilidad de ese objeto. Una vez más, la tarea es bien definida y específica.

En lo que propones de definir un método que pida la edad, y dentro de él llamar al método que calcula los años que restan para un número múltiplo de 5, a simple vista diríamos que no, debería existir un método que pida la edad, y otro método diferente que calcule el múltiplo de edad. Es decir dos métodos donde cada uno de ellos tenga una tarea específica.
Luego sobre ese objeto invocaremos uno u otro método, o uno a continuación del otro, según las necesidades que tengamos, pero ambos métodos deberán ser independientes.

Muy buena tu explicación Alex. Hacía un tiempo que venía viendo en el API de Java estos signos "?" y no sabía de qué se trataría.

De más está decir que ese texto que transcribiste no tiene ni una coma de desperdicio! Magistralmente esclarecedor. Su lectura -como suele pasar- me llevó a investigar otros temas, en este caso: tipos y métodos genéricos.
Y como siempre, escribir y probar código para poner las cosas en práctica con distintas variantes. Pienso es la mejor forma de ir madurando e incorporando los conceptos.

Muchas gracias Alex, como siempre muy interesantes tus aportes!