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

Hola Macarena:

Lo has hecho muy bien!
He de hacerte algunas sugerencias para mejorar tu código simplemente.

Te en cuenta que por convención, los nombres de los métodos y los atributos deben empezar con una letra minúscula, y los nombre de las clases con una letra mayúscula. Esto es algo que todos los que programamos respetamos. Tu lo has respetado, perfecto!
Ahora bien, cuando el nombre de un método esté compuesto por dos palabras, la segunda palabra la comenzamos con mayúscula; de esa manera es más legible y facil de entender a simple vista. Por ejemplo:


al método getnombre() lo deberías renombrar por getNombre().
al método getapellido() lo deberías renombrar por getApellido().
Y así con todos los demás nombres de métodos que estén compuestos por dos o más palabras: cada nueva palabra comienza con mayúscula (salvo la palabra inicial).

Lo mismo sucede con los nombres de los atributos. Por ejemplo, tienes un parámetro llamado valornombre, ese parámetro debería llamarse valorNombre. (lo mismo con los demás atributos y parámetros).

Por último también quería comentarte una buena costumbre en la organización de los métodos.
Si bien no hay una necesidad funcional que haga que un método deba ir antes o después de otro, generalmente ordenamos todos los métodos set uno a continuación del otro, y todos los métodos get uno a continuación del otro. De esta forma es más facil de ir a buscar un método dentro del código ya que están todos juntos los métodos set por un lado, y los get por el otro.
Tu los has intercalado: método set y get para el campo nombre; método set y get para el campo apellido, etc etc. Mi recomendación es que ordenes los métodos por lo que hacen.

Preguntabas finalmente cómo hacer para publicar tus ejercicios.
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.

Sigue adelante!, lo estás haciendo muy bien.

El programa cumple la consigna del ejercicio.
Lo has resuelto creando dos clases: una clase que gestiona la entrada de palabras ingresadas por teclado, y otra clase que implementa el método main. Eso me parece muy bien,  delimitar la tarea que realizará cada clase. Es lo que más me ha gustado de tu código. Estás empezando a comprender la filosofía de la POO.

Hay también cosas que no las veo bien, y veamos cómo podemos mejorarlo:
1) Una vez más he de recomendarte que a las clases las nombres con una mayúscula como letra inicial. Acostúmbrate a seguir las convenciones. Recuerda que nuestros códigos no solo lo leeremos nosotros mismos, sino que podemos participar de un proyecto donde intervengan más programadores y hay convenciones que deben ser respetadas por todos para que nos podamos entender.

2) Respecto de la clase comparacionLetra.
No me parece adecuado el nombre que le has dado a la clase, ya que su nombre no indica lo que hace.
Te sugeriría renombraras la clase con un nombre más significativo, que nos indique para qué sirve, qué tarea cumple, por ejemplo podríamos pensar en llamarla: GestionadorEntradasTeclado.

Declaras un campo de instancia del tipo String entradaTeclado. Yo declararía también un campo de instancia que sea de tipo Scanner. Tu declaraste el tipo Scanner dentro de un método, esto no me parece bien, recomiendo que lo declares como campo de instancia.
Tampoco me parece correcto llamar a un método dentro del Constructor. Dentro del Constructor inicilizaría el campo entradaTeclado solamente.
Luego, implementaría un método llamado recogerPalabra() que me devolviera un String con la palabra que se ingresa por el teclado.
De esta manera queda más sólida la clase, con un método que realiza lo que dice realizar: recoger una palabra desde el teclado.

import java.util.Scanner;

public class GestionadorEntradasTeclado{
   
    private String entradaTeclado;
    Scanner entradaEscaner = new Scanner(System.in);
   
    public GestionadorEntradasTeclado(){
       entradaTeclado = "";
    }
   
    public String recogerPalabra(){
        entradaTeclado = entradaEscaner.nextLine();
        return entradaTeclado;
    }
   
}

3) Respecto a la clase comparacion
Aqui también elegiría otro nombre para la clase. Elige algo que nos diga para qué sirve la clase, por ejemplo ComparadorDePalabras, (puedes elegir otro nombre si te parece).
Como ya tendrás tu clase GestionadorEntradasTeclado, entonces habrá que declarar e instanciar un objeto de este tipo dentro del método main.

public static void main(String[]args){
       GestionadorEntradasTeclado miTeclado = new GestionadorEntradasTeclado();

luego, a los atributos String entrada_1 y entrada_2 les asignas sus valores valiéndote del método recogerPalabra() del objeto miTeclado tipo GestionadorEntradasTeclado.

System.out.println("Introduce la primera cadena");
String entrada_1 = miTeclado.recogerPalabra();
System.out.println("Introduce la segunda cadena");
String entrada_2 = miTeclado.recogerPalabra();
Otra cosa que me ha llamado la atención en esta clase es lo siguiente:

if(entrada_1.length()>entrada_2.length()){
           limiteInf=entrada_1.length();
           palabra = 2;
           limiteSup = entrada_2.length();
        }
        else{
            limiteInf=entrada_2.length();
            palabra = 1;
            limiteSup = entrada_1.length();
        }

Como regla muy general, trataremos que lo que nosotros codifiquemos sea lo más parecido a la realidad. Me refiero a que si la longitud del String entarada_1 es menor a la longitud del String entrada_2, pues entonces asignemos la longitud de entrada_1 al parametro limiteInf.
Si bien esa parte de tu código que transcribi funciona y logra su propósito, pareciera no ser lógico. Más lógico sería escribir:

if(entrada_1.length()<entrada_2.length()){
           limiteInf=entrada_1.length();
           palabra = 1;
           limiteSup = entrada_2.length();
        }
        else{
            limiteInf=entrada_2.length();
            palabra = 2;
            limiteSup = entrada_1.length();
        }

Eso provocará que tengas que modificar también los límites del for y del if de la siguiente manera:

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

lo cual también viene siendo más lógico.

Te invitaría a reescribir tu código con estas recomendaciones. Estamos aquí para volverlo a revisar con gusto!

Hola Rubens:

Tu ejercicio funciona correctamente cumpliéndose la consigna planteada. Haces buen uso del bucle while, lo has entendido bien!

Igualmente para avanzar un poco más, he de hacerte algunas observaciones para optimizar el código.

Fíjate en lo siguiente:

Podemos optimizar el código prescindiendo del atributo contador y valernos únicamente del atributo int i.
De esta manera tu código modificado quedaría:

import java.util.Scanner;
public class SepararWhile{
    public static void main(String [ ] arg){
        System.out.println("Por favor, introduzca una palabra para deletrearla");
        String palabra = "";
        Scanner cadenascan = new Scanner(System.in);
        palabra = cadenascan.nextLine();
        int i = 0;

        while (i < palabra.length()){
           

            System.out.println("Letra " + (i+1) + " = " + palabra.substring(i,i+1));
             i = i +1;
        }
    }
}

Fíjate también que se ha cambiado tu anterior línea:
System.out.println("Letra " + (i+1) + " = " + palabra.substring(0+i,1+i));

por:
System.out.println("Letra " + (i+1) + " = " + palabra.substring(i, i+1));
que no altera en nada la funcionalidad, pero se vé mejor, es más entendible.

Compílalo, analízalo, y si surge alguna duda acá estamos para ayudarte.

Hola 5378453!

Antes que nada no olvides las convenciones que hemos de seguir como programadores, se ha explicado ya en otros hilos: el nombre de la clase debe comenzar con letra mayúscula, a diferencia de los nombres de métodos y parámetros que inician con letra minúscula.

El código que has escrito funciona y cumple con la consigna planeada por el ejercicio.
De todos modos he de decirte que si bien existe la opción de salir de un bucle while a través de  break, trataremos de evitar la salida de esta forma. Siempre es aconsejable que la salida del bucle sea por la condición false.

Te propongo que examines el siguiente código:

import java.util.Scanner;

public class TestWhile{

    public static void main (String[] args){
        System.out.println("Ingrese una palabra:");
        Scanner teclado = new Scanner(System.in);
        String valorTeclado = teclado.nextLine();
       
        int contador = 0;
       
        while (contador!=valorTeclado.length()){
            System.out.println("Letra "+(contador+1)+" : "+valorTeclado.substring(contador,contador+1));
            contador++;
        }
       
    }
   
}

Fíjate que la salida del bucle se da por una condición false del while.
Además hay una optimización del código al declarar solo un atributo tipo int y no dos.

Analízalo y si tienes una consulta pues acá estamos para ayudarte!

Hola!

Me ha quedado una duda al leer la lección (CU00910C) donde se desarrolla un ejemplo resuelto implementando la interface Cloneable, perteneciente al package lang del API Java.

Supongamos que al ejemplo lo reescribo de la siguiente manera:

Por ejemplo, si al código del ejercicio resuelto, lo reescribiéramos de la forma:

/* Ejemplo Clase e Interfaz Cloneable aprenderaprogramar.com */

 public class Persona implements Cloneable{

   public int dni, edad;

      public Persona( int d, int e) {     this.dni = d;       this.edad = e;     }

 }

no tendríamos errores de compilación, ¿ por qué ? porque la interface Clonable no declara ningún método abstracto, por lo tanto no me obliga a implementar ninguno en mi clase concreta. ¿Pero y entonces de dónde sale el método clone() ? El método clone() es un método heredado de la clase Object. Pero al no estar declarado en la Interface clonable() no estoy obligado a implementarlo.

Lo que no entiendo es: si el API de java, define una interface clonable() para que la utilicemos para clonar, ¿por qué no entonces declarar la clase abstracta clone()? ¿por qué no exigir al que implemente la interface que es obligatoria su implementación?

Hola.
Veo bien tu programa!
Como sugerencia, y para robustecer el código, agregaría al método combinacionDeCadenas una condición inicial que evitara se ejecute si las cadenas que se pasan como parámetros tienen menos letras de las que necesita el método para poder cumplir con la consigna del ejercicio.
De este modo el método combinacionDeCadenas nos quedaría de la siguiente manera:

public String combinacionDeCadenas(String cadena1, String cadena2, String cadena3){
        if ((cadena1.length()>=2)&&(cadena2.length()>=4)&&(cadena3.length()>=6)){
            sumaDeCadenas = (cadena1.substring(0,2)+" "+cadena2.substring(0,4)+"-"+cadena3.substring(0,6));
            return sumaDeCadenas;
        }
        else {return "error de longitudes";}
    }

Hola!

El ejercicio está muy bien, has utilizado correctamente los métodos de la clase Math del API de java.

Comenzaré sugiriéndote que vayas subiendo tus ejercicios ni bien los vayas terminando. De esta forma aqui en el foro te iremos guiando al señalárte las cosas que están bien, te haremos observaciones o sugerencias para ir mejorando, o correcciones si fueran necesarias. De esta manera podrás ir incorporando paso a paso, ejercicio a ejercicio, lo que vas aprendido de los ejercicios previos.
Recuerda que aprender a programar es un proceso continuo donde cada cosa que vamos aprendiendo se irá incorporando a lo sucesivo, y que es necesaria una maduración progresiva.

La sugerencia en cuanto a la convención a seguir en la elección de nombres de variables y  métodos ya te la había hecho en los dos ejercicios anteriores, ténlo en cuenta para los próximos ejercicios.

Otra cosa importante a tener en cuenta y pensar, es que los nombres que elegimos para nuestras variables deben estar estréchamente relacionadas a lo que representen, y que el nombre de los métodos deben estar estréchamente relacionados con lo que realicen. Es en este sentido que te recomendaría que:
Si en la clase Salon, tienes dos campos que se llaman:
numeroDeTelevisores y tipoSalon, entonces los métodos set y get deberían llamarse:

setNumeroDeTelevisores (porque lo que vas a setear es el número de televisores)
setTipoSalon (porque lo que vas a setear es el tipo de salón)

getNumeroDeTelevisores (porque lo que vas a devolver es el número de televisores)
getTipoSalon (porque lo que vas a devolver es el tipo de salón)

Recordemos que nuestro código siempre debe ser lo más claro posible teniendo en cuenta que el mantenimiento del mismo tal vez lo realizaremos dentro de mucho tiempo (y quizás ya no tengamos tan frescas las cosas como hoy), o que quizás el mantenimiento lo realice otra persona que debe entender el código con la mayor claridad posible.

Hecha estas observaciones de nomenclatura (y sus implicancias) en la clase Salon, debo decirte que a la clase la veo bien: declaras dos campos de instancia, implementas el Constructor donde se inicializan los campos a sus valores por defecto, e implementas los métodos set y get de los dos campos.

Con respecto a la clase Cocina, he de decirte lo mismo en cuanto a la elección de los nombres de los métodos. Deberían renombraerse a:

setEsIndependiente
setNumeroDeFuegos

getEsIndependiente
getNumeroDeFuegos

por lo demás está muy bien.


Revisemos la clase Casa.
En esta clase está muy bien la declaración de los 4 campos.
El Constructor está muy bien.
Los métodos set y get de los campos superfice y direccion están muy bien.

Los métodos setIndependiente, setFuego, setNumero, setSalon no los veo bien ya que manipulan campos que corresponden a otras clases, no son métodos que debieran estar en la clase Casa.

Recordemos cuáles eran los campos que declaraste en la clase Casa:
    double superficie;
    String direccion;
    SalonCasa salonCasa;
    CocinaCasa cocina;

Pues entonces la clase Casa solo debería hacerse cargo y manipular estos 4 campos.
El campo salonCasa es un campo de la clase Casa, no así el campo numeroDeFuegos que es un campo de la clase Cocina.

Si consideramos la filosofía de programación orientada a objetos (POO), entonces así como implementamos métodos set y get para los campos superficie y direccion, pues tendremos que implementar también métodos set y get para el campo salonCasa (tipo SalonCasa), y para el campo cocina (tipo CocinaCasa). Por ejemplo:

public void setSalonCasa (SalonCasa objetoSalonCasa){
salonCasa = objetoSalonCasa;
}

public SalonCasa getSalonCasa(){
return salonCasa;
}
y lo mismo para el campo cocina. Sé que sabrás cómo implementar sus métodos set y get.

Por último, al método getDatosCasa() lo veo bien. Esta muy bien pensado a la hora de presentar un informe de los campos de la clase Casa.

Hola!

He revisado tu codificación del ejercicio y lo veo muy bien. Has entendido la creación de Constructores con parámetros.
Asimismo, he de hacerte algunas observaciones para tener en cuenta y mejorar tu código:

Respecto a los nombres elegidos para los parámetros del Constructor, si bien comienzan con minúscula que como siempre se ha dicho es una buena práctica para nombrarlos, la segunda palabra comiénzala con mayúscula para que sea más legible a simple vista, y podamos determinar facilmente de qué se trata. Recomnedaría entonces que al parámetro valornombre, lo renombraras en el código como valorNombre; a valorapellido por valorApellido, y asi suscesivamente.
Siguiendo la misma lógica a los métodos get si los has nombras bien: getApellido, getEdad, getCasado, getEspecialista.
Acostumbrarnos a esta convención trae beneficios. Al principio lo tenemos que pensar, pero luego es algo que nos sale de manera automática.
(En el método getNombre has tenido un error de tipeo, ya que escribiste geNnombre).

Repasemos lo que el ejercicio nos pide realizar:

Define un constructor que reciba los parámetros necesarios para la inicialización y los métodos para poder establecer y obtener los valores de los atributos.

Y te han faltado implementar los métodos set. Trata de codificar estos métodos así tu código quedará completo!

Hola calderas.

Realmente lo veo muy bien. Has podido crear las 7 clases solicitadas en el ejercicio haciendo uso de las relaciones de herencia mediante la palabra clave "extends", así que muy bien por ello!. Podrías adjuntar un esquema de las relaciones de herencias, quedaría muy bien.

También ha habido una cosilla que paso a comentarte y que habría que corregir para cumplir con la consigna del ejercicio propuesto, y realmente gozar de las bondades de la herencia.

Fíjate que el enunciado del ejercicio nos dice:

...por ejemplo los productos congelados deben llevar la temperatura de congelación recomendada.

entonces, como todos los productos congelados tendrán un campo 'temperaturaCongelación', en vez de definirlo como campo de instancia de cada una de las clases hijas (CongeladoNitrogeno, CongeladoAire, y CongeladoAgua), lo definimos como campo de instancia en la clase padre Congelado. De esta manera -y gracias a la herencia- cada una de las clases hija hereda el campo 'temperaturaCongelación'. Estaremos de esta forma evitando crear un mismo campo en cada una de las clases hija (no duplicaremos código), es una de las bondades de la herencia.

¿Y cómo podría luego acceder en una clase hija (por ejemplo CongeladoAgua) a su campo 'temperaturaCongelación'? pues a través del método públicos setTemperaturaCongelacion y el método público getTemperaturaCongelacion que se debería implementar en la clase Congelado.

Incorporando esta declaración de campo, la clase Congelado debería quedar:

public class Congelado
{
    private double temperaturaCongelación;
   
    //constructor
   
    //metodos set y get

    //otros métodos
   
}

Y por lo tanto las clases hijas, por ejemplo la clase CongeladoAgua:

public class CongeladoAgua extends Congelado
{

    //constructor
   
    //metodos
}
Y como último, hacerte una sugerencia en cuanto a los nombres que elegimos en la declaración de los campos. En la clase Envio defines dos campos, uno que corresponde al nombre de la lista de envío (tipo String), y otro campo que corresponde a una lista ArrayList donde se cargarán los productos.
Al campo tipo String sería mejor renombrarlo por 'nombreListaEnvio', que con solo leerlo ya nos sugiere que es el nombre de la lista. El nombre que elegiste 'listaEnvios" leído sin ser uno el que realizó el código podría sugerir que hace referencia al ArrayList, y generar confusión.
Es bueno ir acostumbrándonos a nombrar los campos de tal manera que nos dé una información certera de qué se trata.