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

Hola DavidWpo.

Tal vez leer esto te podría ayudar: https://www.google.com.do/amp/s/www.redeszone.net/2014/12/06/controla-un-ordenador-de-forma-remota-con-teamviewer-10/amp/?client=ms-unknown

Saludos..

 Hola hymsoft!

Tu solución a este ejercicio cumple con lo requerido en el enunciado del mismo.

No obstante, podemos mejorar mucho tu código, es bueno que tengas claras algunas cosas a la hora de escribir o estructurar código, por ejemplo ten en cuenta:

Redundancia: Si tienen la misma función y rendimiento, un código limpio, ligero y claro es preferido por todos ante un código robusto y con exceso de código innecesario. Un buen programador evita reinventar la rueda. (redundancia de código)

Reutilizar código: La reutilizacion de código es nuestro mejor aliado para crear un código mas limpio, ligero y amigable a los ojos de quien lo lee.

Delegación de responsabilidades: Una clase debe de hacer lo que dice su nombre  que es o que hace y solo eso. Si es una clase EntradaDeTeclado, debe de limitarse a solo eso, generar una entrada para que el usuario pueda escribir, cosas como mostrar mensajes en pantalla desde esta clase o analizar y realizar operaciones (diferente a guardar lo escrito en la entrada) con el valor de lo escrito por el usuario no son propias de un código bien estructurado.

He editado tu código y he dejado algunos comentarios en cada clase que tal vez te puedan ser útiles. Cuando ejecutes el código, veras un mismo resultado con muchas menos lineas de código (sin contar los comentarios XD)

A continuación tus tres clases con ciertas modificaciones:

EntradaDeTeclado
/**
 * Clase para manipular la entrada por teclado
 *
 * @author aprenderaprogramar
 * @version
 */
import java.util.Scanner;


/*Una clase debe de hacer lo que su nombre dice que es o que hace y no nada mas.*/
public class EntradaDeTeclado
{
   
//Constructor por defecto
   public EntradaDeTeclado(){
   
   /*Este constructor puede ser invocado aun si no estuviese declarado en esta clase, siempre y cuando
    * no exista ningún otro constructor (con argumento/s) declarado en esta clase, se considera buena practica el declararlo */
       
   }//cierre constructor por defecto
   
   /*Este método retorna un String como resultado de lo que el usuario escriba por teclado*/
   public String pedirEntrada(){//metodo de clase
       Scanner  entradaScanner = new Scanner(System.in);
       String entradaTeclado;
       entradaTeclado = entradaScanner.nextLine();
       return entradaTeclado;
    }//cierre pedir entrada
   
   
}
ListaCantantesFamosos
/**
 * Clase generica de cantantes famosos
 *
 * @author Hugo Segura
 * @version (a version number or a date)
 */

import java.util.ArrayList;
import java.util.List;


/*Para un buen programador, los métodos get y set de una variable de clase, no son opcionales
 * Siempre han de ser declarados aun cuando se crean innecesarios*/
public class ListaCantantesFamosos
{
    //Declaracion de variables
    private List<String> listadenombres = new ArrayList<String>();/*Array de objetos string
    que va a guarar los nombres*/
    //fin declaracion variables
   
    //Constructor
    public ListaCantantesFamosos(){
        //Agrego 3 nombres por defecto
    /*No es logico crear un metodo agregarCantante, cuando java nos proporciona el
    * metodo add(String value) para los tipo List, y realiza exactamente lo que necesitamos que es
    * agregar un String al ArrayList de String, hacer esto se considera reinventar la rueda o
    * redundancia*/
        listadenombres.add("David Gilmour");
        listadenombres.add("Brian Johnson");
        listadenombres.add("Rod Evans");
    }//cierre constructor

public List<String> getListadenombres() {
return listadenombres;
}

public void setListadenombres(List<String> listadenombres) {
this.listadenombres = listadenombres;
}
   
   
}
TestListaCantantesFamosos
/**
 * Clase principal para resolucion ejercicio CU00665B
 *
 * @author Hugo Segura
 * @version (a version number or a date)
 */

/*La clase con el método main es la responsable de dirigir el flujo del programa y en este caso, responsable
 * de realizar tareas con los valores de lo escrito por el usuario y de mostrar mensajes en pantalla*/
public class TestListaCantantesFamosos
{
    public static void main(String[] args){
        ListaCantantesFamosos lista1 = new ListaCantantesFamosos();//Creo el objeto
        EntradaDeTeclado entradaDeTeclado = new EntradaDeTeclado();/*Con este unico objeto, pediremos
        todas las entradas de datos al usuario (reutilizacion de código)*/
       
        //Declaramos dos variables tipo String que contendrán cada una un valor escrito por el usuario
        String entrada1, entrada2;//Si son de un mismo tipo, podemos declararlas en una sola linea, separadas por comas
       
        System.out.println("Empecemos con el programa\n-------------------------\nIntroduce "
        + "el nombre de 2 cantantes famosos...\n\nNombre del Cantante 1:");
        entrada1 = entradaDeTeclado.pedirEntrada();
        System.out.println("Nombre del Cantante 2:");
        entrada2 = entradaDeTeclado.pedirEntrada();
        System.out.println("\nMuchas Gracias...");
        //agrego los nombres solicitados
        lista1.getListadenombres().add(entrada1);
        lista1.getListadenombres().add(entrada2);
               
        System.out.println("\nEl listado de mis Cantantes Famosos mas los tuyos es el siguiente:\n");
        int i = 0;/*Usaremos esta variable como un contador en el for each (otra opción seria usar un bucle
        for normal)*/
        for(String cantante: lista1.getListadenombres()){//Usamos un for each para recorrer la lista de cantantes
        i++;
        System.out.println("Cantante " + i + ": " + cantante);//Listo todos los nombres
        }
    }
}
Cualquier duda, no dudes en preguntar.

Saludos!!

 "Reutilizacion de código" totalmente de acuerdo con Lorenzo31.

Correcto..

Correcto..

 Un placer saludarte César.
 
Me alegra saber que te fue de ayuda el anterior comentario claudiogs.

 Hola luis sanz!

A continuación dejo el siguiente código el cual contiene algunos ejemplos de las ventajas y uso de los operadores de asignación compuesta, también e incluido algunos comentarios de clase, que podrían ser útiles.




/**
 * Ejemplo de uso de operadores de asignación compuesta (+= y -=).
 *
 * @author J.lopez
 */
public class OperadorCompuesto
{
    // Declaración de dos variables de tipo primitivo int
    private int primerValor;
    private int segundoValor;

    /**
     * Constructor general
     */
    public OperadorCompuesto()
    {
       // Inicializamos las variables primerValor y segundoValor con un valor inicial de 2 y 3 respectivamente, para una mejor comprensión en este ejemplo
       primerValor = 2;
       segundoValor = 3;
    }

    //Metodos setters
    public void setPrimerValor(int valor)
    {
      primerValor = valor;
    }
    public void setSegundoValor(int valor)
    {
      segundoValor = valor;
    }
    // Getters
    public int getPrimerValor()
    {
      return primerValor;
    }
    public int getSegundoValor()
    {
      return segundoValor;
    }
    // A continuación, dos métodos que no usan operadores de asignación compuesta y devuelven un resultado
   
    /*
      Aquí en principio el compilador "no analiza" el valor contenido en la variable segundoValor, sino que trata a esta como un espacio de memoria donde sera
      almacenado el resultado de la operación matemática: segundoValor + primerValor (3 + 2) donde si analiza el valor de cada variable.
     
      Es como decirle a un niño, busca esa caja verde y luego que la busques, destapa esa caja verde que tiene juguetes  y esa otra caja amarilla que también tiene
      juguetes y junta todos esos juguetes en la caja verde
    */
    public int sumaNormal()
    {
      segundoValor = segundoValor + primerValor;
      return  segundoValor;
    }
    public int restaNormal()
    {
      segundoValor = segundoValor - primerValor;
      return  segundoValor;
    }
    // A continuación, dos métodos que si usan operadores de asignación compuesta y devuelven el mismo resultado que los dos métodos mas arriba
   
    /*
      Aquí la ventaja es que tenemos menos código y obtenemos el mismo resultado. El compilar analiza el valor de la variable segundoValor lo suma al valor
      de la variable primerValor y asigna el resultado como el nuevo valor de la variable segundoValor.
     
      Es como decirle a un niño: busca esa caja verde y esa otra caja amarilla y junta todos los juguetes que tengan en la caja verde. Suena mas facil verdad?
    */
    public int sumaCompuesta()
    {
      segundoValor += primerValor;
      return  segundoValor;
    }
    public int restaCompuesta()
    {
      segundoValor -= primerValor;
      return  segundoValor;
    }
}
Cualquier duda, no dudes en preguntar..

Saludos!

 Hola macarena2405!

El enunciado del ejercicio pide usar un ciclo while y tu has usado un ciclo do while, estos dos ciclos son parecidos pero se comportan de una forma un tanto distintas, no veo mal que uses el do while, lo importante es que sepas que son dos ciclos distintos y que sepas cuando es conveniente usar uno u otro.

Respecto a la enumeración de caracteres y el nombre de la clase, te refiero lo mismo que comente en tu anterior ejercicio (CU00658B) https://www.aprenderaprogramar.com/foros/index.php?topic=2629.0

Saludos!!

  Hola macarena2405!

Tu ejercicio lo veo del todo correcto.

A continuación dejo tu código editado con lo que para mi en lo personal podrían ser posibles mejoras.


import java.util.Scanner;
public class TestCadena
{
  public static void main (String [] args)
  {
      System.out.println("Por favor introduzca una cadena por teclado\n");
      String cadena="";
      Scanner entradaEscanner = new Scanner(System.in);
      cadena =entradaEscanner.nextLine ();
      if (cadena.length()<5)
      {
         /*Para evaluar las tres condiciones respecto a la cantidad de caracteres, usamos un if con else if, asi el ordenador gasta menos memoria
         (aqui es "insignificante" pero a gran escala podria afectar consumiendo memoria)*/     
         System.out.println("\nla cadena tiene menos de 5 caracteres ");
      }
      else if (cadena.length() >= 5 && cadena.length()<=15)
      {
         System.out.println("\nla cadena tiene entre 5 y 15 caracteres");
      }   
      else if (cadena.length()>15)
      {
         System.out.println("\nla cadena tiene mas de 15 caracteres" );
      }//El uso de \n (back slash n) muestra un texto mas fresco al separar los parrafos creando una linea (o tantas lineas como \n existan) en blanco entre estos
       
      if(cadena.substring(0,1).equalsIgnoreCase("a"))
      {
         System.out.println("la cadena empieza con " + cadena.substring(0,1));
      }//Extraemos la primera letra usando substring, asi mostraremos "a" o "A" segun sea el caso
      else
      {
         System.out.println("la cadena no comienza con a/A");
      }
  }
}
Saludos!!

A ver!

Primero extraemos el primer carácter de la cadena introducida usando substring, podría ser algo así:

String primerCaracter;
primerCaracter = cadena.substring(0, 1);
y luego usamos el método equals y no == para comparar dos tipo String, puesto que un tipo String es también un tipo Object y ha de compararse usando equals. Podría ser algo asi:

if(primerCaracter.equals("a") || primerCaracter.equals("A")){...}
Con esto es suficiente para no usar el método matches, o tener que convertir de String a char.
(que no es trampa por cierto, pero si es bueno dominar el tema de todas las formas)

Tus clases quedarían asi:
import java.util.Scanner;

public class AnalizarCadena {
public AnalizarCadena(){}

public String lectura(){
    Scanner lea = new Scanner (System.in);
    return lea.nextLine();
}

public void comprobacion(String caracteres){
       int num;
       String primerCaracter;
       primerCaracter = caracteres.substring(0, 1);
       num = caracteres.length();
       
       if (num < 5){
           System.out.println("\nLa cadena tiene menos de 5 caracteres.");
       }
       else if (num >= 5 && num <= 15){
           System.out.println("\nLa cadena tiene entre 5 y 15 caracteres.");
       }
       else if (num > 15){
           System.out.println("\nLa cadena tiene mas de 15 caracteres.");
       }
     
       if(primerCaracter.equals("a") || primerCaracter.equals("A")){
           System.out.println("\nLa cadena empieza con " + primerCaracter);
       }
       else
           System.out.println("\nLa cadena no empieza con a/A.");
}
}
public class Main {
    public static void main (String[]args){ 
         String caracteres;
         AnalizarCadena cadena = new AnalizarCadena();
         System.out.println("Ingrese una cadena de caracteres:\n");
         caracteres = cadena.lectura();
         cadena.comprobacion(caracteres);
    }
}
Saludos!!