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

Hola Adrián:

Es correcto lo que dices! Me he confundido yo en mi respuesta anterior:

El ciclo "for (i=0; i < entradaTeclado.length() ; i++) "

asumirá los siguientes valores de "i": 0, 1, 2, y 3 cuando la cadena sea "Hola".
Tienes toda la razón! disculpas por la confusión, se trata de un operador < y no de un operador <=.

Pero vayamos al nudo de nuestro problema y para eso retomemos el código original de la clase, que es el que se publica en la lección:

import java.util.Scanner; //Importación del código de la clase Scanner desde la biblioteca Java

// Definimos una clase EntradaDeTeclado aprenderaprogramar.com

public class EntradaDeTeclado {

    private String entradaTeclado; //Variable de instancia (campo) de la clase

 

    public EntradaDeTeclado ()  { //Constructor

        entradaTeclado="";

        pedirEntrada(); //Esto es una llamada a un método interno. Al crear un objeto ejecutamos el método

    } //Cierre del constructor

 

    public void pedirEntrada ()  {  //Método de la clase         

        Scanner entradaEscaner = new Scanner (System.in);

        entradaTeclado = entradaEscaner.nextLine ();     } //Cierre del método pedirEntrada

 

    public String getEntrada () { return entradaTeclado; } //Cierre del método getEntrada

    public String getPrimeraPalabra ()  {

       /*IMPORTANTE: EN JAVA LOS OBJETOS NO SE PUEDEN COMPARAR USANDO == POR ESO ESTO NO FUNCIONARÁ       

          if (entradaTeclado.substring(0,1)=="j") {

          System.out.println ("Hemos detectado una j");

          } else { System.out.println ("Mira esto:" + entradaTeclado.substring(0,1) ); }*/ 

        for (int i=0; i < entradaTeclado.length() - 1; i++) {

            if (entradaTeclado.substring (i, i+1).equals(" ") ) {     //IMPORTANTÍSIMO: COMPARAMOS CON EQUALS

                return entradaTeclado.substring(0, i+1);         }

        }

        return entradaTeclado;  //Caso de que no se detecte ningún espacio devolvemos lo que haya

    } //Cierre del método getPrimeraPalabra

 

    public int getLongitud ()  {  //Método de la clase

        return entradaTeclado.length();

    } //Cierre del método getLongitud

} //Cierre de la clase
Analizaremos primeramente qué sucede cuando ingresamos distintas cadenas por teclado.

Si la cadena ingresada por teclada fuera: "HolaAmigo", revisemos qué sucedería en el ciclo for:

       for (int i=0; i < entradaTeclado.length()-1 ; i++) {
            if (entradaTeclado.substring (i, i+1).equals(" ") ) {
                    return entradaTeclado.substring(0, i+1);         
            }
        }
El valor de entradaTeclado.length()-1 sería 8. Es decir que:
entradaTeclado.substring (i, i+1).equals(" ")
devolverá desde la letra "H" hasta la letra "g". Se compararán todas las letras de la cadena ingresada menos la última (lo cual no sería estrictamente lo correcto).
De todos modos, como no hay ningún caracter " ", nunca será true el condicional if, y por lo tanto el retorno se alcanzará en la línea:

return entradaTeclado;  //Caso de que no se detecte ningún espacio devolvemos lo que haya
Esta línea nos devuelve la cadena "HolaAmigo".
Fíjate que no podemos darnos cuenta si cuando chequeábamos letra por letra, preguntamos por todas ellas (cosa que no sucedió), ya que lo que se imprime por consola es lo que contiene el campo entradaTeclado, que es "HolaAmigo".

Ahora bien, y qué sucedería si la cadena ingresada fuese "HolaAmigo " (termina en un espacio). Analicemos:

El valor de entradaTeclado.length()-1 sería 9. Es decir que:
entradaTeclado.substring (i, i+1).equals(" ")
devolverá desde la letra "H" hasta la letra "o", y se compararán todas las letras de la cadena ingresada menos el espacio final.
Por lo tanto nunca se alcanzaría a chequear que el último caracter es un espacio. El condicional if nunca sería true, y el retorno se alcanzaría también en la línea:

return entradaTeclado;  //Caso de que no se detecte ningún espacio devolvemos lo que haya
y se devuelve la cadena "HolaAmigo ".

Ultimo cadena a analizar: si la cadena ingresada tuviera un caracter " " en una posición intermedia, por ejemplo si la cadena fuese "Hola Amigo".
Cuando "i" sea igual a 4, el condicional if se convierte en true, y el retorno se alcanza ahora en la línea:

return entradaTeclado.substring(0, i+1);
la cadena retornada será: "Hola " (con un espacio luego de la letra "a").

Ahora bien ¿y si modificamos el límite superior del ciclo for codificandolo de la siguiente manera?

       for (int i=0; i < entradaTeclado.length(); i++) {
            if (entradaTeclado.substring (i, i+1).equals(" ") ) {
                    return entradaTeclado.substring(0, i+1);         
            }
        }
Primer caso:
Si la cadena ingresada fuese "HolaAmigo", ahora
entradaTeclado.substring (i, i+1).equals(" ")
devolverá desde la letra "H" hasta la letra "o". Se compararán todas las letras de la cadena ingresada (lo cual sería lo correcto!).
No hay ningún caracter " ", nunca será true el condicional if, y por lo tanto el retorno se alcanzará en la línea:

return entradaTeclado;  //Caso de que no se detecte ningún espacio devolvemos lo que haya
Esta línea nos devuelve la cadena "HolaAmigo".

Segundo caso:
Si la cadena ingresada fuese "HolaAmigo " (con un espacio al final)
entradaTeclado.substring (i, i+1).equals(" ")
devolverá desde la letra "H" hasta el espacio final. El caracter final " ", haría que el condicional if sea true, y por lo tanto el retorno se alcanzará en la línea:

return entradaTeclado.substring(0, i+1);
Esta línea nos devuelve la cadena "HolaAmigo " (con un espacio al final).

Tercer caso:
Si la cadena ingresada fuese "Hola Amigo" (con espacio intermedio), sucedería lo mismo que ya se analizó.

Conclusión:
Si nos guiamos por los resultados que vemos en la consola, es exactamente igual si ese -1 lo incluímos o no en el límite superior del ciclo for. Pero si analizamos el desarrollo de lo que sucede internamente en el código hay diferencias.

En mi opinión personal, yo sacaría el -1 del límite superior del ciclo for. De esa manera internamente sea chequearían cada una de las letras de la cadena ingresada.

Hola:

Estuve revisando tu ejercicio y lo veo bien.
Recuerda las correcciones que marcamos en el ejercicio

https://www.aprenderaprogramar.com/foros/index.php?topic=2880.0

acerca de la clase EntradTeclado, y sobre el uso de la letra 'ñ' en programación.

Más allá de eso, me gustaría analizar lo siguiente:
Declaras y codificas un recorrido completo de la lista donde se muestran los cantantes a través de la consola, dentro del método main.
A esto no lo veo correcto. Lo más lógico sería que ese recorrido conforme un método en si, y que pertenezca a la clase ListaCantantesFamosos.
De este modo, un objeto tipo ListaCantantesFamosos tendría los siguientes métodos:

getCantante
addCantante
removeCantante
getTamaño
mostarLista

El código con esa modificación sería:

Clase ListaCantantesFamosos
import java.util.ArrayList;

public class ListaCantantesFamosos{

    private ArrayList<String> listaCantantes;

    public ListaCantantesFamosos(){
        listaCantantes = new ArrayList<String>();
        listaCantantes.add("Joaquin Sabina");
        listaCantantes.add("Carlos Cano");
        listaCantantes.add("David Broza");
    }

    public ArrayList<String> getLista(){
        return listaCantantes;
    }
   
    public String getCantante(int posicion){
        if(posicion>=0 && posicion<listaCantantes.size()){
            return listaCantantes.get(posicion);
        }else{
            return "No existe cantante para esa posición de la lista";
        }
    }

    public void addCantante(String nombreCantante){
        listaCantantes.add(nombreCantante);
    }

    public void removeCantante(int posicion){
        if(posicion>=0 && posicion<listaCantantes.size()){
            listaCantantes.remove(posicion);
        }
    }

    public int getTamaño(){
        return listaCantantes.size();
    }
   
    public void mostrarLista(){
    int numeroCantante=1;
        for(String cantante : listaCantantes){
            System.out.println("El cantante numero "+ numeroCantante+" es : "+cantante);
            numeroCantante++;
        }
    }
           
}

Clase TestForExtendido
public class TestForExtendido{

    public static void main(String Arg[]){

        ListaCantantesFamosos listaCantantes=new ListaCantantesFamosos();
        EntradaTeclado entradaTeclado;
       
        do{
            System.out.print("Dame el nombre de un cantante famoso : ");
            entradaTeclado = new EntradaTeclado();
            listaCantantes.addCantante(entradaTeclado.getEntrada());

            listaCantantes.mostrarLista();

            System.out.print("¿Quieres continuar?(S/N)");
            entradaTeclado.setEntrada();
        }while(entradaTeclado.getEntrada().equals("S"));
    }
}
Analízalo y cualquier duda estamos aquí para revisarlo nuevamente.

Hola Adrián:

Muy interesante tu observación. Analicemos:
Esa parte del código que copias lo que hará será devolver la primera palabra si es que la cadena que estamos ingresando tiene 2 o más palabras separadas por un " " entre si.
Si la cadena solo fuera una palabra (sin espacios " " internos) se devuelve la palabra completa.
Ejemplo:
Si una de las cadenas ingresadas fuese: "Automovil", el método getPrimeraPalabra() devolverá "Automovil".
Pero si la cadena ingresada fuese: "Motocicleta Deportiva", el método getPrimeraPalabra() devolverá "Motocicleta".

Respecto al uso de -1 en el límite del ciclo for. Reescribamos:
for (int i=0; i < entradaTeclado.length() - 1; i++) {

            if (entradaTeclado.substring (i, i+1).equals(" ") ) {     //IMPORTANTÍSIMO: COMPARAMOS CON EQUALS

                return entradaTeclado.substring(0, i+1);         
            }
}
Supongamos que ingresamos la cadena "Hola", por lo tanto al campo entradaTeclado tipo String se le asigna la cadena "Hola".

¿Y qué valor devuelve el método entradaTeclado.length() ? Respuesta: 4

Vayamos haciendo las distintas valuaciones del método entradaTeclado.substring (i, i+1)
Conforme "i" vaya tomando distintos valores tendremos (comenzando por el 0):

entradaTeclado.substring (0, 0+1) = "H"
entradaTeclado.substring (1,1+1) = "o"
entradaTeclado.substring (2,2+1) = "l"
entradaTeclado.substring (3, 3+1) = "a"

Fíjate que con la variable "i" valiendo 3, ya se ha recorrido cada caracter de la cadena.
Si le permitiera a "i" valer 4, me daría un error, ¿por qué? porque el método:

entradaTeclado.substring (4, 4+1) estaría accediendo a una posición inexistente (la posición 5).

Conclusión: no puedo permitir que "i" llegue a valer 4, es decir, que "i" puede tener como límite superior el valor: entradaTeclado.length() - 1

En este ejercicio, nunca se alcanza esa condición, por lo que bien tu dices no incluyendo el -1 no se produce ningún cambio.

Sin embargo te propongo reescribr el método de la siguiente manera para que puedas comprobar que ese -1 debe existir para no obtener un error en tiempo de ejecución.

    public String getPrimeraPalabra ()  {

       /*IMPORTANTE: EN JAVA LOS OBJETOS NO SE PUEDEN COMPARAR USANDO == POR ESO ESTO NO FUNCIONARÁ       

          if (entradaTeclado.substring(0,1)=="j") {

          System.out.println ("Hemos detectado una j");

          } else { System.out.println ("Mira esto:" + entradaTeclado.substring(0,1) ); }*/ 
       
        int i = 0;
        for (i=0; i < entradaTeclado.length() ; i++) {

            if (entradaTeclado.substring (i, i+1).equals(" ") ) {     //IMPORTANTÍSIMO: COMPARAMOS CON EQUALS

                return entradaTeclado.substring(0, i+1);         }

        }

        return entradaTeclado.substring(0, i+1);  //Caso de que no se detecte ningún espacio devolvemos lo que haya

    } //Cierre del método getPrimeraPalabra
Analízalo y cualquier duda estamos quí que reveerlo.

Hola!

Estuve revisando tu ejercicio. En general lo veo bien.
Sin embargo me gustaría hacer algunas observaciones para mejorar el código.

Respecto a la clase EntradaTeclado. La idea de una clase que cree objetos que manejen los datos provenientes del teclado está muy bien. Sin embargo creo que su codificación podría hacerse más eficiente.
Igualmente renombraría también la clase por un nombre que sea más acorde a lo que hace. Por ejemplo llamaría a esta clase GestionadorEntradasTeclado.
Reescribo esta clase de la manera en que pienso sería más eficiente:

import java.util.Scanner;

public class GestionadorEntradasTeclado{

    Scanner scaner;
   
    public GestionadorEntradasTeclado(){
        scaner = new Scanner(System.in);
    }

    public String recogerCadena(){
        String entrada = scaner.nextLine();
        return entrada;
    }

}
fíjate que se define solo un método recogerPalabra(). Este método lo que hace es devolver una cadena (tipo String) cada vez que se la invoca.

De esta manera, podríamos reescribir la clase Test de la siguiente manera:

public class Test{
   
    public static void main(String arg[]){
       
        ListaCantantesFamosos listaCantantes = new ListaCantantesFamosos();
       
        GestionadorEntradasTeclado teclado = new GestionadorEntradasTeclado();
        System.out.print("Dame el nombre de un cantante famoso : ");
        listaCantantes.addCantante(teclado.recogerCadena());
        System.out.print("Dame un segundo nombre de cantante famoso : ");
        listaCantantes.addCantante(teclado.recogerCadena());
 
        System.out.println("El contenido de la lista de cantantes famosos es el siguiente :");
        for (int i=0; i<listaCantantes.getTamaño();i++){
            System.out.println(listaCantantes.getCantante(i));
        }

        System.out.println("Fin del programa");
    }
}
Como puedes ver, una diferencia respecto de la versión anterior, es que declaramos solo un objeto tipo GestionadorEntradasTeclado, y lo usamos dos veces.
El método teclado.recogerCadena() devuelve un String que es el nombre del cantante. Y a su vez ese String es el parámetro del método listaCantantes.addCantante que lo agrega a la lista.

Fíjate que reutilizamos el recurso 'teclado'. Si tuviéramos que ingresar 100 cantantes, utilizaríamos siempre el mismo objeto.

Una última cosa: la letra 'ñ' castellana es preferible no usarla cuando programamos. Por lo tanto al método getTamaño() bien podríamos renombrarlo por getTamanno o getTamanio.

Analízalo y cualquier duda acá estamos para revisarlo nuevamente.

Hola:

1) Correcto.

2) Correcto. Es más, ni siquiera sería necesaria la declaración de estos atributos.

Hola:

Tu ejercicio está perfecto, cumple en todo con la consigna. A seguir adelante!

Hola Luis:

Tu ejercicio esta muy bien, felicitaciones. Destaco como siempre, el orden en la codificación del programa, los comentarios que realizas en él, y el repeto por las conveción en cuanto a cómo nombrar clases, métodos, y atributos.
A seguir adelante!

Hola!

El ejercicio correspondiente a esta lección propone preguntas a contestar. Te sugiero que releas la consigna del ejercicio nuevamente.
Saludos.

Ejercicio perfecto Ronal, a seguir adelante!

Hola Adrián:

Sigue siendo muy interesante tu disyuntiva, y es precisamente en ese punto donde no quiero adelantarme al orden natural del curso.

Pero analicemos un poco más el asunto así mitigamos en algo la incomodidad de la duda.

Con la línea de código:
vehiculoTaxi = new Taxi (objetoTaxi.getMatricula(), objetoTaxi.getDistrito(),     objetoTaxi.getTipoMotor() );
estamos creando un NUEVO objeto tipo Taxi, que será uno de los campo de instancia del objeto TaxiCond.
Por lo tanto, si posteriormente modificara los atributos del objeto Taxi que se pasó como parámetro (supongamos la matricula), ese cambio no se verá reflejado en el objeto tipo Taxi vehiculoTaxi (campo del objeto TaxiCond), ya que son objetos distintos.
(Esto creo que ya lo tienes claro).

Ahora bien, con la línea de código:
vehiculoTaxi = objetoTaxi;
no estoy creando un nuevo objeto Taxi. Lo que estoy haciendo es asignar a vehiculoTaxi la REFERENCIA del objetoTaxi. Vale decir que a partir de esa asignación, vehiculoTaxi pasará a apuntar a la posición de memoria que ocupa el objeto objetoTaxi.
Y ahora en este caso, si se modificara la matricula de objetoTaxi, entonces ese cambio si se reflejará si consulto la matricula de vehiculoTaxi, ya que vehiculoTaxi ahora "apunta" al mismo lugar que objetoTaxi.

Conclusión: no tenemos dos objetos tipo Taxi independientes como en el caso anterior, tenemos un solo objeto tipoTaxi en una posición determinada de la memoria, pero REFERENCIADO (apuntado) tanto por objetoTaxi como por vehiculoTaxi.

Pero insisto en la siguiente, es un tema que se verá en detalle y mayor profundidad más adelante en el curso. Por ahora no nos preocupemos mucho si es un concepto que todavía no internalizamos.