Algoritmos / Casos de uso / Java Swing en NetBeans 8.2

Guía de los tres proyectos de registro vehicular

Tres proyectos resuelven el mismo problema: iniciar sesión, elegir una opción en un menú y guardar o consultar vehículos en archivos de texto. Cambia la manera de escribir el código, no lo que hace. Esta página explica qué hace cada parte del código que procesa datos.

Cómo usar la guía

  1. Mira el diagrama del flujo: es igual en los tres proyectos.
  2. Lee qué es el .form, para saber qué código no necesitas leer.
  3. Elige un proyecto en las pestañas y baja por sus pantallas.
  4. En cada código, pasa el mouse sobre un paso (o toca, o usa Tab y Enter): se marcan sus líneas. También funciona al revés, desde una línea.
  5. Termina con la tabla comparativa y el glosario.
Descargar los 3 proyectos (.zip, 48 KB)

Descomprime el archivo y en NetBeans 8.2 usa File > Open Project en cada carpeta: ControlVehicular, SistemaVehiculos y RegistroAutos.

01

El flujo que comparten los tres

Flujo común de los tres proyectos El login lee usuarios.txt y abre el menú. El menú abre el formulario y la tabla. El formulario escribe en el archivo de vehículos y la tabla lo lee. Loginusuario y clave Menú2 botones FormularioCrear nuevo registro TablaRegistros existentes usuarios.txt usuario y clave vehiculos.txt registros.txt autos.txt según el proyecto Entrar sigue abierto lee al pulsar Entrar escribe lee todo
El login lee usuarios.txt para comprobar usuario y clave. Si coinciden, se cierra y se abre el menú. El menú abre el formulario o la tabla y sigue abierto. El formulario agrega una línea al archivo de vehículos y la tabla lo lee completo. Cada pantalla es una clase que extiende JFrame, con su archivo .form.
  • Abre otra ventana
  • Lectura (línea punteada)
  • Escritura (línea continua gruesa)
02

¿Qué es el .form?

Cuando arrastras un botón en el diseñador de NetBeans, el diseño se guarda en un archivo .form, que es XML. NetBeans lo traduce a código Java y lo escribe dentro del método initComponents() del archivo .java. Ese código aparece en un bloque gris, y a su lado dice «do not modify»: no lo modifiques.

Al ejecutar el programa, Java solo usa el .java. El .form lo lee únicamente NetBeans. Si editas a mano el bloque gris, NetBeans lo reescribe la próxima vez que cambies el diseño y pierdes el cambio.

Tu código va fuera del bloque gris: en el constructor, después de initComponents(), y en los métodos que NetBeans crea cuando haces doble clic en un botón. Por eso esta guía no pega initComponents() completo: de cada pantalla da un resumen de lo que construye.

Del .form al programa en marcha NetBeans convierte el archivo .form, un diseño en XML, en el método initComponents del archivo .java. Al ejecutar, Java solo usa el .java. .form diseño en XML <Property …/> <Component …/> NetBeans genera FrmLogin.java initComponents() bloque gris: do not modify jButton1ActionPerformed aquí va tu código ejecutar Programasolo usa el .java el .form no se lee
Esquema: el diseño en XML pasa por NetBeans y queda como código dentro de initComponents().
InicioSesion.form, líneas 5 a 7 (RegistroAutos)
    <Property name="defaultCloseOperation" type="int" value="3"/>
    <Property name="title" type="java.lang.String" value="Inicio de sesi&#xf3;n"/>
    <Property name="resizable" type="boolean" value="false"/>

En XML, value="3" es el código de «cerrar el programa al cerrar la ventana», y &#xf3; es la letra «ó».

InicioSesion.java, líneas 69 a 71 (dentro de initComponents)
        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
        setTitle("Inicio de sesión");
        setResizable(false);

Las mismas tres propiedades, ya convertidas en llamadas Java.

03

Los tres proyectos, pantalla por pantalla

Cada proyecto tiene su pestaña. Los archivos de datos se buscan en la carpeta raíz del proyecto, que es donde NetBeans lo ejecuta.

ControlVehicular

El estilo de alguien que apenas empieza pero se ordena: los nombres son los que pone NetBeans por defecto (jButton1, jTextField1...) y el código es el que menos abstrae, línea por línea.

Clases
FrmLogin (login), FrmMenu (menú), FrmRegistro (formulario), FrmLista (tabla).
Archivos .txt
usuarios.txtcontenido real, una línea
admin,admin123
vehiculos.txtejemplo ilustrativo: placa, marca, modelo, línea, propietario; se crea al guardar el primer vehículo
P123ABC,Toyota,Corolla,SE,Ana Lopez
P456XYZ,Honda,Civic,EX,Luis Perez
Separador
La coma ,. Por eso el formulario no deja escribir comas en los datos.
Leer y escribir
Leer con Scanner. Escribir con PrintWriter sobre FileWriter("vehiculos.txt", true).
Usuario de prueba
admin y clave admin123
Rasgo distintivo
El vehículo se identifica por la placa. Es el único que prohíbe el separador en los datos y el único que usa PrintWriter.

El código de abajo es el del archivo .java, sin los comentarios y sin las marcas //GEN que NetBeans agrega. Se conserva la sangría original.

Login FrmLogin.java

Lo que genera NetBeans: initComponents() crea 3 etiquetas, una caja de texto (JTextField), una caja de clave (JPasswordField) y el botón «Entrar» (jButton1). Fija el título, impide cambiar el tamaño y usa EXIT_ON_CLOSE: cerrar esta ventana termina el programa. Conecta el botón con jButton1ActionPerformed. El constructor, aparte, hace de jButton1 el botón por defecto (la tecla Enter lo pulsa).

Método del botón Entrar
    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
        String usuario = jTextField1.getText().trim();
        String clave = new String(jPasswordField1.getPassword());

        if (usuario.isEmpty() || clave.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Escriba el usuario y la clave.", "Faltan datos", JOptionPane.ERROR_MESSAGE);
            return;
        }

        boolean encontrado = false;
        try (Scanner lector = new Scanner(new File("usuarios.txt"))) {
            while (lector.hasNextLine()) {
                String[] partes = lector.nextLine().split(",");
                if (partes.length == 2 && partes[0].trim().equals(usuario) && partes[1].trim().equals(clave)) {
                    encontrado = true;
                }
            }
        } catch (java.io.FileNotFoundException e) {
            JOptionPane.showMessageDialog(this, "No se encontro el archivo usuarios.txt", "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }

        if (encontrado) {
            new FrmMenu().setVisible(true);
            this.dispose();
        } else {
            JOptionPane.showMessageDialog(this, "Usuario o clave incorrectos.", "Error de acceso", JOptionPane.ERROR_MESSAGE);
            jPasswordField1.setText("");
        }
    }
  1. NetBeans crea este método cuando haces doble clic en el botón en el diseñador. Java lo ejecuta cada vez que alguien pulsa «Entrar». jButton1 es el nombre que NetBeans le dio al botón.

  2. getText() devuelve el texto de la caja y trim() quita espacios al principio y al final. La clave viene de un JPasswordField como arreglo de caracteres: getPassword() lo entrega y new String(...) lo convierte en un texto normal.

  3. isEmpty() es verdadero si el texto no tiene letras. || significa «o»: basta con que una caja esté vacía. Se muestra un aviso con JOptionPane y return termina el método: lo de abajo no se ejecuta.

  4. boolean solo vale true o false. Empieza en false: todavía no se encontró al usuario.

  5. new File("usuarios.txt") nombra el archivo (se busca en la carpeta del proyecto). Scanner lo lee. Lo que va entre paréntesis del try se cierra solo al terminar (try-with-resources).

  6. hasNextLine() pregunta si queda otra línea. nextLine() la lee y split(",") la corta en cada coma: la línea admin,admin123 queda como el arreglo {"admin", "admin123"}.

  7. Acepta la línea si tiene 2 partes, la parte 0 es igual al usuario escrito y la parte 1 es igual a la clave. equals compara textos (nunca se usa == para eso). && significa «y». Si todo coincide, la bandera pasa a true. El while sigue hasta el final del archivo.

  8. Si usuarios.txt no existe, Java lanza FileNotFoundException y el programa salta al catch. Se avisa y return sale del método.

  9. Si la bandera quedó en true: new FrmMenu().setVisible(true) crea la ventana del menú y la muestra, y this.dispose() cierra esta ventana de login.

  10. Si no se encontró, aviso de error y setText("") deja vacía la caja de la clave para volver a intentar.

Menú FrmMenu.java

Lo que genera NetBeans: initComponents() crea una etiqueta y dos botones: jButton1 «Ver registros existentes» y jButton2 «Crear nuevo registro». Usa EXIT_ON_CLOSE: cerrar el menú termina todo el programa.

Los dos botones del menú
    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
        new FrmLista().setVisible(true);
    }

    private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
        new FrmRegistro().setVisible(true);
    }
  1. Crea una ventana FrmLista y la muestra.

  2. Crea una ventana FrmRegistro y la muestra.

Formulario FrmRegistro.java

Lo que genera NetBeans: initComponents() crea 6 etiquetas, 5 cajas de texto (jTextField1 a jTextField5: placa, marca, modelo, línea y propietario, en ese orden) y 2 botones: jButton1 «Guardar» y jButton2 «Volver al menu» (su método solo llama a this.dispose()). Usa DISPOSE_ON_CLOSE: cerrar esta ventana no cierra el programa.

Método del botón Guardar
    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
        String placa = jTextField1.getText().trim();
        String marca = jTextField2.getText().trim();
        String modelo = jTextField3.getText().trim();
        String linea = jTextField4.getText().trim();
        String propietario = jTextField5.getText().trim();

        if (placa.isEmpty() || marca.isEmpty() || modelo.isEmpty() || linea.isEmpty() || propietario.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Complete todos los campos.", "Faltan datos", JOptionPane.ERROR_MESSAGE);
            return;
        }

        String todo = placa + marca + modelo + linea + propietario;
        if (todo.contains(",")) {
            JOptionPane.showMessageDialog(this, "No use comas en los datos.", "Dato no valido", JOptionPane.ERROR_MESSAGE);
            return;
        }

        try (PrintWriter escritor = new PrintWriter(new FileWriter("vehiculos.txt", true))) {
            escritor.println(placa + "," + marca + "," + modelo + "," + linea + "," + propietario);
        } catch (IOException e) {
            JOptionPane.showMessageDialog(this, "No se pudo guardar el registro.", "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }

        JOptionPane.showMessageDialog(this, "Vehiculo guardado.", "Listo", JOptionPane.INFORMATION_MESSAGE);
        jTextField1.setText("");
        jTextField2.setText("");
        jTextField3.setText("");
        jTextField4.setText("");
        jTextField5.setText("");
        jTextField1.requestFocus();
    }
  1. Se ejecuta al pulsar «Guardar».

  2. Cada caja se lee con getText().trim(). El número de la caja sigue el orden del diseño: jTextField1 es la placa, jTextField2 la marca, y así hasta el propietario.

  3. Si cualquiera de los cinco está vacío se avisa y return sale sin guardar.

  4. El archivo separa los datos con comas, así que una coma escrita por el usuario rompería las columnas. + une los textos y contains(",") pregunta si el resultado incluye una coma. Si la incluye, aviso y salida.

  5. FileWriter("vehiculos.txt", true): el true significa «agregar al final» sin borrar lo anterior. PrintWriter aporta println, que escribe el texto y un salto de línea. Cada vehículo queda en una línea: placa,marca,modelo,linea,propietario.

  6. Si falla la escritura, catch avisa y return evita mostrar el mensaje de éxito.

  7. Aviso de éxito, setText("") vacía las cinco cajas y requestFocus() pone el cursor de nuevo en la placa para escribir otro vehículo.

Tabla FrmLista.java

Lo que genera NetBeans: initComponents() crea una etiqueta, un JTable dentro de un JScrollPane (la barra de desplazamiento) y el botón «Volver al menu». La tabla nace con 5 columnas (Placa, Marca, Modelo, Linea, Propietario), sin filas, y con las celdas no editables. Usa DISPOSE_ON_CLOSE.

Constructor: llena la tabla
    public FrmLista() {
        initComponents();

        File archivo = new File("vehiculos.txt");
        if (!archivo.exists()) {
            return;
        }

        DefaultTableModel modelo = (DefaultTableModel) jTable1.getModel();
        try (Scanner lector = new Scanner(archivo)) {
            while (lector.hasNextLine()) {
                String[] campos = lector.nextLine().split(",");
                if (campos.length == 5) {
                    modelo.addRow(campos);
                }
            }
        } catch (FileNotFoundException e) {
        }
    }
  1. Un constructor es un método con el mismo nombre de la clase; corre una vez al hacer new FrmLista(). Primero initComponents() dibuja la ventana con la tabla vacía. La carga de datos va después, en el mismo constructor.

  2. new File(...) solo representa el archivo, todavía no lo abre. ! significa «no»: si vehiculos.txt no existe, return termina el constructor y la tabla se queda vacía.

  3. La tabla guarda sus filas en un modelo. getModel() lo entrega y (DefaultTableModel) le dice a Java de qué tipo es, para poder usar addRow.

  4. Scanner lee el archivo; el try lo cierra solo al terminar.

  5. Lee cada línea y la corta con split(","). String[] es un arreglo (lista) de textos.

  6. Solo acepta líneas con 5 datos. addRow(campos) agrega una fila a la tabla con esos 5 textos. Una línea dañada se ignora.

  7. Está vacío a propósito: si falla, la tabla queda vacía y no pasa nada más. Java obliga a escribir este catch porque new Scanner(archivo) puede lanzar FileNotFoundException, aunque aquí ya se comprobó exists().

SistemaVehiculos

La versión más simple de las tres. Nombres claros (botonEntrar, campoMarca), todo el código a la vista y casi sin trucos: abre, lee o escribe, cierra a mano.

Clases
VentanaLogin (login), VentanaMenu (menú), VentanaFormulario (formulario), VentanaTabla (tabla).
Archivos .txt
usuarios.txtcontenido real, una línea
profesor;clave2024
registros.txtejemplo ilustrativo: tipo, marca, modelo, línea, propietario; se crea al guardar el primer registro
Automóvil;Toyota;Corolla;SE;Ana López
Motocicleta;Honda;CB125;Sport;Luis Pérez
Separador
El punto y coma ;.
Leer y escribir
Leer con Scanner. Escribir con FileWriter("registros.txt", true) y su método write.
Usuario de prueba
profesor y clave clave2024
Rasgo distintivo
El vehículo se identifica por su tipo, que se elige en un JComboBox. El login da 3 intentos y luego cierra el programa.

El código de abajo es el del archivo .java, sin los comentarios y sin las marcas //GEN que NetBeans agrega. Se conserva la sangría original.

Login VentanaLogin.java

Lo que genera NetBeans: initComponents() crea 3 etiquetas, campoUsuario (JTextField), campoClave (JPasswordField) y botonEntrar. Fija el título «Acceso al sistema», no deja cambiar el tamaño y usa EXIT_ON_CLOSE. Conecta el botón con botonEntrarActionPerformed.

Contador de intentos y método del botón Entrar
    int intentos = 0;

    private void botonEntrarActionPerformed(java.awt.event.ActionEvent evt) {
        String usuario = campoUsuario.getText().trim();
        String clave = new String(campoClave.getPassword());

        if (usuario.isEmpty() || clave.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Escriba el usuario y la clave.");
            return;
        }

        boolean correcto = false;

        try {
            Scanner lector = new Scanner(new File("usuarios.txt"));
            while (lector.hasNextLine()) {
                String[] partes = lector.nextLine().split(";");
                if (partes.length == 2 && partes[0].equals(usuario) && partes[1].equals(clave)) {
                    correcto = true;
                }
            }
            lector.close();
        } catch (FileNotFoundException e) {
            JOptionPane.showMessageDialog(this, "No se encontró el archivo usuarios.txt");
            return;
        }

        if (correcto) {
            new VentanaMenu().setVisible(true);
            this.dispose();
        } else {
            intentos++;
            if (intentos == 3) {
                JOptionPane.showMessageDialog(this, "Superó los 3 intentos. El programa se cerrará.");
                System.exit(0);
            } else {
                JOptionPane.showMessageDialog(this, "Usuario o clave incorrectos. Le quedan " + (3 - intentos) + " intentos.");
                campoClave.setText("");
            }
        }
    }
  1. Esta variable está fuera de los métodos, al inicio de la clase. Por eso conserva su valor entre una pulsación y la siguiente. Empieza en 0 (en el archivo está arriba, separada del método).

  2. Se ejecuta al pulsar «Entrar».

  3. trim() quita espacios sobrantes. getPassword() entrega la clave como letras sueltas y new String(...) las une en un texto.

  4. Si falta algo, aviso y return. Este caso no cuenta como intento fallido.

  5. Empieza en false (no encontrado).

  6. Scanner abre el archivo. Aquí no hay try-with-resources: el archivo se cierra a mano más abajo.

  7. split(";") corta la línea en cada punto y coma: profesor;clave2024 queda como {"profesor", "clave2024"}.

  8. La parte 0 debe ser igual al usuario y la parte 1 a la clave. Fíjate que aquí no hay trim() sobre lo leído del archivo: un espacio de más en usuarios.txt haría fallar la comparación.

  9. close() libera el archivo. Si se olvida, queda abierto.

  10. Si usuarios.txt no existe, aviso y return.

  11. Abre el menú con new VentanaMenu().setVisible(true) y cierra el login con this.dispose().

  12. Empieza el caso de datos incorrectos.

  13. ++ suma 1 a la variable: intentos++ equivale a intentos = intentos + 1.

  14. Se avisa y System.exit(0) cierra todo el programa.

  15. (3 - intentos) calcula cuántos faltan y + lo une al mensaje. setText("") vacía la caja de la clave.

Menú VentanaMenu.java

Lo que genera NetBeans: initComponents() crea una etiqueta y dos botones: botonVerRegistros «Ver registros existentes» y botonCrearRegistro «Crear nuevo registro». Usa EXIT_ON_CLOSE.

Los dos botones del menú
    private void botonVerRegistrosActionPerformed(java.awt.event.ActionEvent evt) {
        new VentanaTabla().setVisible(true);
    }

    private void botonCrearRegistroActionPerformed(java.awt.event.ActionEvent evt) {
        new VentanaFormulario().setVisible(true);
    }
  1. Crea una VentanaTabla y la muestra.

  2. Crea una VentanaFormulario y la muestra.

Formulario VentanaFormulario.java

Lo que genera NetBeans: initComponents() crea 6 etiquetas, comboTipo (un JComboBox con las opciones Automóvil, Motocicleta, Pickup, Camión y Bus), 4 cajas de texto y 2 botones: botonGuardar y botonRegresar (llama a this.dispose()). Las opciones del combo se cambian en el diseñador, no en el código. Usa DISPOSE_ON_CLOSE.

Método del botón Guardar
    private void botonGuardarActionPerformed(java.awt.event.ActionEvent evt) {
        String tipo = (String) comboTipo.getSelectedItem();
        String marca = campoMarca.getText().trim();
        String modelo = campoModelo.getText().trim();
        String linea = campoLinea.getText().trim();
        String propietario = campoPropietario.getText().trim();

        if (marca.isEmpty() || modelo.isEmpty() || linea.isEmpty() || propietario.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Debe llenar todos los campos.");
            return;
        }

        try {
            FileWriter escritor = new FileWriter("registros.txt", true);
            escritor.write(tipo + ";" + marca + ";" + modelo + ";" + linea + ";" + propietario + "\n");
            escritor.close();
        } catch (IOException e) {
            JOptionPane.showMessageDialog(this, "No se pudo guardar el registro.");
            return;
        }

        JOptionPane.showMessageDialog(this, "El vehículo se guardó correctamente.");
        campoMarca.setText("");
        campoModelo.setText("");
        campoLinea.setText("");
        campoPropietario.setText("");
    }
  1. Se ejecuta al pulsar «Guardar registro».

  2. getSelectedItem() devuelve la opción elegida en la lista, pero como tipo general; (String) la convierte en texto. Las otras cuatro cajas se leen con getText().trim().

  3. El tipo no se revisa porque el combo siempre tiene algo elegido. Si falta marca, modelo, línea o propietario: aviso y return.

  4. FileWriter("registros.txt", true): el true agrega al final sin borrar lo anterior. write recibe un solo texto: los cinco datos unidos con + y separados por ";", más \n al final, que es el salto de línea. No se revisa si el usuario escribió un ; dentro de un dato.

  5. close() cierra el archivo y asegura que lo escrito llegue al disco.

  6. Aviso y return para no mostrar el mensaje de éxito.

  7. Aviso de éxito y setText("") en las cuatro cajas. El combo no se limpia: se queda en el último tipo elegido.

Tabla VentanaTabla.java

Lo que genera NetBeans: initComponents() crea una etiqueta, tablaVehiculos (JTable) dentro de panelTabla (JScrollPane) y botonRegresar. La tabla nace con 5 columnas (Tipo de vehículo, Marca, Modelo, Línea, Propietario) y sin filas. Usa DISPOSE_ON_CLOSE.

Constructor: llena la tabla
    public VentanaTabla() {
        initComponents();

        DefaultTableModel modelo = (DefaultTableModel) tablaVehiculos.getModel();

        try {
            Scanner lector = new Scanner(new File("registros.txt"));
            while (lector.hasNextLine()) {
                String[] datos = lector.nextLine().split(";");
                modelo.addRow(datos);
            }
            lector.close();
        } catch (FileNotFoundException e) {
        }
    }
  1. Corre al hacer new VentanaTabla(). initComponents() dibuja la ventana y lo demás llena la tabla.

  2. El modelo es donde la tabla guarda sus filas. Para agregar filas se pide con getModel(), convertido con (DefaultTableModel).

  3. Scanner abre el archivo. Si no existe, Java salta al catch. No hay exists() antes: el catch hace ese trabajo.

  4. split(";") corta cada línea en un arreglo y addRow(datos) lo agrega como fila. No se revisa cuántos datos trae: una línea con otro número de datos produciría una fila incompleta.

  5. Se cierra a mano al terminar de leer.

  6. Vacío a propósito: si todavía no se guardó ningún vehículo, no hay archivo y la tabla simplemente queda vacía.

RegistroAutos

La más completa: separa el trabajo en métodos pequeños, usa un correlativo automático, tiene botón Limpiar y muestra el total de registros.

Clases
InicioSesion (login), MenuOpciones (menú), FormularioVehiculo (formulario), TablaVehiculos (tabla).
Archivos .txt
usuarios.txtcontenido real, una línea; ⇥ marca el tabulador
usuarioabc123
autos.txtejemplo ilustrativo: número, chasis, marca, modelo, línea, propietario; ⇥ marca el tabulador
11HGCM82633A004352HondaAccordEXAna López
2JTDKB20U793012345ToyotaPriusBaseLuis Pérez
Separador
El tabulador, que en el código se escribe \t. En los ejemplos se marca con ⇥ porque en pantalla un tabulador no se ve.
Leer y escribir
Leer con BufferedReader sobre FileReader, con readLine(). Escribir con BufferedWriter sobre FileWriter(ARCHIVO_AUTOS, true), con write y newLine().
Usuario de prueba
usuario y clave abc123
Rasgo distintivo
El vehículo se identifica por su número de chasis (VIN), guardado en mayúsculas. Cada registro lleva un número correlativo automático. Tiene botón Limpiar y la tabla muestra «Total de registros: N».

El código de abajo es el del archivo .java, sin los comentarios y sin las marcas //GEN que NetBeans agrega. Se conserva la sangría original.

Login InicioSesion.java

Lo que genera NetBeans: initComponents() crea 3 etiquetas, tfUsuario (JTextField), pfClave (JPasswordField) y btEntrar. Fija el título «Inicio de sesión», no deja cambiar el tamaño y usa EXIT_ON_CLOSE. El constructor, aparte, hace de btEntrar el botón por defecto (Enter) y pone el cursor en tfUsuario.

Método auxiliar: credencialesValidas
    private static final String ARCHIVO_USUARIOS = "usuarios.txt";

    private boolean credencialesValidas(String usuario, String clave) {
        boolean encontrado = false;
        try (BufferedReader br = new BufferedReader(new FileReader(ARCHIVO_USUARIOS))) {
            String linea = br.readLine();
            while (linea != null && !encontrado) {
                String[] campos = linea.split("\t");
                if (campos.length >= 2 && campos[0].trim().equals(usuario) && campos[1].trim().equals(clave)) {
                    encontrado = true;
                }
                linea = br.readLine();
            }
        } catch (IOException e) {
            JOptionPane.showMessageDialog(this, "No se pudo leer el archivo " + ARCHIVO_USUARIOS,
                    "Error", JOptionPane.ERROR_MESSAGE);
        }
        return encontrado;
    }
  1. static final es un valor fijo que no cambia. Si el nombre del archivo cambia, se corrige en un solo lugar (en el archivo, la línea está arriba, separada del método).

  2. Recibe dos textos (usuario y clave) y devuelve un boolean. Quien lo llame recibe true o false.

  3. Empieza en false: es el resultado que se devolverá al final.

  4. FileReader abre el archivo y BufferedReader lo envuelve para poder leer línea por línea. El try lo cierra solo.

  5. readLine() devuelve la siguiente línea, o null (nada) cuando ya no hay más.

  6. Repite mientras haya línea (!= null) y todavía no se haya encontrado (!encontrado). Se detiene apenas encuentra al usuario.

  7. split("\t") corta la línea en cada tabulador: campos[0] es el usuario y campos[1] la clave.

  8. Pide al menos 2 partes (>= 2), y que usuario y clave, ya sin espacios sobrantes (trim()), sean iguales (equals) a lo escrito.

  9. Lee la línea que sigue. Sin esta instrucción el while no terminaría nunca.

  10. Muestra un aviso con JOptionPane. encontrado sigue en false.

  11. return termina el método y entrega el valor a quien lo llamó.

Método del botón Entrar
    private void btEntrarActionPerformed(java.awt.event.ActionEvent evt) {
        String usuario = tfUsuario.getText().trim();
        String clave = new String(pfClave.getPassword());

        if (usuario.isEmpty() || clave.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Escriba el usuario y la clave.",
                    "Datos incompletos", JOptionPane.WARNING_MESSAGE);
            return;
        }

        if (credencialesValidas(usuario, clave)) {
            new MenuOpciones().setVisible(true);
            this.dispose();
        } else {
            JOptionPane.showMessageDialog(this, "Usuario o clave incorrectos.",
                    "Acceso denegado", JOptionPane.ERROR_MESSAGE);
            pfClave.setText("");
            pfClave.requestFocusInWindow();
        }
    }
  1. Se ejecuta al pulsar «Entrar» o la tecla Enter.

  2. getText().trim() para el usuario; new String(pfClave.getPassword()) para la clave.

  3. Si falta algo, aviso de advertencia y return.

  4. Llama al método de arriba. Como devuelve true o false, el if decide con ese resultado.

  5. Abre el menú y cierra el login con dispose().

  6. Aviso de acceso denegado, vacía la clave con setText("") y requestFocusInWindow() devuelve el cursor a esa caja.

Menú MenuOpciones.java

Lo que genera NetBeans: initComponents() crea una etiqueta y dos botones: btRegistros «Ver registros existentes» y btNuevo «Crear nuevo registro». Usa EXIT_ON_CLOSE.

Los dos botones del menú
    private void btRegistrosActionPerformed(java.awt.event.ActionEvent evt) {
        new TablaVehiculos().setVisible(true);
    }

    private void btNuevoActionPerformed(java.awt.event.ActionEvent evt) {
        new FormularioVehiculo().setVisible(true);
    }
  1. Crea una TablaVehiculos y la muestra.

  2. Crea un FormularioVehiculo y lo muestra.

Formulario FormularioVehiculo.java

Lo que genera NetBeans: initComponents() crea 6 etiquetas, 5 cajas de texto (tfChasis, tfMarca, tfModelo, tfLinea, tfPropietario) y 3 botones: btGuardar, btLimpiar (llama a vaciarCampos()) y btRegresar (this.dispose()). El constructor hace de btGuardar el botón por defecto. Usa DISPOSE_ON_CLOSE.

Constante y métodos auxiliares
    public static final String ARCHIVO_AUTOS = "autos.txt";

    private int contarLineas() {
        int total = 0;
        File archivo = new File(ARCHIVO_AUTOS);
        if (!archivo.exists()) {
            return 0;
        }
        try (BufferedReader br = new BufferedReader(new FileReader(archivo))) {
            while (br.readLine() != null) {
                total++;
            }
        } catch (IOException e) {
            JOptionPane.showMessageDialog(this, "No se pudo leer el archivo " + ARCHIVO_AUTOS,
                    "Error", JOptionPane.ERROR_MESSAGE);
        }
        return total;
    }

    private String limpiarTexto(String texto) {
        return texto.replace('\t', ' ').trim();
    }

    private void vaciarCampos() {
        tfChasis.setText("");
        tfMarca.setText("");
        tfModelo.setText("");
        tfLinea.setText("");
        tfPropietario.setText("");
        tfChasis.requestFocusInWindow();
    }
  1. El nombre del archivo, escrito una sola vez. Es public para que otras clases lo usen: TablaVehiculos la lee como FormularioVehiculo.ARCHIVO_AUTOS.

  2. int significa que devuelve un entero: cuántas líneas tiene autos.txt.

  3. total es el contador. Si el archivo no existe todavía, return 0 entrega 0 de inmediato.

  4. readLine() lee una línea y devuelve null al terminar. Cada vuelta del while descarta la línea leída y suma 1 con total++.

  5. Aviso de error. El método sigue y devuelve lo que alcanzó a contar.

  6. Entrega la cantidad al método que llamó.

  7. Recibe un texto y devuelve otro. replace('\t', ' ') cambia cada tabulador por un espacio (si no, el usuario podría escribir una tecla Tab y romper las columnas) y trim() quita espacios de los bordes. Las comillas simples son para un solo carácter.

  8. void no devuelve nada. Deja las cinco cajas vacías y requestFocusInWindow() pone el cursor en el chasis. Lo usan el botón Guardar y el botón Limpiar.

Método del botón Guardar
    private void btGuardarActionPerformed(java.awt.event.ActionEvent evt) {
        String chasis = limpiarTexto(tfChasis.getText()).toUpperCase();
        String marca = limpiarTexto(tfMarca.getText());
        String modelo = limpiarTexto(tfModelo.getText());
        String linea = limpiarTexto(tfLinea.getText());
        String propietario = limpiarTexto(tfPropietario.getText());

        if (chasis.isEmpty() || marca.isEmpty() || modelo.isEmpty() || linea.isEmpty() || propietario.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Complete todos los campos antes de guardar.",
                    "Faltan datos", JOptionPane.WARNING_MESSAGE);
            return;
        }

        int numero = contarLineas() + 1;

        try (BufferedWriter bw = new BufferedWriter(new FileWriter(ARCHIVO_AUTOS, true))) {
            bw.write(numero + "\t" + chasis + "\t" + marca + "\t" + modelo + "\t" + linea + "\t" + propietario);
            bw.newLine();
        } catch (IOException e) {
            JOptionPane.showMessageDialog(this, "No se pudo guardar en " + ARCHIVO_AUTOS,
                    "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }

        JOptionPane.showMessageDialog(this, "Vehículo guardado con el No. " + numero + ".",
                "Guardado", JOptionPane.INFORMATION_MESSAGE);
        vaciarCampos();
    }
  1. Se ejecuta al pulsar «Guardar» o Enter.

  2. Cada caja pasa por limpiarTexto(...), el método de arriba. En el chasis se agrega toUpperCase(), que lo convierte a MAYÚSCULAS: así el VIN siempre se guarda igual.

  3. Aviso de advertencia y return si falta cualquier dato.

  4. Se cuentan las líneas que ya tiene el archivo y se suma 1. Con 2 registros guardados, el nuevo es el número 3.

  5. FileWriter(ARCHIVO_AUTOS, true): el true agrega al final sin borrar. BufferedWriter lo envuelve para escribir de forma eficiente. El try lo cierra solo.

  6. write escribe el número y los cinco campos unidos con + y separados por \t (tabulador). newLine() agrega el salto de línea, para que el siguiente registro quede abajo.

  7. Aviso de error y return para no decir «Guardado».

  8. El mensaje incluye el número asignado.

  9. Vacía las cajas y deja el cursor en el chasis.

Tabla TablaVehiculos.java

Lo que genera NetBeans: initComponents() crea una etiqueta de título, tbVehiculos (JTable) dentro de spTabla (JScrollPane), lbTotal (que empieza con «Total de registros: 0») y btRegresar. La tabla nace con 6 columnas (No., Chasis (VIN), Marca, Modelo, Línea, Propietario) y sin filas. El constructor llama a cargarTabla() justo después de initComponents(). Usa DISPOSE_ON_CLOSE.

Método cargarTabla
    private void cargarTabla() {
        DefaultTableModel modelo = (DefaultTableModel) tbVehiculos.getModel();
        modelo.setRowCount(0);
        int total = 0;

        File archivo = new File(FormularioVehiculo.ARCHIVO_AUTOS);
        if (archivo.exists()) {
            try (BufferedReader br = new BufferedReader(new FileReader(archivo))) {
                String linea = br.readLine();
                while (linea != null) {
                    String[] campos = linea.split("\t");
                    if (campos.length == 6) {
                        modelo.addRow(campos);
                        total++;
                    }
                    linea = br.readLine();
                }
            } catch (IOException e) {
                JOptionPane.showMessageDialog(this, "No se pudo leer el archivo " + FormularioVehiculo.ARCHIVO_AUTOS,
                        "Error", JOptionPane.ERROR_MESSAGE);
            }
        }

        lbTotal.setText("Total de registros: " + total);
    }
  1. void: hace su trabajo y no devuelve nada. Se llama desde el constructor.

  2. getModel() entrega el modelo y (DefaultTableModel) lo convierte al tipo exacto. setRowCount(0) borra todas las filas, y total cuenta las que se agreguen.

  3. Usa la constante de la otra clase. Si autos.txt no existe, no se entra al if y no hay filas.

  4. Abre con BufferedReader y lee la primera línea.

  5. split("\t") corta la línea en cada tabulador y devuelve un arreglo.

  6. Una línea buena tiene 6 datos: número, chasis, marca, modelo, línea y propietario. addRow(campos) agrega la fila y total++ suma 1. Las líneas dañadas se ignoran.

  7. Imprescindible: sin ella el while repetiría la misma línea sin fin.

  8. Aviso de error.

  9. setText cambia el texto de la etiqueta; el + une el texto con el número.

04

Comparación de los tres

CaracterísticaControlVehicularSistemaVehiculosRegistroAutos
Clases (login, menú, formulario, tabla)FrmLogin, FrmMenu, FrmRegistro, FrmListaVentanaLogin, VentanaMenu, VentanaFormulario, VentanaTablaInicioSesion, MenuOpciones, FormularioVehiculo, TablaVehiculos
Cómo leeScannerScannerBufferedReader + FileReader (readLine)
Cómo escribePrintWriter + FileWriter(…, true)FileWriter(…, true) con writeBufferedWriter + FileWriter(…, true) con write y newLine
Separadorcoma ,punto y coma ;tabulador (\t)
Archivo de usuariosusuarios.txtusuarios.txtusuarios.txt
Archivo de vehículosvehiculos.txtregistros.txtautos.txt
Qué es el «vehículo»Una placa, más marca, modelo, línea y propietarioUn tipo elegido en una lista, más marca, modelo, línea y propietarioUn número de chasis (VIN) en mayúsculas, más marca, modelo, línea y propietario
ExtrasProhíbe comas en los datos; Enter pulsa Entrar; limpia el formulario y vuelve a la placa3 intentos de login; lista desplegable (JComboBox)Número correlativo automático; botón Limpiar; «Total de registros: N»; métodos auxiliares; constantes
Nombres de componentesLos de NetBeans: jButton1, jTextField1Descriptivos: botonEntrar, campoMarcaCon prefijo: btEntrar, tfChasis
Nivel de dificultad2 de 3. Medio-bajo: try-with-resources y una validación1 de 3. Bajo: la más simple3 de 3. Medio: métodos auxiliares, correlativo, dos clases que se comparten una constante
05

Mini glosario de Java

Las piezas que aparecen en el código. A la derecha de cada una dice en qué proyectos se usa: CV es ControlVehicular, SV es SistemaVehiculos y RA es RegistroAutos.

Scanner
Lee texto de un archivo (o del teclado). Se crea con new Scanner(new File("x.txt")).en CV, SV
hasNextLine() / nextLine()
hasNextLine() pregunta si queda otra línea; nextLine() la lee y avanza a la siguiente.en CV, SV
split
Corta un texto en pedazos cada vez que aparece el separador y devuelve un arreglo: "a;b".split(";") da {"a", "b"}.en CV, SV, RA
trim()
Quita los espacios al principio y al final de un texto.en CV, SV, RA
equals
Compara dos textos por su contenido. Con textos no se usa ==.en CV, SV, RA
isEmpty()
Es true si el texto no tiene ningún carácter.en CV, SV, RA
try / catch
try intenta ejecutar un bloque; si ocurre el error indicado, el programa salta al catch en lugar de caerse.en CV, SV, RA
try-with-resources
Un try (...) con el archivo entre paréntesis: Java lo cierra solo al terminar el bloque.en CV, RA
FileWriter(…, true)
Abre un archivo para escribir. El true significa «agregar al final» en vez de borrar lo que había.en CV, SV, RA
PrintWriter
Escribe texto en un archivo con println, que añade el salto de línea.en CV
BufferedReader / readLine()
Lee un archivo por líneas. readLine() devuelve null cuando ya no hay más líneas.en RA
BufferedWriter / newLine()
Escribe en un archivo de forma eficiente. newLine() agrega el salto de línea.en RA
DefaultTableModel / addRow
El modelo guarda las filas de una JTable. addRow(arreglo) agrega una fila con esos datos.en CV, SV, RA
JOptionPane
Muestra una ventanita de mensaje con JOptionPane.showMessageDialog(...).en CV, SV, RA
dispose()
Cierra y libera la ventana actual (this.dispose()), sin cerrar el programa.en CV, SV, RA
getPassword()
Devuelve el contenido de un JPasswordField como arreglo de caracteres; new String(...) lo vuelve texto.en CV, SV, RA
getSelectedItem()
Devuelve la opción elegida en un JComboBox. Hay que convertirla con (String).en SV
++
Suma 1 a una variable: total++ es como total = total + 1.en SV, RA
setVisible(true)
Muestra una ventana. new FrmLista().setVisible(true) crea la ventana y la muestra.en CV, SV, RA
return
Termina el método en ese punto. Si el método devuelve un valor, lo entrega.en CV, SV, RA

Los fragmentos de código se copiaron de los archivos .java sin los comentarios. Los ejemplos de contenido de los archivos de vehículos son ilustrativos: en los proyectos ese archivo no existe hasta que se guarda el primer vehículo.