Aprendiendo a programar en Java... con el movil | Página 2

HeXaN #31 Mar '18

#30 No ha dilema alguno: hay que generar una buena documentación.

B

[Borrado] #32 Mar '18

Bromas aparte, lo primero que hago en un editor de texto es convertir tab a espacios, tabular como tal es una salvajada xD

1

afhn #33 Mar '18 Guardia Imperial

4espacios vs 1 tab, no sé, no sé.

1 respuesta

eondev #34 Mar '18

#33 4 espacios vs 2
Fight!

2 respuestas

afhn #35 Mar '18 Guardia Imperial

#34 8 espacios vs 2 tabs a segundo nivel.

yasurio #36 Mar '18

#34 subo 1 espacio y bajo 1 tab giren sus apuestas

Xustis #37 Mar '18

#2 ¿Los odias porque pueden ver mucho mejor donde empieza y acaba mucho mejor que tú?

L

luisdomarco #38 Mar '18

Bueno, otro juego de adivinar un número, esta vez es el mastermind, el juego de deducir una secuencia de colores, en este caso con números de 4 cifras, usando pistas. Un "asterisco" para los números correctos y bien colocados y un "más" para los números correctos pero mal colocados. El "menos" indica que un número no tiene ningun tipo de coincidencia.

Esta vez he usado una clase en otro archivo diferente, me ha dado algún dolor de cabeza el tema de las clases y el uso de las variables, y me ha obligado a hacer una función en la clase Main porque me daba un error que no entiendo con una variable al intentar hacerlo como un método de la clase Master.

Pero bueno, es posible que fuera alguna chorrada, y tampoco se explicar cuál era el error ahora, así que me quedo con la duda hasta que ocurra de nuevo.

Aquí está el código.
la clase Main

spoiler

package mastermind;
import java.util.Scanner;
import mastermind.Master;
public class Main 
{

  public static void main(String[] args) 
  {
    Scanner key=new Scanner(System.in);
    int player;
    char sn='n';
    int rnd;
    



do // Bucle proncipal
{
  rnd=(int)(Math.random()*10000);
  Master.SetRandom(rnd);
  
  System.out.println("Adivina un numero de 4 cifras.");
  
  do
  {
    player=Dimenumero();
    Master.SetPlayer(player);
    
  }while( !Master.Comparar());
  
  System.out.print(" ¿Quieres continuar? s/n ");
  sn=key.next().charAt(0);
}while (sn=='s'); 
   


  }
  

  private static int Dimenumero()
  {
    Scanner key=new Scanner(System.in);
    int n;
    boolean ct=false;
    

do
{
  n=key.nextInt();
  if (n<0 || n> 9999)
  {
    System.out.println("El número no es valido.");   
  } 
  else
  {
    ct=true;
  }
}while (!ct);
return n;
  }
}

y la clase Master

spoiler

package mastermind;
import java.util.Scanner;

public class Master 
{
  private static int Random[]= new int[4];
  private static int Player[]= new int[4];
  private Scanner key=new Scanner(System.in);
  /************************************/
  public static void SetRandom(int num)
  {
    Convertir(Random,num);
  }
  /************************************/
    public static void SetPlayer (int num)
  {
    Convertir(Player,num);
  }
  /************************************/
  public static boolean Comparar()
  {
    int cpR[]= new int[4];
    int cpP[]= new int[4];
    int n,m,ct=0;
    boolean bien=false;
    for(n=0;n<4;n++)
    {
      if (Random[n]==Player[n])
      {
        cpP[n]=1;// los numeros comparados con coincidencias no se vuelven a comparar
        cpR[n]=1;
      }
    }
    

  for(n=0;n<4;n++) // indice Player
  {
      for (m=0;m<4;m++) // indice Random
      {
        if ( cpR[m]==0 && cpP[n]==0)
        {
          if( Player[n]==Random[m] )
          {
            cpP[n]=2;
            cpR[m]=1;
          }
        }
      }
  } 
   
// mostrar pistas
for (n=0;n<4;n++) //primero hundidos
{
   if( cpP[n]==1) 
   {
     System.out.print("*");
   }
}
for (n=0;n<4;n++) //luego tocados
{
   if( cpP[n]==2) 
   {
     System.out.print("+");
   }
}
for (n=0;n<4;n++) //y por ultimo agua
{
   if( cpP[n]==0) 
   {
     System.out.print("-");
   }
}

for (n=0;n<4;n++)
{
  if (cpP[n]==1)
  {
    ct++;
  }
}
System.out.println(); // linea nueva
if(ct==4) //  4 hundidos, numero correcto
{
  return true;
}
else
{
  return false;
}  
  }
 /************************************/
  public static void Convertir (int[] n,int num)
  {
    int um=0,c=0,d=0;
    while (num>=1000)
    {
      num-=1000;
      um++;
    }
    while (num>=100)
    {
      num-=100;
      c++;
    }
    while (num>=10)
    {
      num-=10;
      d++;
    }
    n[0]=um;
    n[1]=c;
    n[2]=d;
    n[3]=num;  

  }
}

No se se si así esta el codigo bien estructurado o está correcto el tema de la clase Master, no estoy del todo seguro cuando una variable a método debe ser público o privado, static o no, me ha dado algún problema, al final por eliminación lo voy sacando pero...

Si alguien quiere darme algún consejo sera bienvenido.

Saludos.

spoiler

B

[Borrado] #39 Mar '18

Tab > espacios

Comentarios? El método de por si es ya autoexplicativo.

L

luisdomarco #40 Mar '18

Hola .
Tengo un problemilla simple pero no encuentro una solución.

El otra vez el mastermind pero ahora es el programa quien tiene que adivinar el numero que estoy pensando. He hecho lo difícil, conseguir que en pocos intentos adivine un numero por eliminacion de posibilidades, pero me falla lo mas simple.

Al principio del bucle me pide que piense un número y que pulse intro, cuando termina me pregunta si quiero continuar y al repetir se salta la pulsación de intro, imagino que es por que al final debo pulsar intro para continuar, y al continuar entro en el do con intro pulsado y se salta la sentencia, pero no se como evitarlo.

A ver si me echáis una mano

spoiler

do // Bucle principal
    {
      n=0;
      cont=9999;
      repetir=true;
      ok=false;
      for(n=0;n<=9999;n++)
      {
        no[n]=0;
      }
      System.out.printf("\nPiensa un número de 4 cifras, y pulsa intro.\n");
      System.out.printf("Intentaré adivinarlo.\n");
      key.nextLine();
      do 
      {
        do 
        {
          rnd = (int) (Math.random() * 10000);
        } while (no[rnd] == 1);
        Master.SetRandom(rnd);
           

    if (cont>0)
    {
      Master.MostrarRandom();
      player = Dimenumero();
      if(player==1111)
      {
        ok=true;
      }
      Master.SetPlayer(player);
      descartar();
   
    }
    else
    {
      ok=true;
    }
    
    if (ok)
    {
      System.out.printf("El número es el %d",rnd);
      repetir=false;
    }
  }while (repetir);

  System.out.print(" ¿Quieres continuar? s/n ");
sn= key.next().charAt(0);

} while (sn == 's');
  }

spoiler

1 respuesta

afhn #41 Mar '18 Guardia Imperial

#40 te falta otro Scanner después del

System.out.print(" ¿Quieres continuar? s/n ");

pides una respuesta, pero no estás poniendo un scanner que pille la respuesta.
si mal no estoy viendo xd.

1 respuesta

Yandr0s #42 Mar '18

#30 quien no haga eso no merece llamarse programador

L

luisdomarco #43 Mar '18

#41
ves bien, lo copie mal, luego edité y me salté esa linea. Lo edito de nuevo, pero ese no es el problema, el problema viene al entrar en el bucle do con intro pulsado, que se salta la linea
key.nextLine();
y no se como evitarlo.

Gracias por responder.
Saludos.

L

luisdomarco #44 Mar '18

Bueno, ya encontré la solucion, me respondo a mi mismo por si a alguien le pudiera interesar.

http://puntocomnoesunlenguaje.blogspot.com.es/2012/08/java-scanner.html?m=1

Cuado en un programa se leen por teclado datos numéricos y datos de tipo carácter o String debemos tener en cuenta que al introducir los datos y pulsar intro estamos también introduciendo en el buffer de entrada el intro.
Es decir, cuando en un programa introducimos un datos y pulsamos el intro como final de entrada, el carácter intro también pasa al buffer de entrada.
Buffer de entrada si se introduce un 5: 5\n
En esta situación, la instrucción:

n = sc.nextInt();

Asigna a n el valor 5 pero el intro permanece en el buffer
Buffer de entrada después de leer el entero: \n

Si ahora se pide que se introduzca por teclado una cadena de caracteres:

System.out.print("Introduzca su nombre: ");

nombre = sc.nextLine(); //leer un String

El método nextLine() extrae del buffer de entrada todos los caracteres hasta llegar a un intro y elimina el intro del buffer.
En este caso asigna una cadena vacía a la variable nombre y limpia el intro. Esto provoca que el programa no funcione correctamente, ya que no se detiene para que se introduzca el nombre.

Solución:

Se debe limpiar el buffer de entrada si se van a leer datos de tipo carácter a continuación de la lectura de datos numéricos.

La forma más sencilla de limpiar el buffer de entrada en Java es ejecutar la instrucción:

sc.nextLine();

Pues la cosa era bien sencilla, solo tengo que añadir un
key.nextLine()
después del
sn= key.next().charAt(0);
al final del bucle, para limpiar el buffer del teclado

L

luisdomarco #45 Mar '18

Hola.
Aqui sigo con mis programillas. He hecho otro mastermimd pero esta vez juegas contra la "maquina" por turnos, las pistas se muestran con números, un 1 para las cifras bien colocadas, 2 para las mal colocadas y 0 para las cifras que no están. Se puede seleccionar el número de cifras con las que jugamos, hasta 6 cifras, con 7 mi sistema para descartar números es demasiado lento :/, funciona pero no termina jaja.

Y bueno, aunque no sea gran cosa, por si a alguien le apetece probarlo o echarle un vistazo aquí está el código.

spoiler

package mastermind;

import java.util.*;
import mastermind.Master;

public class Main 
{

  static int[] no = new int[(int)Math.pow(10,Master.Max)];
  static int cont =(int)Math.pow(10,Master.Max)-1 ;
     

  public static void main(String[] args) 
  {
    Scanner key = new Scanner(System.in);
    int player=0;
    char sn = 'n';
    int rnd,n;
    int minum,tunum;
    int tu=0,yo=0,bien;
    boolean repetir,ok,msg;
    



do // Bucle principal
{
  System.out.printf("¿Con cuantas cifras jugamos? 2-6 ");
  do
  {
    Master.Max=key.nextInt();
  }while(Master.Max<2 || Master.Max>5);
  key.nextLine();
  bien=1;
  for(n=1;n<Master.Max;n++)
  {
    bien+=Math.pow(10,n);
  }  
  n=0;
  cont=(int)Math.pow(10,Master.Max)-1;
  repetir=true;
  ok=false;
  msg=true;
  minum=(int) (Math.random() * Math.pow(10,Master.Max));
  for(n=0;n<=(int)Math.pow(10,Master.Max)-1;n++)
  {
    no[n]=0;
  }
  
  System.out.printf("Piensa un número de %d cifras, y pulsa intro.",Master.Max);
  key.nextLine();
  System.out.printf("\n");
   
  do // Empieza la partida
  {
    do   
    {
      rnd = (int) (Math.random() * Math.pow(10,Master.Max));
    } while (no[rnd] == 1);
    Master.SetRandom(rnd);
            
    //Tu turno
    if(!ok)
    {  
      System.out.print("Dime un numero: ");
      tunum=(Dimenumero());
      Master.SetPlayer(tunum);
      Master.Compara(Master.GetPlayer(),minum);
      System.out.print("Tu ");
      Master.MostrarPlayer();
      System.out.print("  ");
      Master.MostrarPistas();
      System.out.print("\n");
      if(tunum==minum)
      {
        if (cont==0)
        {
          System.out.printf("Mi número es el ");
          Master.MostrarPlayer();
          System.out.print(" y el tuyo el ");
          Master.MostrarRandom();
          System.out.println("");
        }
        else
        {
          System.out.printf("Mi número es el ");
          Master.SetPlayer(minum);
          Master.MostrarPlayer();
          System.out.println();
        }
        System.out.print("Tu ganas.\n");
        tu++;
        repetir=false;
      }
    } 
    
    // Mi turno 
    if (repetir)
    { 
      if(cont<12 && cont>0 && msg) 
      {
        msg=false;
        System.out.printf("Ya casi lo tengo.\n");
      }
    
      if (cont>0)
      {
        System.out.print("Yo ");
        Master.MostrarRandom();
        System.out.print("  ");
        player = Dimenumero();
        if(player==bien)
                    {
          ok=true;
        }
        Master.SetPlayer(player);
        descartar();
      }  
      else
      {
        ok=true;
        repetir=false;
      }
      
      if (ok)
      {
        System.out.printf("Tu número es el ");
        
        Master.MostrarRandom();
        System.out.printf(" y el mio es el ");
        Master.SetPlayer(minum);
        Master.MostrarPlayer();
        System.out.println("");

        System.out.printf("Yo gano.\n");
        yo++;
        repetir=false;  
      }
      if (cont==-1)
      {
        System.out.printf("No hagas trampas...");
        repetir=false;
      }
    }
  }while (repetir);
  
  System.out.printf("\nTu %d-%d Yo\n",tu,yo);
  System.out.print("\n¿Quieres continuar? s/n ");
  sn= key.next().charAt(0);
  key.nextLine();

} while (sn == 's');
  } /** *** fin main *** */
  /*---------------------------------*/
  private static void descartar() 
  {
    for (int n = 0; n <= ((int)Math.pow(10,Master.Max)-1); n++) 
    {
      if(no[n]==0)
      {
        if (!Master.Compara(Master.GetRandom(),n)) 
        {
          no[n] = 1;
          cont--;
        }
      }
    }
  }
  /*---------------------------------*/
  private static int Dimenumero() 
  {
    Scanner key=new Scanner(System.in); 
    boolean ct=false;
    int n;
    do
    {
      n = key.nextInt();
      if (n < 0 || n >= ((int)Math.pow(10,Master.Max)) )
      {
        System.out.println("El número no es valido.");
      } else {
        ct = true;
      }
    } while (!ct);
    return n;
  }
}

spoiler

package mastermind;

public class Master 
{
  public static  int Max=6; // numero de cifras con las que vamos a jugar
  private static int Random []=new int[Max];
  private static int Player []=new int[Max];
  private static int Compara[]=new int[Max];
  private static int Pistas []=new int[Max];
  /************************************/
  public static void SetPistas(int num)
  {
    Convertir(Pistas,num);
  }
  /************************************/

  public static void SetCompara(int num)
  {
    Convertir(Compara,num);
  }
  /************************************/
 
  public static void SetRandom(int num)
  {
    Convertir(Random,num);
  }
  /************************************/
  public static void SetPlayer (int num)
  {
    Convertir(Player,num);
  }
  /************************************/
  public static int[] GetRandom()
  {
    return Random;
  }
  /************************************/
  public static int[] GetPlayer()
  {
    return Player;
  }
  /************************************/
    public static void MostrarRandom()
  {
    for (int n=0;n<Max;n++)
    {
      System.out.print(Random[n]);
    }
  }
  public static void MostrarPlayer()
  {
    for (int n=0;n<Max;n++)
    {
      System.out.print(Player[n]);
    }
  }
  public static void MostrarPistas()
  {
    for (int n=0;n<Max;n++)
    {
      System.out.print(Pistas[n]);
    }
  }
  

  /*********************************************/
  /*  Esta función compara el un número int[]  */
  /* con int si salen las mismas coincidencias */
  /* que introduce el jugador es un número     */
  /* posible y no podemos descartarlo.         */
  /*  Las coincidencias se guardan en Pistas[] */
  /*********************************************/      

  public static boolean Compara(int[] Rnd, int Num)
  {
    int cpR[]= new int[Max];
    int cpP[]= new int[Max];
    int n,m,ct=0;
    boolean retorno=true;
    

SetCompara(Num);
for(n=0;n<Max;n++)
{
  if (Rnd[n]==Compara[n])
  {
    cpP[n]=1;// los cifras comparadas con coincidencias no se vuelven a comparar
    cpR[n]=1;
  }
}

  for(n=0;n<Max;n++) // buscamos cifras correctas pero mal colocadas
  {
    for (m=0;m<Max;m++) 
    {
      if ( cpR[m]==0 && cpP[n]==0)
      {
        if( Rnd[n]==Compara[m] )
        {
          cpP[n]=2;
          cpR[m]=1;
        }
      }
    }        
  } 
  /*
  for (n=0;n<Max;n++)
  {
    cpR[n]=cpP[n];
    cpP[n]=0;
  }
  */
  m=0;
  SetPistas(0);
  // ordenamos las pistas, primero unos, numeros iguales y bien colocados, despues doses, numeros iguales mal colocados
  for (n=0;n<Max;n++)
  {
    if(cpP[n]==1)
    {
      Pistas[m]=1;
      m++;
    }      
  }
  for (n=0;n<Max;n++)
  {
    if(cpP[n]==2)
    {
      Pistas[m]=2;
      m++;
    }      
  }
  
  for (n=0;n<Max;n++)
  {      
    if( Pistas[n]!=Player[n]) // si no coinciden todas las cifras podemos descartar el número num asi que retornamos false
    {
      
      retorno=false;
    }            
  }
  return retorno;    
  }
 /************************************/
  public static void Convertir  (int[] f, int num)
  {
    int r[]= new int[Max];
    int p,n;
    

for (n=0;n<Max-1;n++)
{
  p=(int)Math.pow(10,Max-1-n);
  
  while(num>=p)
  {
    r[n]++;
    num-=p; 
  }
  
}
for (n=0;n<Max-1;n++)
{
  f[n]=r[n];
}
f[Max-1]=num;
  }
  

}

spoiler

djamb #46 Mar '18

#30 la mayoría de ide's de java tienen un atajo de teclado que te pone el codestyle que viene por defecto.
#1 si quieres programar para android usa android studio.

1 respuesta

Camperito #47 Mar '18

#2 Yo tambien los odio, pero mas me odio a mi mismo ya que tengo que seguir la convencion psr3 y me lo tengo que tragar quiera o no

L

luisdomarco #48 Mar '18

#46 ¿Mejor Android Studio que Eclipse?
Ya había decidido probar eclipse, más que nada por que estoy siguiendo un curso en Youtube en el que usan Eclipse y me gusta lo que veo. He estado mirando opiniones y la verdad hay para todos los gustos, supongo que no habrá mucha diferencia.
En realidad no es que quiera programar para Android, mi única pretensión es entretenerme, y bueno, me gustaba, antes de dejarlo, la programación gráfica, en su día hice mis pinitos con OpenGL, tengo un vídeo por Youtube, si pudiera hacer algo así para Android...

https://youtu.be/86gT7YlnVHU

2 respuestas

B

[Borrado] #49 Abr '18

#48 Eclipse es la mayor bullshit que existe en IDEs. Y si no me crees, vete a instalarte todo lo que te traen otros en eclipse

1 respuesta

djamb #50 Abr '18

#48 yo trabajo con opengl en android y se pueden hacer exactamente lo mismo, cambian un poco los render y los shaders son iguales. Eclipse lo usa muy poca gente a nivel profesional y casi todos son chinos por el tema que tiene google en china y los servicios que tira jetbrain de google

Ranthas #51 Abr '18

#49 Desde q me pase a intellij idea no vuelvo a tocar el Eclipse ni con un palo.

Los mejores 200 pavos invertidos de mi vida

2

Wei-Yu #52 Abr '18

Si está aprendiendo como si usa blueJ, dejad de darle la lata a gente recién empezada con vuestras preferencias personales.

L

luisdomarco #53 Abr '18

Pues si la alternativa a Eclipse es gastarse 200 pavos lo tengo bastante claro...

Yo no soy ni profesional ni pretendo serlo, si puedo hacer un arkanoid, un buscaminas o un cubo rotando en 3D en mi telefono ya me doy por satisfecho, para mi esto es solo entretenimiento.

Wei-Yu #54 Abr '18

Intellij idea tiene versión de comunidad que sale gratis. Para cacharrear todavía te sobran muchas cosas de las que te traerá, si quieres la versión pro es la que tienes que poner pasta (o conseguir licencia de estudiante). Ahí ya tiene cosillas más "interesantes"; que si bases de datos, servicios web, herramientas varias para analizar y controlar el código...

Si estás haciendo cosas pequeñas lo único que te interesa es que tenga buen autocompletar y autoimport, para que puedas importar arraylist sin dejarte los dedos escribiendo, un linter para que te marque los errores estáticos antes de compilar (como int asignar un valor int a una variable string). Además de eso hay cosas que están bien, como el ir a definición/uso/implementación/declaración o los ctags, entre otras muchas cosas.

Ya te digo que para empezar te vale cualquier cosa, y tampoco es que aprendas "eclipse" o "visual studio"; eso sólo es una interfaz gráfica con funcionalidades parecidas, así que en cualquier momento puedes cambiar de IDE si te apetece.

1 respuesta

L

luisdomarco #55 Abr '18

#54
Gracias por los consejos, a ver si puedo ir probandolos todos, así salgo de dudas, pero no creo que vaya a tener problemas con ninguno de ellos, si todavía me apaño con el javaNIDE...

Saludos.

L

luisdomarco #56 Abr '18

Aqui sigo aprendiendo cosillas.

Estoy mirando cosas sobre como y el porqué de las clases, había usado clases mas veces pero no tenía el tema del todo claro. He aprendido conceptos como encapsulación y he usado por primera vez un constructor de clase.

He creado una clase para manejar archivos de texto, en este caso para hacer una agenda, se puede cargar un archivo existente o crear uno nuevo, en el podemos añadir, buscar, borrar o ver contactos. He encontrado un método molón de la clase Arrays, que es el método sort, para ordenar Arrays que me ha ahorrado mucho trabajo.

Saludos.

spoiler

package Ficheros;
import java.io.IOException; 
import java.util.*;
import Ficheros.Txt;

public class Main 
{ 
  public static void main(String[] args) throws IOException 
  { 
    char volver;
    do
    {
      Scanner key=new Scanner(System.in);
      System.out.println("Nombre del archivo:");
      String agenda= key.nextLine();
      Txt contactos= new Txt(agenda+".txt"); 
      boolean salir=false;
      while(contactos.GetOpen() && !salir)
      {
        System.out.println("\nOpciones.\n1:Nuevo\n2:Buscar\n3:Ver contactos\n4:Borrar\n5:Salir");  

        char opcion=key.nextLine().charAt(0);
        switch(opcion)
        {
          case '1': // Nuevo
            System.out.print("Nombre:");
            String nombre=key.nextLine();
            nombre=RellenarCadena(nombre,20);
            System.out.print("Telefono/Email:");
            String telefono=key.nextLine();
            telefono=EditarNumero(telefono);
            contactos.NewLine(nombre+telefono); 
            contactos.Sort();                  

          break;
        

      case '2': // buscar
        System.out.println("Introduce nombre o inicial:");
        String buscar=key.nextLine();
        contactos.Buscar(buscar);   
        //System.out.println();       
      break;
      
      case '3': // Ver contactos
        System.out.println();
        contactos.Show();
        //System.out.println();
      break;
    
      case '4': // Borrar
        System.out.println("Introduce nombre o inicial:");
        String borrar=key.nextLine();
        contactos.Eliminar(borrar);
        //System.out.println();
      break;
      case '5': // Salir
        salir=true;
      break;
      default:
        System.out.println("La opcion no es valida.");
      break;
    }    
  }  
  System.out.println("¿Quieres cargar otro archivo?s/n");
  volver=key.next().charAt(0);
  key.nextLine();
}while(volver=='s' || volver=='S');
System.out.println("Hasta pronto.");
  } 
  /***************************************/
  private static String EditarNumero(String numero)
  {
    String salida="";
    int len=numero.length();
    if (len==9)
    {
      salida+=numero.charAt(0);
      salida+=numero.charAt(1);
      salida+=numero.charAt(2);
      salida+=" ";
      salida+=numero.charAt(3);
      salida+=numero.charAt(4);
      salida+=" ";
      salida+=numero.charAt(5);
      salida+=numero.charAt(6);
      salida+=" ";
      salida+=numero.charAt(7);
      salida+=numero.charAt(8);
    }
    else
    {
      salida=numero;
    }
    return salida;
  }
  /******************************************/
  private static String RellenarCadena(String cadena,int ult)
  {
    String salida="";
    int len=cadena.length();
    int i;
    if (len>ult)
    {
      for(i=0;i<ult;i++)
      {
        salida+=cadena.charAt(i);
      }
      salida+="  ";
    }
    else
    {
      for (i=0;i<ult;i++)
      {
        if(i<len)
          salida+=cadena.charAt(i);
        else
          salida+=" ";   

      }
      salida+="  ";
    }
    return salida;
  }
}

spoiler

package Ficheros;
import java.io.*; 
import java.util.*;

public class Txt
{
  private static boolean Open;
  private static File TxtFile;
  final String RUTA="/storage/emulated/0/JavaNIDE/"; 

  /********************************************/
  public  Txt (String nombre)throws IOException
  {
    Open= false;
    TxtFile = new File(RUTA+nombre); 
    if (TxtFile.exists())
    {
      Open=true;
      System.out.println("El archivo ya existe.\n¿Quieres sobreescribirlo? s/n");
      Scanner key= new Scanner(System.in);
      char sn= key.next().charAt(0);
      if (sn=='s' || sn=='S')
      {
        System.out.println("Se perderán todos los datos.\n¿Estas seguro? s/n");
        key= new Scanner(System.in);
        sn= key.next().charAt(0);

    if (sn=='s' || sn=='S')
    {
      BufferedWriter bw;
      bw = new BufferedWriter(new FileWriter(TxtFile)); 
      bw.write("");
      bw.close();
    }
  }     
}
else
{
  System.out.println("El archivo no existe.\n¿Quieres crearlo? s/n");
  Scanner key= new Scanner(System.in);
  char sn= key.next().charAt(0);
  if (sn=='s' || sn=='S')
  {
    Open=true;
    BufferedWriter bw;
    bw = new BufferedWriter(new FileWriter(TxtFile)); 
    bw.write("");
    bw.close();
  }
  else
  {
    Open=false;
  }
}  
  }
  /*******************************************/
  public static boolean GetOpen()
  {
    return Open;
  }
  /*******************************************/
  public static void Eliminar(String borrar)throws IOException
  {
    int len=borrar.length();
    Scanner key= new Scanner(System.in);
    String guardar="",compara,cadena;
    BufferedReader br = new BufferedReader(new FileReader(TxtFile)); 
    while((cadena = br.readLine())!=null) 
    {
      compara=""; 
      for (int i=0;i<len;i++)
      {
        compara+=cadena.charAt(i);
      }
      if (borrar.equalsIgnoreCase(compara))
      {
        System.out.println(cadena);
        System.out.println("¿Borrar contacto? s/n");
        char sn=key.next().charAt(0);
        if (sn!='s' && sn !='S')
        {
          guardar+=cadena+"\n";
        }
      }
      else
        guardar+=cadena+"\n";
    } 
    br.close();
    

BufferedWriter bw = new BufferedWriter(new FileWriter(TxtFile)); 
bw.write(guardar);
bw.close();



  } 
  /*******************************************/
  public static void NewLine(String nueva)throws IOException
  {
    BufferedWriter bw;
    String linea;
    String fichero=""; 
    FileReader f = new FileReader(TxtFile); 
    BufferedReader br = new BufferedReader(f); 
    while((linea = br.readLine())!=null) 
    { 
      fichero+=(linea+"\n");
    }
      

br.close(); 
bw = new BufferedWriter(new FileWriter(TxtFile)); 
bw.write(fichero+nueva);
bw.close();      
  }
   

  /******************************************/
  public static void Show() throws  IOException 
  { 
    String cadena;
    BufferedReader b = new BufferedReader(new FileReader(TxtFile)); 
    while((cadena = b.readLine())!=null) 
    { 
      System.out.println(cadena);
     

} 
b.close(); 
  } 
  public static void Buscar(String busca) throws  IOException 
  { 
    String cadena,compara;
    int len=busca.length();
    boolean igual=true;
    int i;
    BufferedReader b = new BufferedReader(new FileReader(TxtFile)); 
    while((cadena = b.readLine())!=null) 
    {
      compara=""; 
      for (i=0;i<len;i++)
      {
        compara+=cadena.charAt(i);
      }
      if (busca.equalsIgnoreCase(compara))
        System.out.println(cadena);
    } 
    b.close(); 
  } 
  

  public static void Sort () throws FileNotFoundException, IOException 
  { 
    String cadena; 
    int i, cont=0;
    BufferedReader br = new BufferedReader(new FileReader(TxtFile)); 
    while((cadena = br.readLine())!=null) 
    { 
      cont++;
    } 
    br.close(); 
     

String[] ordenar= new String[cont];
cont=0;
br = new BufferedReader(new FileReader(TxtFile));
while((cadena = br.readLine())!=null) 
{ 
  ordenar[cont]=cadena;
  cont++;
} 
br.close(); 
   
Arrays.sort(ordenar,0,cont);

BufferedWriter bw = new BufferedWriter(new FileWriter(TxtFile)); 
bw.write("");
bw.close();

for(i=0;i<cont;i++)
{
  NewLine(ordenar[i]);
}  
  } 
}

spoiler

Nombre del archivo:
aa
El archivo ya existe.
¿Quieres sobreescribirlo? s/n
s
Se perderán todos los datos.
¿Estas seguro? s/n
n

Opciones.
1:Nuevo
2:Buscar
3:Ver contactos
4:Borrar
5:Salir
3

Alfredo Mingo         636 12 12 12
Chema Pamundi         655 34 56 78
Federico Rico         655 12 34 56
Francisco Jones       ciscojones@gmail.com
Goyo                  654 32 34 56
Mateo                 mateo@hotmail.com

Opciones.
1:Nuevo
2:Buscar
3:Ver contactos
4:Borrar
5:Salir
1
Nombre:Fernando Alonso
Telefono/Email:636183927

Opciones.
1:Nuevo
2:Buscar
3:Ver contactos
4:Borrar
5:Salir
2
Introduce nombre o inicial:
f
Federico Rico         655 12 34 56
Fernando Alonso       636 18 39 27
Francisco Jones       ciscojones@gmail.com

Opciones.
1:Nuevo
2:Buscar
3:Ver contactos
4:Borrar
5:Salir
4
Introduce nombre o inicial:
fe
Federico Rico         655 12 34 56
¿Borrar contacto? s/n
s
Fernando Alonso       636 18 39 27
¿Borrar contacto? s/n
n

Opciones.
1:Nuevo
2:Buscar
3:Ver contactos
4:Borrar
5:Salir
3

Alfredo Mingo         636 12 12 12
Chema Pamundi         655 34 56 78
Fernando Alonso       636 18 39 27
Francisco Jones       ciscojones@gmail.com
Goyo                  654 32 34 56
Mateo                 mateo@hotmail.com

Opciones.
1:Nuevo
2:Buscar
3:Ver contactos
4:Borrar
5:Salir
5
¿Quieres cargar otro archivo?s/n
n
Hasta pronto.

Pd: Cualquier consejo es bien recibido.

L

luisdomarco #57 Abr '18

Buenas.

Estoy mirando el tema de la herencia de clases, polimorfismo, sobrecarga de constructores... Estoy pensando en un proyecto para aplicar a lo que estoy aprendiendo y se me ha ocurrido algo que podría aplicar a mi trabajo, la carpintería.

La idea es hacer un programa que a partir de unas datos guardados en un txt, coma Alto, Ancho, Fondo, Grueso, etc, me cree otro txt con el despiece de un armario empotrado que podría imprimir.

El caso es que no estoy seguro como debo estructurarlo.

Mi idea es hacer una clase pieza, que tendría alto, ancho y grueso, una clase módulo que tendría varias piezas y una clase armario que tendría varios módulos,
luego una clase armario _corredera que heredaría de armario y otra clase armario _abatible que también heredaría de armario. Tanto la clase armario_abatible como la clase armario_corredera tendrían medidas y datos de las puertas.

Lo que no tengo claro es si armario heredaría de módulo y módulo de pieza.

Yo, en su día hice cosillas con Objetos 3D. En C había una función, struct creo recordar, para hacer estructuras de datos, así para guardar un objeto 3D necesitabas un vértice, que tenía coordenadas x, y ,z, un polígono, con varios vértices, y finalmente el objeto 3D tenía varios polígonos.

Por lo que yo entiendo con una clase podría hacer lo mismo que la función struct de C ya que una clase puede tener solo datos y un armario sería como un objeto 3D.

No se si voy bien encaminado...

Otro tema tema ya, es lo de crear el archivo txt con el despiece a partir de datos que tengo que leer de otro txt pero eso creo tenerlo "claro".

Pues nada más, no se como veis la idea, si a alguien le apetece darme algún consejo...

Saludos.

Usuarios habituales