Principales métodos de la clase Graphics de Java

Métodos	Descripción
drawLine(int x1, int y1, int x2, int y2)	Dibuja un línea con el color actual desde la posición (x1,y1) hasta (x2,y2)
drawRect(int x, int y, int width, int height)	Dibuja un rectángulo sin relleno desde la posición (x,y) con ancho width y alto height
fillRect(int x, int y, int width, int height)	Dibuja un rectángulo con relleno del color actual, desde la posición (x,y) con ancho width y alto height
drawOval(int x, int y, int width, int height)	Dibuja una elipse sin relleno desde la posición (x,y) con ancho width y alto height
fillOval(int x, int y, int width, int height)	Dibuja una elipse con relleno del color actual, desde la posición (x,y) con ancho width y alto height
drawPolygon(int[] xPoints, int[] yPoints, int nPoints)	Dibuja un polígono sin relleno con nPoints puntos, cuyas coordenadas están en los arrays xPoints e yPoints
fillPolygon(int[] xPoints, int[] yPoints, int nPoints)	Dibuja un polígono con relleno del color actual con nPoints puntos, cuyas coordenadas están en los arrays xPoints e yPoints
drawPolyline(int[] xPoints, int[] yPoints, int nPoints)	Dibuja una línea quebrada con nPoints puntos, cuyas coordenadas están en los arrays xPoints e yPoints
setColor(Color c)	Establece el color actual al color especificado. El color puede ser uno de los predefinidos usando Color.nombreColor Es posible crear nuevos colores indicando en el parámetro new Color(r,g,b) con la combinación de colores rojo (r), verde (g) y azul (b) de 0 a 255.
drawString(String str, int x, int y)	Muestra el texto str en la posición (x,y)
setFont(Font font)	Estable el tipo de fuente para el texto. Es posible indicar un tipo de fuente con el constructor: Font(String name, int style, int size)

Gráficos en Java

Una de las formas de manejar gráficos en Java es crear un objeto JPanel, sobre el que se realizarán las operaciones de dibujo, y luego integrarlo en una ventana JFrame con NetBeans.

Para ello, en el proyecto de NetBeans se debe crear un nuevo "Formulario JPanel".

Una vez creado el JPanel se debe crear, dentro de su código fuente, el método paint, el cual será un método que sobreescribe el que posee dicha clase.

Se debe indicar de la siguiente forma:

(Una forma automática de escribir este código es utilizar el menú Fuente > Insertar código > Redefinir método, y dentro del objeto JComponent seleccionar el método paint y hacer clic en el botón Generar).

Es un método público (public), que no retorna ningún valor (void) y al que se pasa como parámetro un objeto de la clase Graphics al que se le llama g.

Este método es llamado automáticamente cuando se muestra en pantalla el panel, o bien, se puede utilizar en un momento determinado cuando se llama desde el código al método repaint.

En el método conviene hacer una llamada al mismo objeto de la clase padre (super.paint(g)) para que se muestren los objetos que tenga asociados el panel. Posteriormente se pueden escribir las sentencias que creen el dibujo. Un ejemplo de dichas sentencias puede ser:

g.drawLine(20, 10, 30, 50);

que dibuja una línea desde la posición (20,10) hasta la (30,50).

Hay que tener en cuenta que la posición (0,0) está en la esquina superior izquierda del panel.

Todos los métodos de la clase Graphics que se vayan a utilizar para realizar el dibujo deben llamarse indicando el objeto g, o el que se haya especificado en el parámetro del método paint, utilizando el formato:

g.nombreMétodo(parámetros);

Tras escribir el código fuente es el momento de integrar ese JPanel en el diseño de un formulario JFrame que debe crearse dentro mismo proyecto. Para ello, basta con hacer clic sobre el JPanel en el explorador de Proyectos de la parte izquierda, y arrastrarlo dentro de la ventana JFrame en el lugar deseado.

Se pueden consultar todos los métodos de la clase Graphics en la API de Java.

Añadir espacios de relleno a un String en Java

Si se desea que un String tenga un tamaño determinado, rellenando con espacios al final hasta un número de caracteres determinado se puede utilizar el método format de la clase String con la siguiente cadena de formato:

String.format("%1$-10s",cadena);

(Se debe sustituir el 10 por el tamaño deseado, y cadena debe ser la variable de tipo String o la cadena literal entre comillas sobre el que se desea aplicar el relleno).

En este ejemplo se asigna un tamaño de 10 caracteres para el String llamado cadena. Si esa cadena tuviera menos de esos 10 caracteres la sentencia anterior devolvería un String con dicha cadena seguida de los espacios necesarios hasta rellenar los 10 caracteres. En caso de que la cadena tuviera más de 10 caracteres, dicha sentencia devuelve la cadena tal cual, es decir, no la corta a 10 caracteres. Para eso habría que utilizar el método substring.

El guión que se indica delante del 10 permite que los espacios de relleno se coloquen detrás de la cadena. Si se desea que el relleno se coloque delante se debe eliminar ese guión.

Ventana de selección de archivos en Java

La clase JFileChooser (Requiere importar javax.swing.JFileChooser) permite abrir una ventana de diálogo en la que el usuario pueda seleccionar un archivo para realizar una acción sobre él (por ejemplo, abrirlo).

        //Crear un objeto FileChooser
        JFileChooser fc = new JFileChooser();
        //Mostrar la ventana para abrir archivo y recoger la respuesta
        //En el parámetro del showOpenDialog se indica la ventana
        //  al que estará asociado. Con el valor this se asocia a la
        //  ventana que la abre.
        int respuesta = fc.showOpenDialog(this);
        //Comprobar si se ha pulsado Aceptar
        if (respuesta == JFileChooser.APPROVE_OPTION)
        {
            //Crear un objeto File con el archivo elegido
            File archivoElegido = fc.getSelectedFile();
            //Mostrar el nombre del archvivo en un campo de texto
            txtNombre.setText(archivoElegido.getName());
        }

Si en vez de utilizar la ventana de diálogo para abrir un archivo se desea utilizar la ventana para guardar un archivo se debe utilizar el método showSaveDialog en vez de showOpenDialog.

         int respuesta = fc.showSaveDialog(this);

Para seleccionar directorios en vez de archivos hay que utilizar el siguiente método antes de llamar a ShowOpenDialog o ShowSaveDialog:

        fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);

Es posible modificar el directorio que se muestra al abrir la ventana utilizando el método setCurrentDirectory al que se le debe pasar por parámetro un objeto File con la ruta del directorio.

        //Cambiar al direcrio Windows
        fc.setCurrentDirectory(new File("c:/windows/"));
        //O bien usando dos barras invertidas
        fc.setCurrentDirectory(new File("c:\\windows\\"));

Principales métodos de la clase File

Método constructor

• File(String rutaFichero)
• Parámetro:
• rutaFichero: ruta completa y nombre del archivo del que se desea crear un objeto File. Debe utilizarse la barra / para separar los directorios en la ruta, en vez de la barra invertida típica de las rutas en Windows.

Métodos sobre directorios y archivos

• boolean isDirectory()
• Acción: Comprobar si el objeto es un directorio.
• Retorna: true si el objeto es un directorio y false si es un archivo.
• boolean mkdir()
• Acción: Crear el directorio especificado como rutaFichero en el constructor.
• Retorna: true si se ha creado el directorio y false en caso contrario.
• String[] list()
• Acción: Obtener la lista de archivos que hay en el directorio.
• Retorna: Un array de tipo String con la lista de los nombres de archivos.
• File[] listRoots()
• Acción: Obtener la lista de directorios raíz (Unidades de disco/particiones en Windows). Es un método static por lo que debe ser llamado directamente con la clase File, no con un objeto.
• Retorna: Un array de tipo File con la lista de los volúmenes del sistema.
• String getPath()
• Acción: Obtener la ruta del objeto.
• Retorna: Una cadena de caracteres con la ruta.

• boolean delete()
• Acción: Borrar el archivo o directorio al que hace referencia el objeto que llama a este método.
• Retorna: true si el archivo o directorio ha sido borrado, y false en caso contrario.
• boolean exists()
• Acción: Comprobar si el archivo o directorio al que hace referencia el objeto que llama a este método existe o no.
• Retorna: true si el archivo o directorio existe, y false en caso contrario.
• String getName()
• Acción: Obtener el nombre del objeto.
• Retorna: El nombre del archivo o directorio.
• long length()
• Acción: Obtener el tamaño del objeto.
• Retorna: Dicho tamaño.
• boolean renameTo(File dest)
• Acción: Cambier el nombre de un archivo o directorio.
• Parámetro:
• dest: Objeto de tipo File que hace referencia al nuevo nombre que debe tener el archivo o directorio.
• Retorna: true si se ha podido cambiar el nombre, y false en caso contrario.

Más métodos e información en la API de Java - Clase File . Ejemplo:

/Obtener la lista de archivos y directorios
//  del directorio actual
File dirActual = new File(".");
String[] lista = dirActual.list();
for (int i = 0; i < lista.length; i++)
{
   File f = new File(lista[i]);
   System.out.println("Nombre: "+f.getName());
   System.out.println("Tamaño: "+f.length());
   if(f.isDirectory())
       System.out.println("Es un directorio");
   else
       System.out.println("Es un archivo");
   System.out.println("-------------------");
}

//Comprobar si existe el archivo "prueba.txt"
File prueba = new File("prueba.txt");
if(prueba.exists())
   System.out.println("El archivo prueba.txt existe");
else
   System.out.println("El archivo prueba.txt NO existe");

Establecer botón por defecto en Java

Normalmente, en las ventanas de diálogo, se suele tener un botón activado por defecto, de manera que al pulsar Intro es como hacer clic con el ratón sobre él. Para indicar cuál es el botón por defecto en una ventana se puede utilizar el siguiente código: getRootPane().setDefaultButton(nombreDelBotón); Siendo nombreDelBotón el nombre que se le haya dado al objeto jButton que se desea tener activado por defecto. Un buen lugar para colocar esta sentencia puede ser detrás del initComponents() que se encuentra en el método constructor de la ventana.

Acceso directo a un fichero en Java

(Se debe importar java.io.RandomAccessFile)

try
{
    //La variable pos va a marcar desde donde se accede al fichero
    int pos = 10;
    //Los caracteres leídos se toman como entero
    int caract;
    //Se abre el fichero para lectura y escritura
    RandomAccessFile raf = new RandomAccessFile("directo.txt","rw");
    //Obtener el tamaño del fichero
    long tamaño = raf.length();

    //Posicionar el puntero del fichero en la posición indicada
    raf.seek(pos);
    //Bucle mientras no se alcance el final del fichero
    while(raf.getFilePointer()<tamaño)
    {
        //Leer un carácter y avanzar puntero al siguiente carácter
        caract = raf.read();
        //Mostrar en pantalla el carácter leído
        System.out.print((char)caract);
        //Retroceder una posición
        raf.seek(raf.getFilePointer()-1);
        //Escribir el carácter leído convertido a mayúsculas
        raf.write(Character.toUpperCase(caract));
    }
    //Para leer una línea entera se usa readLine
    //y usar writeBytes para escribir un String
    raf.writeBytes("Fin del fichero");
    //Cerrar el fichero
    raf.close();
}
catch(Exception e)
{
    System.out.println("Error de acceso al fichero");
}

Crear un fichero de texto y escribir líneas en él con Java

(Se debe importar java.io.FileReader y java.io.BufferedWriter)

Scanner teclado = new Scanner(System.in);
String texto="";
try
{
   FileWriter fw = new FileWriter("nuevo.txt");
   //Crear un objeto BufferedWriter
   BufferedWriter bw = new BufferedWriter(fw);
   do
   {
       //Leer, por ejemplo, un texto desde el teclado
       System.out.print("Escriba un texto: ");
       texto = teclado.nextLine();
       //Escrbir en el fichero el texto
       bw.write(texto);
       //Escribir en el fichero un salto de línea
       bw.newLine();
       //También se puede: bw.write("\n");
   }while(texto.length()>0);
   //Cerrar el buffer
   bw.close();
}
catch(Exception e)
{
   System.out.println("Error de escritura del fichero");
}

Leer un fichero de texto, línea a línea, en Java

(Se debe importar java.io.FileReader y java.io.BufferedReader)

try
{
   FileReader fr = new FileReader("prueba.txt");
   //Crear un objeto BufferedReader
   BufferedReader br = new BufferedReader(fr);
   //Leer la primera línea, guardando en un String
   String texto = br.readLine();
   //Repetir mientras no se llegue al final del fichero
   while(texto != null)
   {
       //Hacer lo que sea con la línea leída
       System.out.println(texto);
       //Leer la siguiente línea
       texto = br.readLine();
   }
   //Cerrar el buffer
   br.close();
}
catch(Exception e)
{
   System.out.println("Error de lectura del fichero");
}

Crear un fichero y escribir en él carácter a carácter en Java

(Se debe utilizar import java.io.FileWriter)

try
{
   //Abrir el fichero "nuevo.txt" para escribir en él.
   //Si no existe se crea, y si existe borra el contenido
   FileWriter fw = new FileWriter("nuevo.txt");
   //Escribir, como ejemplo, los caracteres de la A a la Z
   for(char c='A'; c<='Z'; c++)
       fw.write(c);
    //Cerrar el fichero
   fw.close();
}
catch(Exception e)
{
   System.out.println("Error de escritura del fichero");
}

Leer un fichero carácter a carácter en Java

(Se debe importar java.io.FileReader)

try
{
   //Abrir el fichero indicado en la variable nombreFichero
   FileReader fr = new FileReader("prueba.txt");
   //Leer el primer carácter
   //Se debe almacenar en una variable de tipo int
   int caract = fr.read();
   //Se recorre el fichero hasta encontrar el carácter -1
   //   que marca el final del fichero
   while(caract != -1)
   {
       //Mostrar en pantalla el carácter leído convertido a char
       System.out.print((char)caract);
       //Leer el siguiente carácter
       caract = fr.read();
   }
   //Cerrar el fichero
   fr.close();
}
catch (Exception e)
{
   System.out.println("Error de lectura del fichero");
}

Crear una carpeta de recursos en un proyecto de NetBeans

En ocasiones los proyectos creados en NetBeans pueden necesitar la utilización de recursos como imágenes, archivos de audio, etc. Es conveniente, en esos casos, crear una carpeta en la que alojar dichos archivos, de forma que quede mejor organizado el contenido del proyecto. La creación de una carpeta se puede realizar como un paquete desde el proyecto de NetBeans. Para ello se crea una nuevo paquete haciendo clic con el botón derecho del ratón sobre "Paquetes de fuentes" y eligiendo la opción "Nuevo > Paquete Java". Se indica un nombre que identifique el paquete nuevo, el cual se asignará de forma automática también a la carpeta que se creará. Un buen nombre podría se "Recursos". Desde el Explorador de archivos, o equivalente, se puede comprobar que en la carpeta "src" del proyecto se ha creado una nueva carpeta con el mismo nombre. En ella podremos guardar o copiar los archivos que formarán parte del proyecto. Los archivos que se alojen en esa carpeta se mostrarán además en el árbol del proyecto o de archivos del entorno NetBeans.

Centrar las ventanas creadas con NetBeans en Java

Por defecto, las ventanas que se crean en Java con NetBeans se muestran, al ejecutar el programa, en la esquina superior izquierda (posición 0,0). Si se desea que aparezcan en el centro de la pantalla se debe hacer modificando el código generado. Hay que localizar el método constructor de la ventana que se llamará igual que el nombre del archivo .java que la contiene. En él se encuentra una llamada al método initComponents(). Después de esa llamada se debe indicar la instrucción: setLocationRelativeTo(null); Por ejemplo, para una ventana llamada "Ventana":

public Ventana() {
      initComponents();
      setLocationRelativeTo(null);
}

Asignar código a la pulsación de botones y otros eventos en Java con NetBeans

Para que un programa realizado en Java con una interfaz gráfica pueda interactuar con el usuario (realizar acciones al pulsar botones, mover el ratón, arrastrar objetos, etc) es necesario asignar Eventos a los elementos que forman parte de la ventana. Para que un programa realice una determinada acción al pulsar un botón se debe hacer doble clic sobre el botón mientras se está en el diseño de la ventana. Al hacer doble clic soble el botón se abre el editor de código en el que se habrá creado un nuevo método cuyo nombre coincide con el nombre asignado al botón seguido del nombre del evento ActionPerformed. Ahí será donde se deba escribir el código que debe ejecutarse cuando el usuario haga clic en el botón. El manejador de evento que se crea al hacer doble clic es el que corresponde con el de ActionPerformed (llamado cuando el usuario hace clic con en el botón). Existen muchos otros tipos de eventos para botones o para cualquier tipo de elemento de una ventana. Para escribir código como respuesta a un evento cualquiera se dispone, en la ventana "Propiedades", de la pestaña "Eventos". En ella aparece una lista de los posible eventos disponibles para el elemento seleccionado en la ventana. Para escribir código dentro de un evento se debe hacer clic en el botón con tres puntos (...) que aparece a la derecha de cada tipo de evento. Esto mismo se puede hacer utilizando el menú contextual, haciendo clic con el botón derecho del ratón sobre el elemento de la ventana al que se le desea asignar un evento. Los distintos tipos de eventos se encuentran en el menú contextual dentro de la opción Eventos. En el código de los eventos se puede utilizar cualquier instrucción Java como en cualquier otro método que se diseñe. Es posible hacer referencia a cualquier elemento de la ventana a través de su nombre directamente, pudiendo llamar a cualquier método de dicho elemento para modificar alguno de sus atributos. Por ejemplo, para modificar el texto de un "jTextField" llamado "txtHoras", se puede utilizar dentro del evento ActionPerformed del botón el siguiente código: txtHoras.setText("Nuevo texto");

Cambiar privilegios del usuario de "Guadalinex V4 educativa" para ser administrador

• Arrancar el ordenador con el SystemRescueCD u otro Linux similar (Live-CD)
• Obtener la partición en la que se encuentra instalado Linux utilizando el comando cfdisk (por ejemplo, puede ser sda2).
• Crear un nuevo directorio en /mnt: mkdir /mnt/sda2
• Montar en ese directorio la partición de encontrada: mount /dev/sda2 /mnt/sda2
• Cambiar el directorio raíz a esa partición: chroot /mnt/sda2
• Editar el archivo /etc/sudoers y añadir la línea: usuario ALL=(ALL) ALL (El lugar adecuado para escribir esta línea debería ser dentro de la sección User privilege specification)
• Reiniciar el ordenador

(Para editar el archivo se puede utilizar el editor vim, en el que para hacer una modificación se debe pulsar la tecla "i" para usar el modo edición. Para salir del modo edición, pulsar la tecla Esc. Por último para salir y guardar los cambios, escribir ":x!". El símbolo de admiración es necesaria ya que el archivo no tiene permisos de escritura) Con estas operaciones el usuario predefinido "usuario" puede utilizar el comando sudo desde el terminal. Si se desea tener el escritorio con los programas de administración se debe hacer la siguiente modificación:

• Editar el archivo /etc/group y añadir en la línea admin:x:118: el nombre del usuario que en este caso es "usuario", quedando la línea así: admin:x:118:usuario

Aunque, en las pruebas que he realizado, al reiniciar el ordenador se vuelven a restaurar esos permisos y se elimina automáticamente el usuario de la lína admin en el archivo /etc/group. Siempre está la posibilidad de editar ese archivo y volver a entrar en la sesión pero sin reiniciar, lo cual mantiene esos permisos.