diseño del formulario en java

N°1.- Abrir NetBeans y crear un "New Project"--"java"--"Java Class Library".
(Dar el nombre que uno quiera no influye en nuestro objetivo).



Para efectos del ejemplo lo llamare Formulario1

N°2.- En nuestro Source Packages, daremos click secundario, y crearemos un package llamado Presentacion,otro llamado Negocio.Modelo y otro llamado Negocio.Control
(Esto lo hacemos para tener un código mas limpio)
Nos quedara algo así...



Trabajaremos en Presentacion primeramente.

Presentacion

N°3.- En nuestro package Presentacion le damos click secundario, seleccionamos "new" y le damos a "JFrame Form". (En caso de no estar abajo sale other... buscan "Swing GUI Forms" y dentro de el tiene que aparecer "JFrame Form" ) .

Lo creare con el nombre de "InterfazFormulario"..



En este ejemplo pediremos los siguientes datos (Nombre, apellidos, RUT, email, telefono)
seran obligatorios todos los datos (El rut es para los chilenos asique su codigo lo enseñare al final de este pequeño tutorial).

para este fin tendremos estos jlabel:
Nombre, Apellidos, Rut, Email, Telefono, y que sus Nombres de variables seran "JLNombre" en el caso del nombre...
(en caso de tener titulo crear un jlabel con el titulo).

Ponerle nombre visible por el usuario es click secundario y "Edit Text"
Ponerle nombre a la variable es click secundario y "Change Variable Name"

Nos quedara algo asi:



N°4.-Crearemos los JTextField:
uno para cada Dato, excepto para el rut que necesita 2, con el siguiente nombre de varible
por ejemplo: para el Nombre se llamara "txtNombre" para el Apellido se llamara "txtApellidos",
(RUT; txtRut .... txtValidador).


le damos click secundario "Edit Text" y le borramos el contenido sin ningun espacio luego agrandamos el textfield en caso de achicarse este...


Nos quedara algo así...




N°5.- Le damos un titulo al JFrame eso se hace dandolo click secundario encima del frame en cualquier lugar que no sea ni un jlabel o un JtextField y damos en "Propiedades", luego en donde dice "title" escribimos "Formulario"



N°6.- Ahora crearemos botones "Button". crearemos 3 uno para "Guardar" uno para "Limpiar" y uno para "Salir" en los cuales al igual que en los jlabel y textfield vamos a ponerle nombre de variable...
Guardar = BotonGuardar; Limpiar = BotonLimpiar; Salir = BotonSalir.



N°7.- Agregaremos fondo a un Formulario, esto lo aremos con una clase y una imagen...
Crearemos una clase llamada "FondoFormulario" (Java Class, en Presentacion) y a su vez crearemos un nuevo package llamado "Presentacion.Imagenes" (donde pondremos todas las imagenes).

en FondoFormulario.java pondremos el siguiente codigo:

//Inicio del código

package Presentacion;

/**
*
* @ author Chino
*/
import java.awt.Graphics;
import javax.swing.ImageIcon;
public class FondoFormulario extends javax.swing.JPanel {
public FondoFormulario(){
this.setSize(395, 493);
}
@ Override
public void paintComponent(Graphics g){
ImageIcon imagenFondo = new ImageIcon(getClass().getResource("/Presentacion/Imagenes/FondoFormulario.png" ) ) ;

g.drawImage(imagenFondo.getImage(),0,0,395, 493, null);
setOpaque(false);
super.paintComponent(g);
}

}

//Fin del código

Nos quedara algo así...



hasta el momento no hemos programado nada solamente nos hemos centrado en lo gráfico y aun no tiene fondo nuestro formulario, así que ahora empezaremos con un poco para programar que se ponga la imagen de fondo....

N°8.-

Le damos Click secundario sobre el JForm principal y vamos a "Events" -- "Window" -- "windowOpened"

y ahí instanciamos la clase que posee el fondo y la aplicamos de la siguiente manera..

(deberan importar la libreria "import java.awt.BorderLayout ; " eso se debe escribir abajo del nombre del package )





N°9.- Un detalle importante tendremos que cambiar de color los JLABEL dado que el fondo que escogí es oscuro por lo tanto las dejare amarillas y para efectos del ejemplo también sirve que vean como se hace
Click secundario sobre el JLabel a cambiar el color y "Propiedades"



y ahora al ejecutarlo obtendremos el siguiente resultado...



N°10.- Pero su tamaño puede ser cambiado por el usuario, por lo que debemos meternos denuevo a las propiedades del JForm principal y cambiar esa virtud...



Por fin en estos 10 pasos hemos terminado la parte netamente gráfica de este asunto.

Ahora la parte programable de este Proyecto...

N°1.- Empezaremos por el mas facil el BotonSalir que le daremos click secundario iremos a "Events" - "Action" - "ActionPerformed".

y escribiremos ahí "dispose ( ) ; " o "System.exit(0) ;" o "this.dispose ( ) ;" cualquiera nos sirve pero deben elegir una y dado que solo es una ventana YO elijo "dispose ( ) ;"



N°2.- Ahora Programaremos el BotonLimpiar con el cual dejaremos todos los JTextField nuevamente sin ninguna escritura...
Esto se hace de la siguiente manera
ej:
txtNombre.setText( "" ) ;
con esto se dice que a la variable txtNombre le llevamos (set) un String vacio ( "" ) y asi con todas las variables..

nos quedaria un codigo así:



N°3.- Se Programara el botón Guardar con las siguientes cosas. no se guardara en ninguna parte solamente en RAM (de momento), se validara que se hallan llenado los campos obligatorios y se mostrara en un JOptionPane lo que se guardara a futuro...

N°3.1.- Validar llenado de campos obligatorios
Esto lo haremos de la siguiente manera Preguntaremos al programa si los campos están llenados en caso de que no sea así le mandamos un mensaje al usuario que diga que por favor llene el campo faltante y le ponemos la sentencia "return" para que asi no siga adelante con las demás acciones...



N°3.2 Ningún nombre y ningún apellido posee números, el teléfono no posee letras (al menos en Chile no), el RUT no posee letras por lo cual aquí haremos algo interesante que solucionara algunas cosas que hay que hacer para validar números...(nos evitaremos el validarlos con un try catch que algunas veces queda mal y el error es mucho mas grande)...

Diremos que el tipo de tecla que será capturado en el JTextField serán letras y cuando sea un numero diremos que eso no se escriba y que se consuma el evento... esto lo aremos de la siguiente manera...

Nos posamos sobre el JTextField que queramos editar, le damos click secundario vamos a "Events" -- "Key" -- "KeyTyped"...
ahí capturamos el evento (que es cuando el usuario apreta una tecla) en un char y lo analizamos y decimos al programa, ¿es un dígito ese char? si es un dígito entonces consumimos el evento (osea lo hacemos nulo, que no lo escriba en el JTextField), sino solo se escribe...
(Verán como les servirá en un futuro esta parte)




y así quedaría cuando queremos introducir solo números...



N°3.3 Ahora veremos que nuestro usuario no meta demasiados caracteres y en algunos casos solo los necesarios, para practicas del ejercicio solo se hará con la longitud del texto
por lo cual también debemos entrar en el KeyTyped contar la longitud de nuestro texto y si es mayor a la longitud que nosotros queremos dar entonces que consuma el evento...
(se añade arriba del paso 3.2 como veremos a continuación )




N°4 Haremos que cuando sea llenado un campo "aparezca" una imagen de un Ticket al lado haciendo semejanza de que el campo esta correctamente llenado... veamos como se hace esto...

N°4.1 Crearemos JLabels del porte de nuestra imagen o del tamaño que necesitemos en este ejercicio se necesitan 5 JLabels para ingresar imagenes...
Agrandaremos el JFrame principal para tener espacio y los colocaremos en el (los JLabels) primero los dejaremos de un porte diferente y luego borramos lo que dice... ahora le daremos click secundario 1.- cambiaremos su nombre de variable por
ej: JLNombre --- txtNombre --- JLImagenNombre
y así con todas los JLabels que contendrán imágenes
teniendo esto le diremos cual sera su tamaño, el cual para este ejercicio lo dejaremos en 30 x 30 de la siguiente manera:



N°4.2 Programaremos el JTextField para que cuando se rellene y el usuario pase a otra casilla salga el ticket verde...
esto se hace con el evento llamado FocusLost
entonces en el JTextField le damos click secundario "Events" -- "Focus" -- "FocusLost"
En el cual preguntamos si la longitud del texto escrito es superior a 2 o 3 letras entonces que el JLabel de la imagen cambie por un ticket caso contrario que la imagen sea un null.
lo que se hace de la siguiente manera:

(primero debes iniciar una variable que contenga nuestro icono de la siguiente manera y en ese lugar dado que la ocuparemos mas de una vez...):



y luego hacemos vamos a "Events" -- "Focus" -- "FocusLost"



Una vez creado esto con todos nuestros JTextField tendremos que reeditar nuestro fondo dado que ahora no tiene las mismas dimensiones entonces para saber las dimensiones de nuestro JFrame principal damos doble click en cualquier borde de este y nos aparecerá un mensaje que nos dirá el largo y ancho separados por una coma...

Entonces vamos al FondoFormulario.java y editamos donde dice "this.setSize(aqui damos nuestros 2 valores separados por una coma) ;
Lo mismo abajo, PERO deben darle un poco mas de largo y de ancho para que la imagen no se vea apretada...
(Eso lo van arreglando a medida de las ejecuciones)



Ya con eso tendríamos el siguiente resultado ...



BONUS TRACK CHILENOS

Para auto calcular el código verificador se hace lo siguiente numero 1 se bloquea el txtValidador para que el usuario no pueda seleccionarlo



Luego en FocusLost de el txtRut aremos unos ciclos que permiten calcular el código verificador



Y ya esta.... Es un poco difícil de entender quizá no me especifique bien pero si lo ocuparan dirán "Que clase de brujería es esta" xD
pero si navegan un rato por la net verán que es lo mismo que hacen todos para calcularlo

Negocio.Control

En esta parte crearemos una clase la cual poseerá solo atributos y en casos apartados puede tener uno que otro método entonces dentro de Negocio.Control le damos click secundario y "New" -- "Java Class"...
Yo le llamare "Persona" y le daré los atributos que pedimos en la interfaz gráfica, are un constructor por defecto y uno con valores por parámetros, nos quedara algo así:



Negocio.Modelo

En este package es donde albergaremos la mayor cantidad de métodos y la menor cantidad de atributos
Para tener todos los atributos de Persona lo aremos de la siguiente manera:

Haremos una clase de nombre Agenda ( Negocio.Modelo le damos click secundario y "New" -- "Java Class"...)

Ahora lo que resta es hacer Metodos para utilizar los atributos y luego implementarlos en la Interfaz
Así que crearemos el método guardar, el cual nos guardará en un arraylist o un vector o como le llamen...
se hace así

(creación de un vector importando la clase java.util.vector)



Por consiguiente debemos llenar ese vector de Personas, pero los vectores se auto crean con capacidad de llenarse con Object (es por defecto del que hizo ese código) por lo que una ves que yo entregue al vector una clase de tipo Persona el la guardara como tipo Object por lo cual al sacar nosotros la información debemos devolver el Object a Persona... (si les resulta estresante o enredado es cosa de ver el código y lo entenderán)

N°1.1.- Guardar:
En este método lo que se hará es Guardar lo que tiene Persona en el Vector de la siguiente manera



N°1.2.- Mostrar Agenda
En este método lo que se hará simplemente es en una variable llamada "Linea" albergaremos las lineas, valga la redundancia, de todas las personas en el vector (recordar que como todo lo que hay en ese vector es de tipo Object hay que devolverlo a Persona antes de poder ocuparlo)



Modificar Guardar...
 
Crear un BotonMostrar para ver si se guarda el curso completo en nuestro Vector


Y los resultados que tiene nuestro Programa son....

Resultados

(Guardar Exitoso)


(Mostrar Exitoso)

swing de java

El paquete Swing es parte de la JFC (Java Foundation Classes) en la plataforma Java. La JFC provee facilidades para ayudar a la gente a construir GUIs. Swing abarca componentes como botones, tablas, marcos, etc...
Las componentes Swing se identifican porque pertenecen al paquete javax.swing.
Swing existe desde la JDK 1.1 (como un agregado). Antes de la existencia de Swing, las interfaces gráficas con el usuario se realizaban a través de AWT (Abstract Window Toolkit), de quien Swing hereda todo el manejo de eventos. Usualmente, para toda componente AWT existe una componente Swing que la reemplaza, por ejemplo, la clase Button de AWT es reemplazada por la clase JButton de Swing (el nombre de todas las componentes Swing comienza con "J").
Las componentes de Swing utilizan la infraestructura de AWT, incluyendo el modelo de eventos AWT, el cual rige cómo una componente reacciona a eventos tales como, eventos de teclado, mouse, etc... Es por esto, que la mayoría de los programas Swing necesitan importar dos paquetes AWT: java.awt.* y java.awt.event.*.
Ojo: Como regla, los programas no deben usar componenetes pesados de AWT junto a componentes Swing, ya que los componentes de AWT son siempre pintados sobre los de Swing. (Por componentes pesadas de AWT se entiende Menu, ScrollPane y todas las componentes que heredan de las clases Canvas y Panel de AWT).
Compilación: Estándar.

---

Estructura básica de una aplicación Swing.

Una aplicación Swing se construye mezclando componentes con las siguientes reglas.

• Debe existir, al menos, un contenedor de alto nivel (Top-Level Container), que provee el soporte que las componentes Swing necesitan para el pintado y el manejo de eventos.
• Otras componentes colgando del contenedor de alto nivel (éstas pueden ser contenedores o componentes simples).

Ejemplo 1:

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class HolaMundoSwing {
    public static void main(String[] args) {
        JFrame frame = new JFrame("HolaMundoSwing");
        final JLabel label = new JLabel("Hola Mundo");
        frame.getContentPane().add(label);

        //frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        frame.addWindowListener(new java.awt.event.WindowAdapter(){
           public void windowClosing(WindowEvent e){
             System.exit(0);
           }
        }
        );

        frame.pack();
        frame.setVisible(true);
    }
}

En las primeras líneas se importan los paquetes necesarios.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

Luego se declara la clase HolaMundoSwing y en el método main se setea el top level container:

public class HolaMundoSwing {
    public static void main(String[] args) {
        JFrame frame = new JFrame("HolaMundoSwing");
        ...
        frame.pack();
        frame.setVisible(true);
    }
}

En el ejemplo, sólo hay un contenedor de alto nivel, un JFrame. Un frame implementado como una instancia de la clase JFrame es una ventana con decoraciones, tales como, borde, título y botones como íconos y para cerrar la ventana. Aplicaciones con un GUI típicamente usan, al menos, un frame.
Además, el ejemplo tiene un componente, una etiqueta que dice "Hola Mundo".

        final JLabel label = new JLabel("Hola Mundo"); //construye el JLabel.
        frame.getContentPane().add(label);             //agrega el label al frame.

Para que el botón de cerrar cierre la ventana, hay dos opciones:

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);       //JDK 1.3+

        frame.addWindowListener(new java.awt.event.WindowAdapter(){ //versiones anteriores
          public void windowClosing(WindowEvent e){
            System.exit(0);
          }
        }
        );

---

Principales aspectos de una aplicación Swing

Como ya se dijo antes, cada aplicación Swing debe tener al menos un top-level container que contendrá toda la aplicación, estos pueden ser

• javax.swing.JFrame: Una ventana independiente.
• javax.swing.JApplet: Un applet.
• Diálogos: ventanas de interacción sencilla con el usuario como por ejemplo:
  • java.swing.JOptionPane: Ventana de diálogo tipo SI_NO, SI_NO_CANCELAR, ACEPTAR, etc...
  • java.swing.JFileChooser: Ventana para elejir un archivo.
  • java.swing.JColorChooser
  • etc.

A un contenedor se le pueden agregar otros contenedores o componentes simples, para ver una muestra visual de cada componente y sus respectivas descripciones presione aquí

Configurando el "Look & Feel" de una aplicación

Swing permite setear dinámicamente el aspecto y la forma de interacción de una aplicación, por ejemplo el siguiente código setea el L&F al estilo Java

UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName())

Existen los siguientes L&F:

• Java look & feel
• CDE/Motif look & feel
• Windows look & feel

Configurando el "Layout" de un contenedor

Varias componentes pueden contener otras componentes dentro, para determinar de qué modo esas componentes se organizarán visualmente se utiliza el concepto de Layout. Por ejemplo, el siguiente código crea un frame y setea el layout del paño de contenidos (porción central de la ventana) con BorderLayout y finalmente agrega una etiqueta al sur de la ventana.

 JFrame frame= new Jframe();
 frame.getContentPane().setLayout(new BorderLayout());
 JLabel label=new JLabel("yo voy abajo");
 frame.add(label, BorderLayout.SOUTH);

A continuación se muestran los diferentes layout estándares de swing.

Manejando eventos

Cada vez que el usuario interactúa con la aplicación se gatilla un evento, para que una componente determinada reaccione frente a un evento, debe poseer un "escuchador" con, al menos, un método determinado que se ejecutará al escuchar un evento en particular, por ejemplo, en el siguiente código se crea un botón que al ser presionado imprime en la salida estándar un mensaje.

 JButton boton=new JButton("Un botón");
 boton.addActionListener(new ActionListener(){
     public void actionPerformed(ActionEvent e){
      System.out.println("Me apretaron");
  }
 });

Swing puede generar un variado set de eventos, en la siguiente tabla se resumen los más comunes con sus respectivos "escuchadores".

Ejemplos de eventos y sus escuchadores
Acción que gatilla un evento	Tipo de escuchador
El usario hace un click, presiona Return en un área de texto o selecciona un menú	ActionListener
El usuario escoje un frame (ventana principal)	WindowListener
El usuario hace un click sobre una componente	MouseListener
El usuario pasa el mouse sobre una componente	MouseMotionListener
Una componente se hace visible	ComponentListener
Una componente adquiere el foco del teclado	FocusListener
Cambia la selección en una lista o tabla	ListSelectionListener

Threads y Swing

Como regla general sólo un thread debe accesar una componente Swing, para lograr esto, la receta es que sólo el thread que atiende los eventos invoque los métodos de las componentes.
El siguiente código sigue el patrón "The Single-Thread Rule".

//Ejemplo Thread-safe
public class MyApplication {
    public static void main(String[] args) {
        JFrame f = new JFrame(...);
        ...//agregar componentes al frame
        f.pack();
        f.setVisible(true);
        //No hacer mas GUI
    }

    ...
    //Toda la manipulación de la GUI -- setText, getText, etc. 
    //es efectuada por manejadores de eventos como actionPerformed().
    ...
}

Nota: algunos métodos dentro de la API de Swing están marcados como "thread safe", éstos pueden ser invocados concurrentemente por cualquier thread, el texto que indica esto es: "This method is thread safe, although most Swing methods are not."

---

pasos para crear un programa en java

En este post aprenderemos como crear una sencilla aplicación “Hola Mundo” en Java.

Para ello abriremos nuestro NetBeans IDE y nos dirigimos al menú File (o Archivo) en la opción New Project.

Ahora le asignamos un nombre a nuestro proyecto. Yo le he llamado HolaMundo. Debemos quitarle el ganchito a la casilla “Create Main Class” tal y como se muestra en la siguiente imagen.

Luego de esto le damos clic en Finish. Con esto habremos creado nuestro proyecto. Ahora nos fijamos en la sección de la izquierda, nos aparecerá un árbol desplegable con nuestro proyecto.  Desplegamos el contenido y encontramos Source Packages y Library.

Ahora, dentro de Source Packages encontraremos <default package>.

Le damos clic derecho a <default package>, luego en “New” y buscamos la opción Java Package.

Creamos un nuevo paquete llamado Clases.

Le damos clic en “Finish”.

Ahora, de nuevo en el árbol desplegable. En el nuevo paquete llamado Clases damos clic derecho, “New”, “JFrameForm”.

Creamos un nuevo JForm llamado “Window”.

Le damos clic en “Finish” y nos aparecerá un cuadro en blanco. Este cuadro se conoce como JFrame y es el lienzo para iniciar la creación de un programa.

En la parte de la derecha encontraremos la Paleta o Palette.

Desplegamos Swing Controls y buscamos la opción que dice “Button” o “Boton”.

Lo seleccionamos y lo arrastramos al JFrame. Con esto habremos agregado un botón a nuestro programa.

Ahora buscamos la opción llamada “Label” y la arrastramos al Frame.

Le damos clic derecho al botón que agregamos y le damos clic a “Editar Texto” o “Edit Text”.

Escribimos “Aceptar”.

Ahora hacemos lo mismo con el Label, esta vez lo llamaremos “Mensaje”.

Esta será la interfaz de nuestra primera aplicación. En la sección de la derecha, en Propiedades, es posible cambiar la fuente, el tipo de letra, el tamaño, etc.
Ahora procederemos a programar el comportamiento de nuestra aplicación.
Para ello, hacemos clic derecho en el botón que colocamos y vamos a Eventos/Events, Acciones/Action, actionPerformed.

Se nos abrirá una ventana de códigos en la cual designaremos el comportamiento del botón que colocamos en el Frame.
Eliminamos el mensaje que nos aparece por default (“// TODO add your handling code here:”) y escribimos lo siguiente:

jLabel1.setText("Hola Mundo");

1	jLabel1.setText("Hola Mundo");

Explicaré lo que esto significa:

jLabel1 es el nombre del label que colocamos, el mismo al que le escribimos “Mensaje”.

Con el comando setText() establecemos cualquier texto que deseemos. El texto que vayamos a designar debe colocarse entre comillas.

Luego que hemos escrito esto, podemos proceder a probar nuestro programa.

Ejecutamos el programa presionando F6 y nos aparecerá una ventana con un botón y la inscripción “Mensaje”. Al hacer clic en el botón “Aceptar” vemos que donde decía “Mensaje” nos aparecerá “Hola Mundo”.

Este es el principio básico de cualquier tipo de aplicación. Mi intención con este post es preparar el terreno para aplicar estos mismos procedimientos con Arduino.

Estaremos viendo algunos tips para crear aplicaciones con Java y eventualmente lograremos encender LEDs y motores con Arduino utilizando un programa creado por nosotros en Java.

historia de java

Java actualmente puede ser considerado uno de los lenguajes más extendido y usado del mundo, pero esto no siempre fue así. ¿Cual es la historia de Java?
Para hablar de la historia de java, primero debemos remontarnos a los años 80, donde C podía considerarse el lenguaje por antonomasia. Era un lenguaje versátil, que podía actuar a bajo nivel y resolvían problemas muy complejos. Era la cima de la programación estructurada, para resolver estos complejos algoritmos, se generaban grandes procedimientos con un código muy complicado de mantener a largo plazo. Por ello empezó a surgir como alternativa la programación orientada a objetos, y con ella nació C++. Entonces, ¿por qué surgio Java?

Inicios de JAVA

Java nace en 1991 con el nombre "OAK", posteriormente cambiado por Green por problemas legales, y finalmente con la denominación actual JAVA.
El objetivo de java era crear un lenguaje de programación parecido a C++ en estructura y sintaxis, fuertemente orientado a objetos, pero con una máquina virtual propia. Esto se hizo bajo el principio, de poder ser usado bajo cualquier arquitectura "Write Once, Run Anywhere (escríbelo una vez, ejecútalo en cualquier sitio)".
En 1992 se presenta el proyecto verde, con los prototipos a bajo nivel. Entre 1993 y 1994 se trabaja para poder presentar un prototipo funcional (hotJava) donde se ve todo el potencial que JAVA puede ofrecer.

Establecimiento

En 1995 finalmente, es presentada la versión alpha de java, y un año despues en 1996 es lanzado el primer JDK (JDK 1.0). El desarrollo de java a partir de entonces es imparable, se van presentando nuevos paquetes y librerías hasta la actualidad.

Java hoy en día

A día de hoy, podemos decir, que Java es uno de los lenguajes más importantes del mundo. Con una comunidad extendida en todos los componentes y más de 4 millones de desarrolladores, existen millones de dispositivos que lo usan. Ademas, tras el surgimiento de android, java se establecido como el lenguaje de programación para móviles más extendido del planeta.

Curiosidades de JAVA

El nombre de JAVA tiene una gran polémica con respecto a su origen, se discuten varias teorías:

• Una de las teorías más difundidas viene del cafe, se dice que una cafetería cercana donde los desarrolladores tomaban cafe se llamaba de la misma forma, de ahí vendria tambien su logo con una taza de cafe humeante.
• Otra versión dice que viene del acronimo: Just Another Vague Acronym ("sólo otro acrónimo ambiguo más").
• Aparte de estas teorías, la versión más plausible es que se eligió su denomicación al azar de una lista de posibles nombres.