En el presente tutorial, seguiremos explorando la creación de GUI con la biblioteca AWT de Java, esta vez con la incorporación de un menú en nuestra ventana.

Para el caso del menú, la idea es la siguiente: en cada ventana puedes definir una barra de menu (MenuBar), que es el menú que vemos en la pare superior de la misma (el que tiene las clásicas entradas “Archivo”, “Ayuda”, “Acerca de”). Dentro de ese menú principal, puedes tener varias opciones (o itemes de menú), y alguna de estas puede ser un menú también, es decir, puede ser un submenú.

Pero no tantas palabras, y más acción.

import java.awt.*;
import java.awt.event.*;

public class PruebaMenu{
	private Frame ventana;

	public PruebaMenu(){
		ventana = new Frame("Prueba de menu");
		MenuBar principal = new MenuBar();

		//crearemos un menú clásico para que se entienda la idea
		Menu archivo = new Menu("Archivo");
		MenuItem archivo_abrir = new MenuItem("Abrir");
		MenuItem archivo_guardar = new MenuItem("Guardar");
		MenuItem archivo_guardarComo = new MenuItem("Guardar como...");
		MenuItem archivo_salir = new MenuItem("Salir");

		//ahora, agregamos los elementos del menú archivo.
		archivo.add(archivo_abrir);
		archivo.add(archivo_guardar);
		archivo.add(archivo_guardarComo);
		archivo.addSeparator(); //agrega línea divisoria
		archivo.add(archivo_salir);

		//agregar el listener para los elementos del menú
		EscuchaItemMenu eim = new EscuchaItemMenu();
		archivo_abrir.addActionListener(eim);
		archivo_guardar.addActionListener(eim);
		archivo_guardarComo.addActionListener(eim);
		archivo_salir.addActionListener(eim);

		//ahora, indicamos que el menú "archivo" forma parte de la barra de menú
		principal.add(archivo);

		//Por último, le decimos a la ventana cuál es su barra de menu
		ventana.setMenuBar(principal);

		ventana.setSize(300, 300);
		ventana.setResizable(false);
		ventana.addWindowListener(new WindowListener(){
			public void windowOpened(WindowEvent e){}
			public void windowActivated(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				ventana.setVisible(false);
				ventana.dispose();
			}
		});
		ventana.setVisible(true);
	}

	class EscuchaItemMenu implements ActionListener{
		public void actionPerformed(ActionEvent e){
			MenuItem item = (MenuItem)e.getSource();
			String texto = item.getLabel();
			System.out.println("Opcion seleccionada: " + texto);
			if (texto.equals("Salir")){
				ventana.setVisible(false);
				ventana.dispose();
			}
		}
	}

	public static void main(String[] args){
		PruebaMenu pm = new PruebaMenu();
	}
}

• MenuBar principal = new MenuBar() crea la barra de menú que usaremos en la ventana.
• Menu archivo = new Menu(“Archivo”) crea el menú “Archivo que irá dentro del menú principal.
• MenuItem archivo_abrir = new MenuItem(“Abrir”) crea cada uno de los itemes que irán dentro de archivo.
• archivo.add(archivo_abrir) con este método estamos agregando los itemes como parte del menú archivo.
• principal.add(archivo) agrega el menú Archivo a la barra de menú.
• ventana.setMenuBar(principal) asigna la barra de menú a la ventana. Sin este paso, no se ve ningún menú en la ventana.

Otro punto ventajoso para nosotros es que el Listener de cada item de menú es el ActionListener, que ya conocemos; como nota al margen, se puede agregar un ActionListener al menú (en este caso, a Archivo)… busca en la API de Java la clase java.awt.Menu para ver más detalles.

Otra cosa importante: además del MenuItem, existe el CheckboxMenuItem, que es un item que puede estar seleccionado o no (el típico elemento de menú al que le aparece un ‘visto bueno’ al lado).

También es importante indicar que se pueden anidar los elementos, es decir, puedo poner un menú dentro de un menú para ir haciendo un submenú… como en el siguiente código.

import java.awt.*;
import java.awt.event.*;

public class PruebaMenu{
	private Frame ventana;

	public PruebaMenu(){
		ventana = new Frame("Prueba de menu");
		MenuBar principal = new MenuBar();

		//crearemos un menú clásico para que se entienda la idea
		Menu archivo = new Menu("Archivo");
		MenuItem archivo_abrir = new MenuItem("Abrir");
		MenuItem archivo_guardar = new MenuItem("Guardar");
		MenuItem archivo_guardarComo = new MenuItem("Guardar como...");
		Menu importar = new Menu("Importar");
		MenuItem archivo_salir = new MenuItem("Salir");

		//ahora, agregamos los elementos del menú archivo.
		archivo.add(archivo_abrir);
		archivo.add(archivo_guardar);
		archivo.add(archivo_guardarComo);
		archivo.addSeparator(); //agrega línea divisoria
		archivo.add(importar);
		archivo.add(archivo_salir);

		//los elementos del menú importar
		MenuItem importar_imagen = new MenuItem("Importar desde imagen");
		MenuItem importar_odf = new MenuItem("Importar desde ODF");
		MenuItem importar_html = new MenuItem("Importar desde HTML");
		MenuItem importar_pdf = new MenuItem("Importar desde HTML");
		CheckboxMenuItem importar_repetidos = new CheckboxMenuItem("Importar elementos repetidos", true);
		importar.add(importar_imagen);
		importar.add(importar_odf);
		importar.add(importar_html);
		importar.add(importar_pdf);
		importar.addSeparator();
		importar.add(importar_repetidos);

		//agregar el listener para los elementos del menú
		EscuchaItemMenu eim = new EscuchaItemMenu();
		archivo_abrir.addActionListener(eim);
		archivo_guardar.addActionListener(eim);
		archivo_guardarComo.addActionListener(eim);
		archivo_salir.addActionListener(eim);
		importar_imagen.addActionListener(eim);
		importar_odf.addActionListener(eim);
		importar_html.addActionListener(eim);
		importar_pdf.addActionListener(eim);
		importar_repetidos.addItemListener(new ItemListener(){
			public void itemStateChanged(ItemEvent e){
				System.out.println("  Importar repetidos: " + (e.getStateChange() == ItemEvent.SELECTED));
			}
		});

		//ahora, indicamos que el menú "archivo" forma parte de la barra de menú
		principal.add(archivo);

		//Por último, le decimos a la ventana cuál es su barra de menu
		ventana.setMenuBar(principal);

		ventana.setSize(300, 300);
		ventana.setResizable(false);
		ventana.addWindowListener(new WindowListener(){
			public void windowOpened(WindowEvent e){}
			public void windowActivated(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				ventana.setVisible(false);
				ventana.dispose();
			}
		});
		ventana.setVisible(true);
	}

	class EscuchaItemMenu implements ActionListener{
		public void actionPerformed(ActionEvent e){
			MenuItem item = (MenuItem)e.getSource();
			String texto = item.getLabel();
			System.out.println("Opcion seleccionada: " + texto);
			if (texto.equals("Salir")){
				ventana.setVisible(false);
				ventana.dispose();
			}
			else if (texto.equals("Importar elementos repetidos")){
				CheckboxMenuItem check = (CheckboxMenuItem)e.getSource();
				System.out.println("  Importa repetidos: " + check.getState());
			}
		}
	}

	public static void main(String[] args){
		PruebaMenu pm = new PruebaMenu();
	}
}

Nota que el listener para el CheckboxMenuItem es el ItemListener, y no el ActionListener; si quieres, puedes probar agregando ambos listener al CheckboxMenuItem para ver cuál es el que se activa.

Para finalizar, sólo señalar que se pueden agregar varios elementos Menu al MenuBar (esta vez sólo agregué uno para no complicar el ejemplo), y que se pueden generar submenues de la profundidad que necesites (es decir, puedes poner menú dentro de menú tanto como sea necesario).

Bien, eso ha sido todo por este tutorial.

Como siempre, si quieres aprender más detalles, revisa la API de Java y practica, practica, practica.

Hasta la próxima!

En este tutorial, veremos cómo se pueden acomodar dos o mas widgets dentro de una ventana.

Para poder poner más de un widget en una ventana, se debe cambiar su diseño o layout. Java nos proporciona varios layouts, pero presentaré acá los más comunes para dejar las nociones de uso de layouts, y el resto queda a investigación del lector; no olvidar que una excelente forma de aprender Java es tener la documentación de la API a mano.

FlowLayout

Este es el layout más fácil de usar, y el más básico. La idea es que los elementos se ubicarán dentro de la ventana en el mismo orden en que los fui añadiendo. Así de simple. Además, ese orden se acomoda dependiendo de los tamaños de la ventana… pero eso queda -como siempre- más claro con un pequeño ejemplito:

import java.awt.*;
import java.awt.event.*;

public class PruebaFlowLayout{
	public PruebaFlowLayout(){
		//crear la ventana
		Frame ventana = new Frame("Flow Layout");
		ventana.setLayout(new FlowLayout());
		//ventana.setSize(300, 100);
		ventana.setSize(100, 300);
		ventana.addWindowListener(new WindowListener(){
			public void windowActivated(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowOpened(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				System.out.println("Cerrando ventana...");
				e.getWindow().dispose();
			}
		});

		//agregar los botones
		ListenerBoton lb = new ListenerBoton();
		for(int i = 1; i <= 4; i++){
			Button boton = new Button("Boton " + i);
			boton.addActionListener(lb);
			ventana.add(boton);
		}

		//mostrar la ventana
		ventana.setVisible(true);
	}

	//listener para los botones
	class ListenerBoton implements ActionListener{
		public void actionPerformed(ActionEvent e){
			String texto = ((Button)e.getSource()).getLabel();
			System.out.println("Boton presionado: " + texto);
		}
	}

	//main
	public static void main(String[] args){
		PruebaFlowLayout pfl = new PruebaFlowLayout();
	}
}

EL resultado sería algo similar a lo siguiente:

Mucho del código acá mostrado ya es conocido, así que sólo me quedo con las novedades.

• ventana.setLayout() es el método que nos permite asignar un layout o diseño a la ventana. El parámetro para este método debe ser uno de los layouts que existen en el paquete java.awt; para este ejemplo, pasé como parámetro un nuevo FlowLayout.

Tambien nota que utilizo un ciclo for para agregar cuatro botones a nuestra ventana.

Fíjate lo que pasa cuando cambias el tamaño de la ventana. Prueba lo siguiente: haz la ventana más alta que ancha, y fíjate lo que pasa con la distribución de los botones… sigue siendo ordenada según agregué los botones a la ventana, pero el orden cambia de horizontal a vertical dependiendo del tamaño de la ventana.

BorderLayout

Otro layout que normalmente se utiliza es el BorderLayout. La idea de este layout es posicionar los componentes según los puntos cardinales… veamos cómo queda el código asociado:

import java.awt.*;
import java.awt.event.*;

public class PruebaBorderLayout{
	public PruebaBorderLayout(){
		//crear la ventana
		Frame ventana = new Frame("Border Layout");
		ventana.setLayout(new BorderLayout());
		ventana.setSize(300, 250);
		ventana.addWindowListener(new WindowListener(){
			public void windowActivated(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowOpened(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				System.out.println("Cerrando ventana...");
				e.getWindow().dispose();
			}
		});

		//agregar los botones
		ListenerBoton lb = new ListenerBoton();
		Button boton = new Button("Norte");
		boton.addActionListener(lb);
		ventana.add(boton, BorderLayout.NORTH);
		boton = new Button("Sur");
		boton.addActionListener(lb);
		ventana.add(boton, BorderLayout.SOUTH);
		boton = new Button("Este");
		boton.addActionListener(lb);
		ventana.add(boton, BorderLayout.EAST);
		boton = new Button("Oeste");
		boton.addActionListener(lb);
		ventana.add(boton, BorderLayout.WEST);
		boton = new Button("Centro");
		boton.addActionListener(lb);
		ventana.add(boton, BorderLayout.CENTER);

		//mostrar la ventana
		ventana.setVisible(true);
	}

	//listener para los botones
	class ListenerBoton implements ActionListener{
		public void actionPerformed(ActionEvent e){
			String texto = ((Button)e.getSource()).getLabel();
			System.out.println("Boton presionado: " + texto);
		}
	}

	//main
	public static void main(String[] args){
		PruebaBorderLayout pbl = new PruebaBorderLayout();
	}
}

Y nuestro programa se vería más o menos así:

Nuevamente, me centro en los cambios:

• ventana.setLayout(new BorderLayout()) define el layout de la ventana como BorderLayout.
• ventana.add(boton, BorderLayout.X) define en qué posición se agrega el widget. En este caso, lo que se estaba agregando era un botón, y X puede tomar los valores NORTH, SOUTH, EAST, WEST o CENTER según se requiera.

Prueba esta vez a cambiar el tamaño de la ventana, y cómo se modifican los botones dentro de ella.

GridLayout

La idea del GridLayout es poner los widgets en grilla, es decir, en una malla. Es tan sencillo como “cuadricular” la ventana para poner los componentes que se desee. Vamos al ejemplo:

import java.awt.*;
import java.awt.event.*;

public class PruebaGridLayout{
	public PruebaGridLayout(){
		//crear la ventana
		Frame ventana = new Frame("Grid Layout");
		ventana.setLayout(new GridLayout(2, 2));
		ventana.setSize(300, 250);
		ventana.addWindowListener(new WindowListener(){
			public void windowActivated(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowOpened(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				System.out.println("Cerrando ventana...");
				e.getWindow().dispose();
			}
		});

		//agregar los botones
		ListenerBoton lb = new ListenerBoton();
		for(int i = 1; i <= 4; i++){
			Button b = new Button("Boton " + i);
			b.addActionListener(lb);
			ventana.add(b);
		}

		//mostrar la ventana
		ventana.setVisible(true);
	}

	//listener para los botones
	class ListenerBoton implements ActionListener{
		public void actionPerformed(ActionEvent e){
			String texto = ((Button)e.getSource()).getLabel();
			System.out.println("Boton presionado: " + texto);
		}
	}

	//main
	public static void main(String[] args){
		PruebaGridLayout pbl = new PruebaGridLayout();
	}
}

Y nuestra ventana se vería más o menos así:

Entonces, lo importante está en ventana.setLayout(new GridLayout(2,2))… ¿qué significan esos 2 que están ahí? Pues simple: el numéro de filas y columnas (respectivamente) en los que será dividida la ventana; prueba cambiar los números para ver lo que ocurre.

Otra cosa importante de destacar es el orden en que los botones se agregan: fíjate que van desde la primera fila (desde arriba hacia abajo), y desde la primera columna (de izquiera a derecha).

Interfaces más complejas: paneles y layouts anidados

Si bien no hemos visto todos los layouts, tenemos herramientas suficientes para crear interfaces de usuario relativamente complejas. Para esto, debes saber que los layouts se pueden anidar, es decir, yo podría poner -por ejemplo- un GridLayout al norte de un BorderLayout, y otras mezclas. Para lograr eso, el layout anidado se pone dentro de un Panel (java.awt), que es un widget no visible que actúa como contenedor (igual que la ventana), así que a un Panel se le puede asignar un layout.

¿Cómo combino entonces los layouts? Depende exclusivamente de lo que me interesa hacer, nada más.

Para muestra, un último ejemplo:

import java.awt.*;
import java.awt.event.*;

public class Anidados{
	public Anidados(){
		//crear la ventana
		Frame ventana = new Frame("Layouts y paneles");
		ventana.setLayout(new BorderLayout());
		ventana.setSize(450, 400);
		ventana.addWindowListener(new WindowListener(){
			public void windowActivated(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowOpened(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				System.out.println("Cerrando ventana...");
				e.getWindow().dispose();
			}
		});

		ListenerBoton lb = new ListenerBoton();
		Button b = null;

		Panel p1 = new Panel(new FlowLayout());
		for(int i = 1; i <= 5; i++){
			b = new Button("Boton p1-" + i);
			b.addActionListener(lb);
			p1.add(b);
		}
		ventana.add(p1, BorderLayout.SOUTH);

		Panel p2 = new Panel(new GridLayout(3,3));
		for(int i = 1; i <= 9; i++){
			b = new Button("Boton p2-" + i);
			b.addActionListener(lb);
			p2.add(b);
		}
		ventana.add(p2, BorderLayout.CENTER);

		b = new Button("Norte");
		b.addActionListener(lb);
		ventana.add(b, BorderLayout.NORTH);

		b = new Button("Oeste");
		b.addActionListener(lb);
		ventana.add(b, BorderLayout.WEST);

		b = new Button("Este");
		b.addActionListener(lb);
		ventana.add(b, BorderLayout.EAST);

		//mostrar la ventana
		ventana.setVisible(true);
	}

	//listener para los botones
	class ListenerBoton implements ActionListener{
		public void actionPerformed(ActionEvent e){
			String texto = ((Button)e.getSource()).getLabel();
			System.out.println("Boton presionado: " + texto);
		}
	}

	//main
	public static void main(String[] args){
		Anidados a = new Anidados();
	}
}

Esto es sólo un ejemplo de lo que podría hacer; de aquí en adelante, la creatividad de cada uno es fundamental para llegar al layout que necesito para mi aplicación.

Bueno, eso es todo por este tutorial.

Pronto, tutoriales con más widgets para Java y AWT.

Hasta la próxima!

Siguiendo con los tutoriales de GUI en Java, esta vez veremos cómo se crean botones en nuestras GUI, y cómo programar código asociado a los mismos.

En Java, el botón es la clase Button del paquete java.awt. El listener asociado es el ActionListener, que -como casi todos los listener- pertenece a java.awt.event.

En el tutorial anterior, vimos ya cómo crear una ventana con Java. Ahora, lo que haremos será crear, además de la ventana, un botón dentro de ella. En fin, creo que se aprende mejor con un ejemplo, así que vamos a ello:

import java.awt.*;
import java.awt.event.*;

public class PruebaBoton{
	private Frame ventana;

	public PruebaBoton(){
		ventana = new Frame("Probando Button");
		ventana.setSize(120, 80);
		ventana.addWindowListener(new WindowListener(){
			public void windowOpened(WindowEvent e){}
			public void windowActivated(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				ventana.dispose();
			}
		});
		Button boton = new Button("Mi botón");
		ventana.add(boton);
		ventana.setVisible(true);
	}

	public static void main(String[] args){
		PruebaBoton pb = new PruebaBoton();
	}
}

Mucho del código anterior ya es conocido, así que me voy a las novedades:

• Button boton = new Button(“Mi botón”) es lo que crea un nuevo botón. El texto que tendrá el botón es lo que pasamos como parámetro al constructor.
• ventana.add(boton) es lo que agrega el botón a la ventana.

Si te fijas bien, ahora se entiende la ventaja de que una ventana no sea visible inmediatamente: podemos configurar toda la interfaz (es decir, agregar los widgets que sean necesarios) antes de mostrarla.

Ok, tenemos botón… pero no responde. Nuevamente, hay que agregar un listener, y ese es el famoso ActionListener. Así que retocamos el código anterior para ponerle un poco de acción a nuestra interfaz:

import java.awt.*;
import java.awt.event.*;

public class PruebaBoton{
	private Frame ventana;

	public PruebaBoton(){
		ventana = new Frame("Probando Button");
		ventana.setSize(120, 80);
		ventana.addWindowListener(new WindowListener(){
			public void windowOpened(WindowEvent e){}
			public void windowActivated(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				ventana.dispose();
			}
		});
		Button boton = new Button("Mi botón");
		boton.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent e){
				System.out.println("Boton presionado");
			}
		});
		ventana.add(boton);
		ventana.setVisible(true);
	}

	public static void main(String[] args){
		PruebaBoton pb = new PruebaBoton();
	}
}

(Nota: debes ejecutar desde una consola/terminal/símbolo de sistema para poder ver lo que hace el botón)

Como puedes ver, la única novedad es que hemos agregado el ActionListener al botón; a diferencia del WindowListener, en ActionListener sólo tenemos un método, que recibe un ActionEvent como argumento.

A quienes les gusta meter mano en los ejemplos, se estarán preguntando: ¿y para poner más de un botón? Bueno, ahí la cosa no es tan simple, ya que hay que distribuir los botones dentro de la ventana para que se vean.

¿Y debería poner un ActionListener para cada botón? No necesariamente: si programo una clase que implemente a ActionListener podría agregar la misma instancia a más de un botón, pero tendré que detectar primero de qué botón viene la acción. Sin entrar en los detalles de la distribución de los botones (y widgets en general, que veremos en un próximo tutorial), veamos un ejemplo al respecto:

import java.awt.*;
import java.awt.event.*;

public class PruebaBoton{
	private Frame ventana;
	private Button boton1;
	private Button boton2;

	public PruebaBoton(){
		ventana = new Frame("Probando Button");
		ventana.setSize(120, 80);
		ventana.addWindowListener(new WindowListener(){
			public void windowOpened(WindowEvent e){}
			public void windowActivated(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				ventana.dispose();
			}
		});
		boton1 = new Button("Boton 1");
		boton2 = new Button("Boton 2");
		EscuchaBoton eb = new EscuchaBoton();
		boton1.addActionListener(eb);
		boton2.addActionListener(eb);
		ventana.setLayout(new FlowLayout());
		ventana.add(boton1);
		ventana.add(boton2);
		ventana.setVisible(true);
	}

	class EscuchaBoton implements ActionListener{
		public void actionPerformed(ActionEvent e){
			Button b = (Button)e.getSource();
			System.out.println("Boton presionado: " + b.getLabel());
			if (b == boton1)
				System.out.println("\tSI, definitivamente es el boton1");
			else if (b == boton2)
				System.out.println("\tSI, definitivamente es el boton2");
		}
	}

	public static void main(String[] args){
		PruebaBoton pb = new PruebaBoton();
	}
}

Como ves, acá creo una clase que implementa a ActionListener, y el mismo listener se agrega a los dos botones. Con el método e.getSource() en el listener obtenemos el origen del evento, es decir, qué objeto es el que cambió su estado. Este método retorna un Object, por eso se hace el cast a un botón… y el método getLabel() de Button nos permite obtener el texto de un botón.

Bueno, eso es todo por este tutorial. En el próximo, veremos cómo se pueden distribuir widgets dentro de una ventana, para luego ir avanzando con otros widgets de uso común.

Hasta la próxima!

Ahora que hemos visto un poquito de la teoría de las GUI con Java, podemos dar el siguiente paso: nuestra primera ventana y el respectivo listener para responder a sus eventos. Esta vez, como es lógico, nos “ensuciaremos las manos” con un poco de código, para irnos acostumbrando hasta llegar a GUI un poco más complejas.

En Java, la ventana (llamada también Form en algunos toolkits), es llamada Frame, y forma parte del paquete java.awt. Por su parte, WindowListener forma parte de java.awt.event.

Veamos algunos métodos de Frame con un pequeño ejemplo.

import java.awt.Frame;

public class WinListener{
	private Frame ventana;

	public WinListener(){
		ventana = new Frame("Muestra WindowListener");
		ventana.setSize(640, 480);
		ventana.setVisible(true);
	}

	public static void main(String[] args){
		WinListener w = new WinListener();
	}
}

Como ves, el código es relativamente corto.

Fíjate que la clase fue declarada como public, asi que el código anterior debe estar en un archivo llamado WinListener.java o no compilará.

Veamos de a poco.

• ventana = new Frame(“Muestra WindowListener”) crea un nuevo Frame o ventana, con el título indicado. Este es uno de los constructores de Frame.
• ventana.setSize(640, 480) da tamaño a la ventana. El primer número es su ancho, el segundo el alto; ambos números se refieren a pixeles.
• ventana.setVisible(true) hace visible la ventana. En Java, crear una ventana no la hace visible inmediatamente. En próximos tutoriales veremos las ventajas de aquello.

Si ejecutas el código, te vas a encontrar con algo más o menos así:

También puedes notar que minimizar/maximizar la ventana funciona sin problemas, pero cerrar no produce absolutamente nada. ¿Qué es lo que pasa ahí? Pues simple: no hay un listener que haga algo con el evento cerrar ventana.

Ahora hace su entrada magistral el primer listener que estudiaremos: WindowListener. Como es una interfaz, debemos hacer una clase que lo implemente, es decir, que ponga código a los métodos que declara; WindowListener declara cinco métodos… pero basta de palabrerías. ¡Vamos al código!

import java.awt.Frame;
import java.awt.event.WindowListener;
import java.awt.event.WindowEvent;

public class WinListener{
	private Frame ventana;

	public WinListener(){
		ventana = new Frame("Muestra WindowListener");
		ventana.setSize(640, 480);
		ventana.setVisible(true);
		ventana.addWindowListener(new EscuchaVentana());
	}

	class EscuchaVentana implements WindowListener{
		public void windowActivated(WindowEvent e){
			System.out.println("windowActivated");
		}

		public void windowClosed(WindowEvent e){
			System.out.println("windowClosed");
		}

		public void windowClosing(WindowEvent e){
			System.out.println("windowClosing");
			ventana.dispose();
		}

		public void windowDeactivated(WindowEvent e){
			System.out.println("windowDeactivated");
		}

		public void windowDeiconified(WindowEvent e){
			System.out.println("windowDeiconified");
		}

		public void windowIconified(WindowEvent e){
			System.out.println("windowIconified");
		}

		public void windowOpened(WindowEvent e){
			System.out.println("windowOpened");
		}

	}

	public static void main(String[] args){
		WinListener w = new WinListener();
	}
}

El código de nuestro constructor no tiene modificaciones mayores, salvo su última línea: ventana.addWindowListener(new EscuchaVentana());

En esa línea es donde estamos registrando el WindowListener, es decir, lo estamos asociando con la ventana. Si te fijas, poco más abajo tenemos una clase llamada EscuchaVentana, que es una implementación del WindowListener y que nos permitirá realizar alguna operación en cada evento que se genere.

Para cada método, sólo he puesto código para que escriba en consola el nombre del método/evento generado, así que te recomiendo ejecutar tu código desde una consola/terminal/símbolo de sistema para que puedas apreciar lo que pasa con la ventana.

Y ahora si, nuestra ventana está totalmente operativa.

La clave para que se cierre está en el método windowClosing del listener. windowClosing es el evento que se genera cuando se intenta cerrar la ventana, es decir, cuando el usuario presiona la X de la esquina. Para que la ventana se cierre, esta debe ser liberada, es decir, llamar al método dispose() de la misma; si no se hace esto, el evento se genera, pero la ventana no se cierra.

Para los más avanzados en programación, habrán notado que EscuchaVentana es una clase contenida en WinListener, por lo que EscuchaVentana tiene acceso a los atributos de WinListener. ¿Y qué hubiera pasado si WinListener hubiera heredado de Frame? No podía haber dicho this.dispose() en windowClosing(), puesto que en ese contexto, this habría sido instancia de EscuchaVentana… Una forma alternativa de obtener la ventana sobre la que se generó el evento es con el método getWindow() de WindowEvent (fíjate que el parámetro de todos los métodos de WindowListener es un WindowEvent). Así que en el código podrías reemplazar perfectamente

ventana.dispose()

En el método windowClosing(), por…

e.getWindow().dispose()

obteniendo el mismo resultado en ambos casos.

Quienes tengan conocimientos más avanzados de Java, de seguro conocerán las clases anónimas, que es una clase que sólo tiene alcance dentro del ámbito en el cual se define. Son relativamente habituales justamente para implementar listener de GUI, y el código con una clase anónima quedaría más o menos así:

import java.awt.Frame;
import java.awt.event.WindowListener;
import java.awt.event.WindowEvent;

public class WinListener{
	private Frame ventana;

	public WinListener(){
		ventana = new Frame("Muestra WindowListener");
		ventana.setSize(640, 480);
		ventana.setVisible(true);
		ventana.addWindowListener(new WindowListener(){
			public void windowActivated(WindowEvent e){}
			public void windowClosed(WindowEvent e){}
			public void windowDeactivated(WindowEvent e){}
			public void windowDeiconified(WindowEvent e){}
			public void windowIconified(WindowEvent e){}
			public void windowOpened(WindowEvent e){}
			public void windowClosing(WindowEvent e){
				System.out.println("Cerrando ventana...");
				e.getWindow().dispose();
			}
		});
	}

	public static void main(String[] args){
		WinListener w = new WinListener();
	}
}

En este caso, se está creando una implementación de WindowListener al vuelo, lo que te ahorra tener que crear una clase nueva exclusivamente para eso. También nota que ahora sólo puse código para el método windowClosing(), puesto que es el único que me interesa controlar para este ejemplo; el resto de métodos se queda sin cuerpo.

Es importante destacar en este punto que una clase anónima sólo tiene alcance en el punto donde se declara y que los métodos que implementa no son una expresión lambda (o closure), así que no caigas en la tentación. De todas maneras, una clase anónima siempre es una clase anidada, es decir, puede acceder a los atributos de la clase que la contiene.

Bueno, eso es todo por este pequeño tutorial. Pronto veremos widgets que podemos ir agregando a nuestra ventana para construir aplicaciones más complejas e interesantes.

Si quieres profundizar e investigar, revisa la famosa API de Java en la cual encontrarás más detalles acerca de WindowEvent y de WindowListener.

¡Hasta la próxima!

Veremos ahora la teoría necesaria para entender el desarrollo de GUI (graphical user interfaces, interfaces gráficas de usuarios); la teoría que veremos ahora es aplicable no sólo a Java, sino que a cualquier desarrollo con GUI que realicen, independiente de que cada biblioteca de GUI o lenguaje de programación utilice términos ligeramente diferentes.

Objetos y eventos

Como probablemente ya sepamos, Java es un lenguaje orientado a objetos, es decir, cuando ejecutamos una aplicación tenemos un conjunto de objetos interactuando entre si. Esto significa que la unidad mínima de programación es la clase, la definición abstracta de un objeto.

Cuando programamos una GUI (piensen en cualquier aplicación que usen comunmente, como el mismo navegador web), nos damos cuenta que esa interfaz responde a eventos como hacer click en un menú, poner cursor sobre cierto punto, hacer click en un botón, etcétera. Esto significa que cuando yo -como usuario- genero un evento -como el click en un botón-, en ese momento mi aplicación responde al evento ejecutando una porción del programa.

Para muchos, la relación está medianamente clara: entonces la GUI podría ser una clase, y los eventos podrían ser métodos. Y si, esa es una buena aproximación, pero no es exactamente lo que hace Java.

Los listeners

La aproximación que utiliza Java es también una orientada a objetos, y esta es utilizar el patrón observador (observer); es curioso que siendo el patrón observer, Java los haya llamado listeners (y después dicen que los informáticos no tenemos sentido del humor xD).

La idea es la siguiente: yo puedo poner listeners a cada objeto de una GUI, y cada listener estará pendiente de un determinado cambio en el objeto de GUI. Cuando este cambio suceda, el listener ejecutará una acción determinada. ¿Sencillo, verdad?

Para los más avanzados en conceptos de POO, los listeners son meras interfaces que debemos implementar y registrar o agregar al objeto que nos interesa escuchar. En la imagen que está más arriba, si yo no agrego el listener correspondiente al botón Cancelar, cuando haga click sobre él no pasará absolutamente nada.

Como observación, en otros toolkits de GUI (como gtk y qt), no se trabaja en base a listeners, sino que en base a señales y manejadores. Si bien la idea es similar, un manejador (o handler) puede ser simplemente un método/función, y no un objeto. En .net se ocupa esta misma idea, utilizado para ello los delegates (delegados).

Los widgets

En la mayoría de la documentación que puedan encontrar por la web, se referirán a los objetos de GUI como widgets. Yo no pretendo ir contra ese esquema, así que también les llamaré widgets… además que widgets es mucho más breve que objeto de GUI xD; cabe señalar que en la jerarquía de clases de Java, se les llama componentes y no wdgets.

Cada evento con su listener

Como podrán imaginar, un widget no está obligado a generar sólo un evento particular, sino que puede generar muchos. Por ejemplo, podría ser un evento poner el cursor sobre el objeto, sacarlo del objeto también es un evento, hacer click, hacer click derecho, presionar una tecla, arrastrar, etcétera. Según su naturaleza, cada widget generará los eventos que corresponden.

Cada evento, como es de suponer, tiene naturaleza distinta. Por ejemplo, presionar una tecla y hacer click no son lo mismo, puesto que hacer click es sólo hacer click en determido botón del mouse, mientras que presionar una tecla puede ser cualquiera, puedo haberla presionado junto con control, con alt, con shift, con control y alt…

Pensando en esto, en Java tenemos diferentes listeners para cada tipo de evento: para los click en un botón tenemos el ActionListener, para saber cuando se quiere maximizar/minimizar/cerrar una ventana tenemos el WindowListener y el WindowStateListener, para saber si recibe el foco tenemos WindowFocusListener, y así para cada widget.

Al principio puede parecer confuso, ya que habría que recordar cada evento, el listener asociado, implementarlo, agregarlo al widget. Claro que no es evidente a la primera, pero con un poco de práctica, ya no es tan sufrido hacer una GUI. Junto con esto, también tenemos la documentación de la API de Java, que te muestra la jerarquía de paquetes, clases, los métodos y parámetros de cada método, y a veces algunas explicaciones breves de cómo usar un determinado método.

Por ahora, los insto a investigar un poco acerca de los diversos widgets disponibles (paquetes java.awt y javax.swing, respectivamente), y de los listeners que tenemos disponibles para implementar (principalmente en el paquete java.awt.event). Los nombres de las clases  métodos sugieren mucho para qué sirve cada cosa, así que no será tan complejo.

En el próximo tutorial, veremos nuestro primer código de GUI: una ventana y los eventos que podemos usar con ella.

Gracias por leer!!

Pero, para quienes no hayan trabajado con listas antes, partamos desde las bases:

lista = ["cero", "uno", "dos", "tres", "cuatro", "cinco"]
print lista
print lista[0]
print lista[3:]
print lista[-2]
print lista[:4]

Quienes hayan trabajado con arreglos en lenguajes de tipo C, entenderán rápidamente la idea: una vez declarada la lista, puedo acceder a un elemento en particular indicando su índice (posición) entre corchetes (la primera posición es cero).

Python también permite obtener partes (slices) de una lista. Cuando se dice lista[3:], se está obteniendo una parte de sublista, que comienza desde el elemento 3 en adelante. De manera similar, al decir lista[:3] son los elementos de lista hasta el tercero. ¿Y los índices negativos? Muy simple: es contando desde el último hacia el primero. Eso significa en el ejemplo que lista[-2] referencia al penúltimo elemento.

Ahora, para los más avanzados en programación, las listas de Python son objetos, por lo que tienen algunos métodos interesantes para probar:

def mostrarLista(nombreLista, lista):
	for elemento in lista:
		print nombreLista + ":" + elemento
	print

autos = ["ferrari", "porsche", "audi", "bmw"]
frutas = ["pera", "manzana", "frutilla", "naranja", "ciruela"]

print "Autos con el Lamborghini"
autos.insert(2, "lamborghini")
mostrarLista("Autos", autos)

print "Autos con el lada"
autos.append("lada")
mostrarLista("Autos", autos)

print "Frutas sin frutilla"
frutas.remove("frutilla")
mostrarLista("Frutas", frutas)

jeeps = ["musso", "land rover"]
autos.extend(jeeps)
print "Autos y jeeps"
mostrarLista("Autos", autos)

autos.remove("musso")
autos.remove("land rover")

#autos no contiene a los jeeps ahora
#pero, por si no me crees...
print "Jeeps eliminados de los autos"
mostrarLista("Autos", autos)
mostrarLista("Autos y jeeps", autos + jeeps)
autos += jeeps
#si... se pueden concatenar
mostrarLista("Autos y jeeps", autos)

print "El lada esta en esta posicion:", autos.index("lada")

print "Para terminar, muuuuuuuuuuchas fruuuuuuuuuuuuutas"
mostrarLista("MUCHAS FRUTAS", frutas * 5)

Hay que tener cuidado con los métodos append() y extend(): ambos agregan elementos, pero lo hacen de manera diferente. Si paso como parámetro una lista a append(), esa lista será agregada como un único elemento, mientras que extend() agrega cada elemento de la lista pasada como parámetro al final de la otra.

Para terminar con las listas, una característica que me llamó la atención por su potencial: inyección de listas. Esto simplemente significa que puedo crear una nueva lista a partir de una existente, pero aplicando alguna función a los elementos de la lista existente. Por ejemplo:

class Clase:
	def metodo(self):
		return "Soy el resultado de un metodo"

def mostrarLista(nombreLista, lista):
	for elemento in lista:
		print nombreLista + ":" + elemento
	print

instancias = []
for i in range(10):
	instancias.append(Clase())

valores = [elem.metodo() for elem in instancias]
mostrarLista("Valores", valores)

Lo que se hace acá es crear una lista de clases, para luego generar una segunda lista a partir de los valores obtenidos de invocar un método de cada elemento de la lista de clases. La sentencia valores = [elem.metodo() for elem in instancias] conviene leerla al revés: sabemos que for elem in instancias es una forma de recorrer toda la lista instancias, llamando elem al elemento actual. Luego, la lista valores se crea al llamar al metodo de cada elem en instancias.

Con estos pequeños ejemplos de listas me despido, no sin antes mencionar que Python posee también otros tipos de datos interesantes como tuplas (listas inmutables) y diccionarios, que también pueden facilitar mucho la programación de cierto tipo de aplicaciones. Espero pronto poder desarrollar algún proyecto pequeño que muestre las ventajas de estos tipos de datos.

En primer lugar, JDBC es el Java Database Connectivity, una API de java que permite el acceso a bases de datos abstrayéndose de detalles como el motor en específico al que estás conectando, el sistema operativo sobre el que se ejecuta, etcétera. Esto se traduce en que dispones de un conjunto de interfaces y clases que permiten el acceso a datos, y que el esquema de conexión y consulta es practicamente igual para varios DBMS (espero, más adelante, publicar otro artículo donde te muestre eso en detalle). Eso si, para poder conectar a un DBMS específico necesitas el driver JDBC, así que eso es lo primero que debes buscar para este artículo: el driver JDBC para SQLite, que se puede descargar desde acá.

Para tener continuidad, partiré con la base de datos creada en el artículo Uso de SQLite. Ahora, simplemente nos conectaremos a esos datos para hacer consultas e inserciones.

Lo primero es lo primero: necesitamos importar el paquete java.sql en nuestro código, que es la API de JDBC. Luego, debemos realizar la conexión, y una vez establecida, crear un Statement que nos permitirá operar sobre la base de datos. Si, si… si el ejemplo viene ahora, simplemente estoy clarificando lo que debemos hacer. Al código:

import java.sql.*;

public class EjemploJDBC
{
public static void main(String args[])
   throws ClassNotFoundException, SQLException
   {
      Class.forName("org.sqlite.JDBC");
      Statement stmt;

      Connection con = DriverManager.getConnection("jdbc:sqlite:ejemplo.sqlite");
      Statement stmt = conexion.createStatement();
      ResultSet resultado = stmt.executeQuery("select * from buses");
      while(resultado.next())
      {
         int id = resultado.getInt(1);
         String matricula = resultado.getString(2);
         int ano = resultado.getInt(3);
         int capacidad = resultado.getInt(4);
         System.out.println("Datos de bus");
         System.out.println("ID       :" + id);
         System.out.println("Matricula:" + matricula);
         System.out.println("Ano      :" + ano);
         System.out.println("Capacidad:" + capacidad);
         System.out.println();
      }
      System.out.println("Datos de buses leidos");
   }
}

¿Y qué significa todo esto? Vamos por partes:

• Class.forName(“org.sqlite.JDBC”) carga el driver de sqlite.
• DriverManager.getConnection(“jdbc:sqlite:ejemplo.sqlite”) crea una conexión (Connection) hacia la base de datos. El string que se le pasa como parámetro es “jdbc:sqlite:”
• conexion.createStatement() crea el Statement, que nos permite ejecutar código SQL.
• El método executeQuery() nos permite ejecutar una consulta. Entrega un ResultSet (un conjunto de resultados).
• El ResultSet se puede trabajar casi como un iterador: mientras pueda ir al siguiente elemento, los leo; el ResultSet tiene tuplas (filas) de resultado.
• Los métodos getYYY() de ResultSet me permiten leer un dato de la tupla actualmente activa en el ResultSet. Hay métodos para obtener enteros, enteros largos, booleanos, Strings, Fechas, etcétera. El parámetro pasado (un número, en este caso) indica la columna dentro de esa fila de donde se están sacando los datos (partiendo desde 1). Para más detalles de eso, habría que mirar el esquema de la base de datos. Es importante mencionar que los métos getYYY() están sobercargados, pudiendo pasarles también un String: el nombre de la columna.

Como ves, el código es relativamente sencillo. Muchos de estos métodos lanzan excepciones, así que debes estar atento a la API de Java para capturarlas adecuadamente.

Para poder ejecutar este código, debes incluir el driver JDBC de SQLite en el classpath. Esto se traduce en español a:

java -cp .;sqlitejdbc-v052.jar EjemploJDBC

(Si estás probando desde Linux, cambia el ; por : )

Con esa invocación, estás diciendo a la JVM mira, las clases que vas a ocupar están en el directorio actual (por eso el .) y en este archivo .jar (el driver SQLite).

Una observación importante es que puedes también indicar el driver JDBC a utilizar desde la línea de comandos, en lugar de hacerlo desde el código Java. Eso significa que puedes eliminar (o comentar) la linea que llama a Class.forName(), pero ejecutar el programa de esta forma:

java -cp.;sqlitejdbc-v052.jar -Djdbc.drivers=org.sqlite.JDBC EjemploJDBC

(Nuevamente, reemplaza ; por : si están en linux)

¿Y si quisiera portar los datos de SQLite a MySQL o PostgreSQL? Pues simple: necesito el driver para el DBMS que voy a utilizar, cambiar los parámetros pasados a Class.forName() y DriverManager.getConnection()… y el resto queda igual (si es que al portar, ocupo datos compatibles en el DBMS). Como puedes ver, el esquema JDBC facilita enormemente cambiar de un DBMS a otro.

Junto con esto, si tienes un buen diseño, minimizas aún más el impacto de cambiar el DBMS. Usualmente se utiliza el patrón DAO, que puedes buscar más detalladamente en Wikipedia. Ahora, si quieres una excelente explicación, Huilén a puesto acá un muy buen tutorial de patrón DAO con Java, el que después continúa en un segundo artículo donde utiliza otro patrón de diseño (singleton) para mejorar el diseño.

SQLite es un pequeño ‘sistema’ de base de datos: es una biblioteca que sobre un archivo almacena el esquema de la base de datos y los datos propiamente tal. En términos generales presenta un buen rendimiento, y está aconsejada para quienes requieren almacenar un volumen medio de datos en sus aplicaciones, utilizando un esquema relacional.

En el caso de querer incluir la API SQLite en tu proyecto de programación, puedes incluir en tu programa C/C++ a sqlite.h, compilar a sqlite.c y listo.

Dentro de lo que podemos llamar una desventaja de SQLite es que no implementa la integridad referencial, es decir, no disponemos de claves foráneas (puedes declararlas, pero el intérprete ignorará tu declaración). De todas formas, SQLite si implementa triggers, así que hay algunas formas de implementar la integridad referencial de esa forma.

¿Un ejemplo? Pero con mucho gusto… de todas maneras, el ejemplo está pensado solo para mostrar las características de SQLite, así que no esperes un buen diseño ni nada por el estilo…

Por ejemplo, imagínese una pequeña empresa de buses que requiere almacenar información acerca de sus viajes. Para ello, supongamos que tenemos la tabla buses (con información de los buses), viaje (con los datos de un viaje) y pasajero (con los datos de un pasajero). Una propuesta entonces podría ser la siguiente:

create table buses(
  id integer primary key not null autoincrement,
  matricula text not null,
  ano integer not null,
  capacidad integer not null);

create table pasajero(
  cedula text primary key not null,
  nacimiento date not null);

create table viaje(
  id_bus integer not null,
  cedula text not null);

Bueno, hay algunas cosas por explicar de acá:

• SQLite implementa el incremento automático de un campo (autoincrement), el que perfectamente pude indicarse para el primary key.
• Las claves foráneas, como ya mencioné, no están implementadas aún en SQLite, así que no las agrego.
• La primary key de la tabla viaje será su OID.

SQLite, para almacenar una tupla en una tabla, utiliza el sistema de OID, es decir, asigna secretamente un identificador para cada tupla, que facilita su búsqueda en el arbol B (la estructura de datos usada por SQLite para almacenar los datos en archivo). No necesito declarar el OID, pero puedo consultarlo en cualquier tabla; pronto un ejemplo de eso.

Ahora, insertemos algunos datos, para hacer las pruebas.

insert into buses values(null, 'ABCD-01', 2008, 40);
insert into buses values(null, 'JANO-05', 2007, 27);
insert into buses values(null, 'INSQ-35', 2007, 20);
insert into pasajero values('123ASD-K', 1980-05-23);
insert into pasajero values('237QSD-3', 1970-03-28);
insert into pasajero values('135QTW-3', 1989-08-05);

Con esos datos, podemos ver en acción el sistema de los OID:

sqlite>select oid,* from buses;
1|1|ABCD-01|2008|40
2|2|JANO-05|2007|27
3|3|INSQ-35|2007|20

sqlite>select oid,* from pasajero;
1|123ASD-K|1980-05-23
2|135QTW-3|1989-08-05
3|237QSD-3|1970-03-28

Puede parecer extraño lo que ocurre con la tabla buses, puesto que ya existe su primary key, y esta se autoincrementa. Bien, pues de todas formas se genera un OID… pero cuando se define una primary key autoincrementable de tipo integer, el OID tendrá el mismo valor que dicha clave. No ocurre lo mismo en la tabla pasajero, puesto que su primary key es un texto, y no un entero. Nota también que en los campos que se autoincrementan, el siguiente valor se genera insertando un null.

Gracias a esta característica es que he definido la tabla viajes sin primary key: confío en el OID (lo que no es recomendado, por cierto).

Ahora, la parte artística: ¿y las claves foraneas? Como mencioné, para eso disponemos de los triggers…

create trigger fki_viaje_buses
before insert on viaje
for each row
begin
  select raise
     (rollback,
     'Inserción en viaje viola restricción fki_viaje_buses')
  where
     (select id from buses where id=new.id_bus) is null;
end;

Luego de eso, intentemos insertar un viaje para un bus no válido:

sqlite> insert into viaje values(5, '123ASD-K');
SQL error: Inserción en viaje viola restricción fki_viaje_buses

El trigger para la actualización (update) es exactamente igual, pero en el caso de la eliminación tenemos un problema: si quiero eliminar un bus ¿qué hago con los viajes? Por como se definió la base de datos, no se pueden eliminar buses o pasajeros mientras hayan viajes, así que manos al trigger:

create trigger fkd_viaje buses
before delete on buses
for each row
  begin
    select raise(rollback, 'No se puede eliminar bus')
    where
       (select id_bus from viaje where old.id = id_bus)
    is not null;
end;

Ahora, si yo he insertado los siguientes datos de viaje

insert into viaje values(1, '135QTW-3');
insert into viaje values(1, '123ASD-K');

el trigger impedirá que eliminemos un bus, lo que generaría un estado inconsistente en la base de datos

sqlite> delete from buses where id = 1;
SQL Error: No se puede eliminar bus

Como se puede apreciar, SQLite es una alternativa interesante cuando se necesita un acceso a datos rápido y sencillo. Aunque me parece que SQLite es muy bueno, no me atrevería aún a usarlo en un entorno más de producción… aunque en la medida que lo voy usando, más me convence.

También cabe destacar que hay soporte de SQLite para PHP, .Net, Java (JDBC) y otros.

Información más detallada y descargas de SQLite, en su página oficial: www.sqlite.org

public class Clase{
 int atr1;
 int atr2;

 public Clase(){
 atr1 = 10;
 atr2 = 20;
}

Acá se puede postear código fuente actionscript3, bash, coldfusion, cpp, csharp, css, delphi, erlang, fsharp, diff, groovy, javascript, java, javafx, mathlab, objc, perl, php, powershell, python, ruby, scala, sql, vb y xml… nice!

int main(void){
   int var;
   printf("Hola, mundo!");
   scanf("%d", &var);
}

¿Se entiende por qué cambié?