CU00641B - Clases que utilizan objetos pasar objetos como parámetros Java

[LPM]

Hola, tengo una consulta. Una parte del código que dan como ejemplo aparece esto

Código: [Seleccionar]

public String getDatosTaxiCond () {
        String matricula = vehiculoTaxi.getMatricula();
        String distrito = vehiculoTaxi.getDistrito();
        int tipoMotor = vehiculoTaxi.getTipoMotor();
        String cadenaTipoMotor = "";

        if (tipoMotor ==0) { cadenaTipoMotor = "Desconocido"; }
        else if (tipoMotor == 1) { cadenaTipoMotor = "Gasolina"; }
        else if (tipoMotor == 2) { cadenaTipoMotor = "Diesel"; }

        String datosTaxiCond = "El objeto TaxiCond presenta estos datos. Matrícula: " + matricula +
            "\n Distrito: " + distrito + " Tipo de motor: " + cadenaTipoMotor;

        System.out.println (datosTaxiCond);
        return datosTaxiCond;
Crea variables locales y le asignan los métodos de las otras clases.

Pregunto, se podría hacer directo? algo así?

Código: [Seleccionar]

public String getDASDASDASDSA () {
       
        String cadenaTipoMotor = "";

        if (vehiculoTaxi.getTipoMotor() ==0) { cadenaTipoMotor = "Desconocido"; }
        else if (vehiculoTaxi.getTipoMotor() == 1) { cadenaTipoMotor = "Gasolina"; }
        else if (vehiculoTaxi.getTipoMotor( )== 2) { cadenaTipoMotor = "Diesel"; }

        String datosTaxiCond = "El objeto TaxiCond presenta estos datos. Matrícula: " + vehiculoTaxi.getMatricula()+"  \nDistrito+: " + vehiculoTaxi.getDistrito() + " Tipo de motor: " + cadenaTipoMotor;

        System.out.println (datosTaxiCond);
        return datosTaxiCond;
    }
Funciona bien, pero no se si se consideraria adecuado el modo para programar

[toni_apr]

Hola LPM
Si, es válido, igualmente correcto, adecuado también. Es adecuado para tí, que lo has diseñado así y además de funcionar, te gusta.
Lo que si tiene, es que es más difícil de leer y de seguir.

Si que consideraría más adecuado el primer método (con variables locales), si en ese método se tuviera que usar varias veces la matricula o el distrito. En ese caso sería más adecuado usar la variable local que llamar repetidas veces a un método externo.

Saludos

[Jorge lopez]

 Hola LMP!

Funciona bien, pero no se si se consideraría adecuado el modo para programar

Aunque como bien dices, funciona bien, esta forma de hacer esta tarea "no es recomendable" de un todo he intentare explicarte porque.

En java hay muchos factores que nos ayudan a mantener un orden a la hora de diseñar un código, un factor de estos (por mencionarte uno que otro) es un "simple" convenio entre programadores donde se a convenido que el nombre de una clase debe de comenzar siempre con una letra mayúscula, por tal motivo cuando por ejemplo yo creo una clase con nombre: persona donde al compilar la clase no me salta ningún error y todo sale bien, pero cuando otro programador con experiencia mira mi código nota que tengo una clase persona donde debería tener una clase Persona.

Que el nombre de mi clase inicie o no con una letra mayúscula ya es opción y responsabilidad mía como programador, puesto que el compilador java en cuanto a funcionamiento admite cualquiera de las dos formas, pero yo como programador debo de siempre pensar en hacer siempre lo correcto para diseñar un código de calidad donde también es importante el aspecto visual de mi código.

Porque es recomendable decir: "El objeto TaxiCond presenta estos datos. Matrícula: " + matricula... en lugar de decir: "El objeto TaxiCond presenta estos datos. Matrícula: " + getMatricula()...? Yo diría que por diversos motivos. 1ro: La forma correcta de declarar la variable matricula en la clase de este ejercicio es: private String matricula; Donde al declararla como private estamos indicando que dicha variable solo podrá ser usada por su clase y no por otras clases. El método getMatricula(); esta declarado como public, porque esta pensado para ser usado por otras clases interesadas en conocer el valor de la variable matricula, pero que no pueden usar directamente la variable matricula porque dicha variable esta declarada como private. Para que relaciones todo esto con tu duda te explico que un método get, no debería invocarse desde su propia clase, si no que en su lugar se usa la variable en si, por ejemplo lo correcto seria decir: System.out.println(matricula); y no decir: System.out.println(getMatricula());

2do: Un buen programador debe de optar siempre por diseñar un código lo mas corto claro y eficiente posible. Porque diría yo: System.out.println(getMatricula());? cuando puedo decir: System.out.println(matricula); donde obtendré el mismo resultado por pantalla, pero con esta ultima forma me ahorro tiempo al escribir por ser una linea de código mas corta (con menos caracteres) y también me ahorraría espacio en mi código por la misma razón y estoy diseñando un código mas corto y claro con la misma eficiencia de usar una forma u otra. Esto de ahorrar tiempo y espacio tal vez sea "insignificante" en una linea de código, pero recuerda que un código puede contener miles y miles de lineas de código, donde esto si seria bastante relevante.

3ro: Cuando uso una sintaxis como: System.out.println(matricula); estoy diseñando un código bajo un standar de programación (la mayoría de programadores del mundo lo hacen así) igual que declarar el nombre de una clase iniciando con letra mayúscula, por tanto, si otro programador mira mi código no notara algo "raro" a diferencia de si se encuentran con algo como: System.out.println(getMatricula()); en la clase propia de la variable matricula.

Espero que mi explicación te sea útil, y como siempre, cualquier duda no dudes en preguntar.

Saludos!

[LPM]

Gracias por responder a ambos.

Tal vez al ser codigos cortos, no parezca que haya diferencia, pero sí, como dicen, puede ser complicado al trabajar con programas de verdad.

Estuve revisando la siguiente entrega del curso, CU00642B, pasar objetos como parámetros.

Hay que crear instancias de las clase Taxi y Persona. Luego crear un objeto con el segundo constructor de TaxiCond

Código: [Seleccionar]

public class TaxiCond {
    private Taxi vehiculoTaxi;
    private Persona conductorTaxi;
   
    public TaxiCond () {
        vehiculoTaxi = new Taxi (); //Creamos un objeto Taxi con el constructor general de Taxi
        conductorTaxi = new Persona (); //Creamos un objeto Persona con el constructor general de Persona
    }

    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() );     }
       
    public void setMatricula (String valorMatricula) { vehiculoTaxi.setMatricula(valorMatricula); }

    public String getDatosTaxiCond () {
        String matricula = vehiculoTaxi.getMatricula();
        String distrito = vehiculoTaxi.getDistrito();
        int tipoMotor = vehiculoTaxi.getTipoMotor();
        String cadenaTipoMotor = "";

        if (tipoMotor ==0) { cadenaTipoMotor = "Desconocido"; }
        else if (tipoMotor == 1) { cadenaTipoMotor = "Gasolina"; }
        else if (tipoMotor == 2) { cadenaTipoMotor = "Diesel"; }

        String datosTaxiCond = "El objeto TaxiCond presenta estos datos. Matrícula: " + matricula +
            "\n Distrito: " + distrito + " Tipo de motor: " + cadenaTipoMotor;

        System.out.println (datosTaxiCond);
        return datosTaxiCond;
    }

    public void setTipoMotor (int valorTipoMotor){vehiculoTaxi.setTipoMotor(valorTipoMotor);}
}
Bueno, como objeto del parámetro le pasé el objeto taxi1 que lo creé con un constructor que pedía parámetros.

Al inspeccionar el objeto taxiCond1,  me muestra los valores de  taxi1, tambien el del objeto creado de Persona. Hasta ahí bien, y espero se entienda lo que voy diciendo.

Luego, al código TaxiCond le cambié esto:

Código: [Seleccionar]

  public TaxiCond (Taxi objetoTaxi, Persona objetoPersona) {
        vehiculoTaxi = new Taxi (objetoTaxi.getMatricula(), objetoTaxi.getDistrito(), objetoTaxi.getTipoMotor() );
        conductorTaxi = new Persona (objetoPersona.getNombre() );     }
       

y lo dejé así:

Código: [Seleccionar]

  public TaxiCond (Taxi objetoTaxi, Persona objetoPersona) {
        vehiculoTaxi = new Taxi ( );
        conductorTaxi = new Persona (objetoPersona.getNombre() );     }
       

Y ahora, cuando inspecciono taxiCond1,  no me figuran los datos que puse usando el segundo constructor de Taxi, que me pedía parámetros, sino con el primer constructor, sin parámetros.


aver si logro explicarme mejor.

Tengo la clase Taxi con 2 constructores. el primero no pide parámetros pero tiene sus variables inicializadas con a,b,c y d; y el segundo constructor me pide parámetros. creé un objeto taxi1 con el segundo constructor. sus valores son 1,2,3 y 4.

ahora, el segundo constructor de la clase TaxiCond me pide  como parámetro un objeto Taxi. Le pasé taxi1, pero al inspeccionar no me muestra los valores 1,2,3,4 con los que creé taxi1, sino que me muesta los valores a,b,c y d.

Lo que me marea es que,  vehiculoTaxi = new Taxi (objetoTaxi.getMatricula() muestre bien el valor de matricula, mientras que vehiculoTaxi = new Taxi () me muestre un valor que ni tiene taxi1

Me cuesta muchisimo entender el por qué, ni puedo explicarme bien.

Help!

xd


Aver, metodo funcion devuelve algo. get... getMatricula devolveria el valor de matricula del objeto taxi1. 

Al sacar este parámetro "objetoTaxi.getMatricula()", no se qué es lo que pasa, por ahora se me ocurre que al crear la clase TaxiCond...

Código: [Seleccionar]

public class TaxiCond {
    private Taxi vehiculoTaxi;
    private Persona conductorTaxi;
al declarar la variable vehiculoTaxi, de por sí inicializa el constructor sin parámetros que tiene Taxi, que es:

public Taxi () {

        ciudad = "Mexico D.F.";       

        matricula = "asd123";

        distrito = "Desconocido";

        tipoMotor = 2;

[Jorge lopez]

 Hola nuevamente LMP!

Intentare sacarte de tu confusion exponiendo una situación imaginaria .

Imagina que te invitan a una fiesta, la persona que te invita te dice: debes de llevar un frasco conteniendo tinta para zapatos de color rojo (esto seria un parámetro en un constructor) para que el portero te deje entrar a la fiesta, cuando llegues a la entrada le muestras el frasco al portero y el te dejara pasar y también te dejara conservar el frasco. Una vez que estés dentro, yo estaré esperando por ti y te regalare unos zapatos nuevos,
(los zapatos nuevos representan la expresión: new Taxi(); ) puedes usar tu frasco de tinta para tintar tus zapatos nuevos o bien puedes no usarlo y dejar tus zapatos nuevos de color negro.

Ahora intentare relacionar esta situación imaginaria con tu confusion: Un parámetro es como una llave para poder entrar (frasco de tinta) o ejecutar las instrucciones que contenga un método o constructor, normalmente el valor de un parámetro se usa en el cuerpo (el cuerpo de un método o constructor esta comprendido entre las llaves {...}) de un método o constructor, pero también un método o constructor puede pedir un parámetro pero no hacer uso de este en su cuerpo, (aunque no es lo normal) fíjate que en la fiesta el portero te deja entrar porque llevas lo que se te pide
(un frasco con tinta roja para zapatos) pero el portero no te dice y mucho menos te obliga a pintar los zapatos nuevos que yo te he regalado con la tinta que tienes en el frasco.

En tu nuevo constructor:

Código: [Seleccionar]

public TaxiCond (Taxi objetoTaxi, Persona objetoPersona) {
        vehiculoTaxi = new Taxi ( );
        conductorTaxi = new Persona (objetoPersona.getNombre() ); } indicas lo siguiente: Este constructor solicita dos parámetros para poder ejecutarse,
(igual que como en la fiesta te solicitan el frasco con tinta para que puedas entrar) si le pasas como parámetros números enteros, el constructor te negara la entra o ejecución, porque lo que solicita es un objeto Taxi y un objeto Persona.

Una vez introduces los parámetros correctos indicas que la varia tipo Taxi "vehiculoTaxi" sera igual a un nuevo objeto de la clase Taxi, pero el hecho de que el parámetro que acabas de pasarle al constructor lo ayas construido con su constructor con parámetros, no incide en la creación del objeto de la variable "vehiculoTaxi", es como que entraste a la fiesta con tu frasco de tinta pero no tintaste tus zapatos, no le diste ningún uso al frasco.

No es lo mismo decir: regalo = new Zapatos(); a decir regalo = new Zapatos(frasco.tintarZapatos()); donde en el primer código tienes unos zapatos negros y en el segundo tienes unos zapatos rojos.

Tampoco es lo mismo decir: vehiculoTaxi = new Taxi(); a decir: vehiculoTaxi = new Taxi(objetoTaxi.getMatricula(), objetoTaxi.getDistrito(), objetoTaxi.getTipoMotor()); donde en el primer código creas un objeto de la clase Taxi usando el constructor general (sin parámetros) de la clase Taxi y en el segundo código creas un objeto de la clase Taxi usando el constructor con parámetros de la clase Taxi, pasandole los valores que has indicado en el parámetro objetoTaxi.

Espero que captes la idea, pero si aun te cuesta comprender después de esta "explicación" te recomiendo continuar avanzando en el curso, puesto que cosas que hoy te parecen super difíciles las dominaras mas adelante y luego te reirás cuando recuerdes que una vez tuviste una confusion en tan "sencilla" situación.

Saludos!

[LPM]

sí, voy entendiendo un poco mas cada vez que leo tu explicación.

pedir parámetros en un método no implica que, bueno,. como vos decís, lo tengas que usar sí o sí.

en un método pido como parámetro el objeto "x" de la clase "y"
en el cuerpo del método creo un nuevo objeto de la clase "y", que se inicializará con su constructor por defecto.

a=1
b=2
c=3
d=4

al instanciar, si quiero le paso algún valor del objeto "x"  invocando un método getter, el cual me devuelve el valor de ese objeto.

por ejemplo, getD, que me devuelve el valor de "d" en el objeto "x".



masomeno eso entendi. la idea creo que la tengo. igual es como vos decís también, seguir con el curso, seguir aprendiendo.

gracias por la ayuda, y por los zapatos.

xd

[Jorge lopez]

gracias por la ayuda, y por los zapatos.

        
              
              
        .