Este es el proyecto de la clase finalizado.
En la esquina superior derecha de la pantalla principal hay un boton llamado cargar que sirve para cargar la informacion de usuarios
Descargar
lunes, 11 de abril de 2011
domingo, 3 de abril de 2011
BOTONES Y CONTROLES PERSONALIZADOS
En este proyecto java se encuentra un paquete con 5 botones personalizados y otro con 2 controles personalizados(JTextField y JTextArea)
Descargar
Descargar
martes, 29 de marzo de 2011
JTREE
El JTree nos permite mostrar información jerárquica, es excelente para mostrar datos como un árbol familiar o la estructura del sistema de archivos. Utilizar un JTree es algo sencillo, pero no siempre es muy claro cómo llenarlo para no gastar mucha memoria y para que no se gaste mucho tiempo al llenarlo. En este Trial vamos a hacer una aplicación guíada en la que utilizaremos un JTree para mostrar el sistema de archivos de la partición raíz de la computadora.
El archivo contiene una versión termianda del programa que vamos a crear en este Trial.r una aplicación guíada en la que utilizaremos un JTree para mostrar el sistema de archivos de la partición raíz de la computadora.
El archivo contiene una versión termianda del programa que vamos a crear en este Trial.
¿Cómo utilizar un JTree? | ||||||||||||||||||||||||||||||||||||||||||
| La aplicación que queremos crear es una aplicación similar al Explorador de Windows. En la aplicación vamos a tener un JTree con los directorios que se encuentran en la estructura de archivos, y en la otra parte vamos a tener los archivos que se encuentren dentro del directorio seleccionado. Además de utilizar el JTree vamos a utilizar extensivamente la clase File que nos permite muchas facilidades en el manejo de archivos. Primero que nada crea una nueva aplicación de Java en que la clase principal se llame Main. En la clase Main copia el siguiente código: 
| ||||||||||||||||||||||||||||||||||||||||||
JTABLE
Las tablas nos permiten tener tabulados de información que se vean organizados y que sean de utilidad para los clientes. Las tablas son muy utilizadas en programas similares a excel, donde se deben tener rejillas de información; o en programas de administración donde pueden haber varios productos que tienen un conjunto de características, o en programas de ventas, donde pueden haber varios vendedores con número de ventas y con total vendido.
Para agregar una tabla en NetBeans selecciona el icono de tabla de la paleta (que regularmente se encuentra a la derecha)
. Una vez que lo hayas seleccionado agrégalo a la ventana principal. El JTable utiliza un DataModel para representar sus datos, de la misma manera que varios otros componentes como JList.
Para agregar una tabla en NetBeans selecciona el icono de tabla de la paleta (que regularmente se encuentra a la derecha)
. Una vez que lo hayas seleccionado agrégalo a la ventana principal. El JTable utiliza un DataModel para representar sus datos, de la misma manera que varios otros componentes como JList.Creando un modelo estático
El modelo nos permite indicarle a la tabla qué información va a contener. Si sólo queremos presentar información estática (que nunca cambia) al cliente entonces podemos usar un modelo estático, para hacer esto vamos a hacer click en el atributo model que se encuentra en las propiedades.
Una vez que hicimos click aparecerá una pantalla en la que podemos editar cómo queremos que se vea la tabla. En esta pantalla podemos seleccionar el núemro de columnas, el nombre de las columnas e incluso podemos agregar algunos datos.
En la pantalla anterior podemos ver cómo manejar el número de columnas (con los botones de Insert, Delete o con los botones de +, -) y también podemos ver una rejilla donde podemos poner el título que aparece en la columna, el tipo de dato que va a guardar y si se puede editar o no.
Con esto podemos crear una tabla estática que siempre va a iniciar con los mismos datos.
Una vez que hicimos click aparecerá una pantalla en la que podemos editar cómo queremos que se vea la tabla. En esta pantalla podemos seleccionar el núemro de columnas, el nombre de las columnas e incluso podemos agregar algunos datos.
En la pantalla anterior podemos ver cómo manejar el número de columnas (con los botones de Insert, Delete o con los botones de +, -) y también podemos ver una rejilla donde podemos poner el título que aparece en la columna, el tipo de dato que va a guardar y si se puede editar o no.
Con esto podemos crear una tabla estática que siempre va a iniciar con los mismos datos.
Creando un modelo dinámico
La mayoría de las veces un usuario no va a querer una tabla estática (en la que aunque pueda editar los valores no se muestren los valores que se habían guardado previamente). Es por esto que es necesario crear un modelo dinámico. Para poder crear un modelo dinámico es necesario implementar la interfaz
TableModel que nos obliga a sobrecargar un gran número de métodos:getColumnClass(): Es un método que nos permite saber qué clase tiene guardada cada columna, esto es para que sean más fáciles de pintar para java.getColumnCount(): Es un método que nos permite saber cuántas columnas tiene la tabla.getColumnName(): Es un método que nos permite saber el encabezado de la tabla para una cierta columna.getRowCount(): Es un método que nos permite saber cuántas filas tiene la tabla.getValueAt(): Es un método que nos devuelve el valor que se encuentra en la posición pasada como parámetro.isCellEditable(): Es un método que nos devuelve verdadero si la celda puede ser modificada, o falso en caso contrario.setValueAt(): Es un método que nos permite cambiar el valor que se encuentra en la posición pasada como parámetro mediante código (el usuario puede cambiar los datos dependiendo del métodoisCellEditable()).getValueAt(): Es un método que nos devuelve el valor que está guardado en la celda pasada como parámetro, este valor va a ser de la clase que indicagetColumnClass()para esa columna.
TableModel tiene un par de métodos para manejar eventos (como por ejemplo, que el usuario haga click, que edite una celda). Estos métodos involucran agregar código a nuestra clase que cuando modifique algún valor o que agregue nuevos datos tenga que disparar eventos. Este código, aunque no es muy complicado, no tendría ninguna utilidad (a menos que vayamos a escribir una manera de deshacer acciones o algo similar), sin embargo como tenemos que implementar TableModel tendríamos que implementarlos. Por suerte Java cuenta con un modelo ya implementado (el que utilizan todas las tablas al ser creadas) que podemos utilizar para no implementar estos métodos, entonces, en lugar de implmentar la interfaz TableModel vamos a extender la clase DefaultTableModel que ya implementa la interfaz anterior.Implementando el modelo dinámico
Normalmente las tablas sólo crecen en una dirección (hacia abajo, aumentando el número de filas). Por ejemplo, en el reporte de empleados, es probable que contratemos o despidamos empleados, por lo que vamos a tener que agregar más filas, sin embargo sería raro que apareciera un nuevo atributo que quisiéramos manejar del empleado (y más raro aún que el cliente pudiera modificar el programa de tal manera que lo agregue). Entonces, como la mayoría de las tablas crecen en una sola dimensión(sólo aumenta el número de filas) vamos a implementar un modelo en el que utilizando un ArrayList que contiene arreglos vamos a manejar el crecimiento de la tabla (el ArrayList puede crecer, pero los arreglos no).
El
Primero veamos a crear una clase nueva, que extienda
Otro método que quizás sería importante implementar sería uno que nos permitiera agregar filas con datos, ya que muchas veces vamos a leer los datos de un archivo y vamos a querer construir la tabla.
El
ArrayList va a representar las filas de la tabla, y va a contener arreglos, que representan las columnas.
Primero veamos a crear una clase nueva, que extienda
DefaultTableModel.public class EditableTableModel
extends DefaultTableModelNuestro modelo debe tener alguna manera de almacenar los datos (ya vimos cómo vamos a resolver este problema) y además debe contar con variables de control que nos faciliten la tarea de saber cuál es el nombre de las columnas, qué tipo de dato guarda cada columna (importante para poder guardar números o booleanos) y si la columna es editable (la mayoría de las veces este parámetro va a ser verdadero, pero podrían haber ocasiones en que necesitáramos que fuera falso). private ArrayList<Object[]> data;
private int numColumns;
private String columnNames[];
private Class classes[];
private boolean editable[];El constructor que recibe todos los parámetros debe de crear un tabla de datos en blanco y debe de leer los parámetros que manda el usuario. Como vamos a tener varios constructores que reciban diferente número de parámetros debemos construir un método que nos permita iniciar el objeto y llamarlo desde todos los constructores, el método sería algo similar a: private void initComponents(String columnNames[], Class classes[], boolean editable[])
throws IllegalArgumentException {
if (columnNames.length != classes.length || classes.length != editable.length)
throw new IllegalArgumentException("The arrays passed as parameters must be of the same size");
data = new ArrayList<Object[]>();
this.numColumns = columnNames.length;
this.columnNames = columnNames;
this.classes = classes;
this.editable = editable;
}La mayoría de los métodos son simples getters y setters (por ejemplo getRowCount() sólo debe regresar el tamaño de data con data.size(), getValueAt() sólo debe obtener el valor de la celda con data.get(row)[col]), por lo que estos métodos no van a ser consultados con más detenimiento. Sin embargo, para permitir que la tabla pueda crecer debemos crear métodos que nos permitan agregar o quitar filas. Estos métodos deben agregar o quitar arreglos de objetos de la lista de datos. Es decir: public void addRow() {
int numRows = data.size();
Object[] row = new Object[numColumns];
data.add(row);
this.fireTableRowsInserted(numRows, numRows+1);
}Y para remover va a ser muy similar: @Override
public void removeRow(int row) {
data.remove(row);
this.fireTableRowsDeleted(row, row);
}En los métodos anteriores no está sucediendo mucho que no sepamos, excepto por los métodos fireTableRowsInserted() y fireTableRowsDeleted(). Estos dos métodos le indican a la tabla (y la tabla se encarga de comunicarle a todos los componentes que dependan de ella) que se agregaron o quitaron filas. Si no hiciéramos esta llamada entonces no veríamos los cambios hasta que modifiquemos los datos en la lista, que sería cuando la tabla se daría cuenta de que el modelo cambió.Otro método que quizás sería importante implementar sería uno que nos permitiera agregar filas con datos, ya que muchas veces vamos a leer los datos de un archivo y vamos a querer construir la tabla.
public void addRow(Object[] row) {
int numRows = data.size();
data.add(row);
this.fireTableRowsInserted(numRows, numRows+1);
}Quizás también sería prudente crear un constructor que reciba una matriz de datos y de ahí obtenga todos los datos para crear la tabla.Usando el modelo
Construir el modelo es un proceso un poco abstracto y muchas veces no sabemos cómo están sucediendo las cosas sino hasta que lo comenzamos a usar, para poder usar nuestro modelo vamos a crear una clase de prueba que tenga una ventana con una tabla y dos botones de la siguiente manera:
Vamos a declarar el modelo en la parte de declaraciones globales, para que toda la interfaz gráfica pueda acceder a ella (esto es conveniente porque así los botones van a poder usarlo directamente, sin tener que sacarlo de la tabla pero podría considerarse una mala práctica de programación).
Ahora vamos a implementar el botón para agregar filas:
Vamos a declarar el modelo en la parte de declaraciones globales, para que toda la interfaz gráfica pueda acceder a ella (esto es conveniente porque así los botones van a poder usarlo directamente, sin tener que sacarlo de la tabla pero podría considerarse una mala práctica de programación).
private EditableTableModel model;En el constructor de la ventana vamos a agregar el siguiente código: public EditableModelTest() {
initComponents();
String columnNames[] = { "Nombre", "Edad", "Telefono" };
Class classes[] = { String.class, Integer.class, String.class };
boolean editable[] = { true, true, true };
model = new EditableTableModel(columnNames, classes, editable);
tblEmployees.setModel(model);
}Como podemos ver, el código está creando tres arreglos, el primero tiene los nombres de las columnas (son tres columnas: nombre, edad y teléfono), el segundo arreglo es un arreglo de clases, que nos dice de qué tipo va a ser cada columna. Podemos utilizar cualquier clase de Java, pero regularmente queremos utilizar String, Integer, Double, Float o Boolean, que son las clases para las que ya está creado un renderer y por lo tanto no tenemos que preocuparnos por eso. Fíjate que después del nombre de la clase ponemos .class para que obtenga la clase. El último arreglo es un arreglo de boolean y nos dice si las columnas van a ser editables (en la mayoría de los casos sí).Ahora vamos a implementar el botón para agregar filas:
private void btnAddRowActionPerformed(java.awt.event.ActionEvent evt) {
model.addRow();
}Como nuestro modelo está bien implementado esto fue sencillísimo, ahora vamos a implementar el botón que borra las filas seleccionadas: private void btnRemoveRowActionPerformed(java.awt.event.ActionEvent evt) {
int rows[] = tblEmployees.getSelectedRows();
model.removeRows(rows);
}Igual de sencillo. Una vez que hayamos hecho todo esto nuestro programa debe permitir agregar y quitar filas y poner los datos que querramos adentro de las filas.Guardar datos
Una vez que los usuarios tengan la oportunidad de modificar la tabla van a agregar datos y van a querer guardar esos datos (imaginen que cada que abran excel tienen que volver a poner todos los datos que habían puesto la vez anterior). Para guardar los datos vamos a crear un método en el modelo que se encargue de poner los datos en una matriz (para que sea más fácil de manejar) y después, utilizando este método vamos a utilizar un par de ciclos para guardar los datos en un archivo.
En el modelo vamos a agregar el siguiente método:
En el modelo vamos a agregar el siguiente método:
public Object[][] getDataMatrix() {
int numRows = getRowCount();
int numCols = getColumnCount();
Object matrix[][] = new Object[numRows][numCols];
for (int rowIndex = 0; rowIndex < data.size(); rowIndex++) {
Object[] row = data.get(rowIndex);
for (int colIndex = 0; colIndex < row.length; colIndex++) {
Object object = row[colIndex];
matrix[rowIndex][colIndex] = object;
}
}
return matrix;
}Y dentro de la interfaz gráfica hay que crear un nuevo botón que sea el que guarda y debemos poner el siguiente código: private void btnSaveActionPerformed(java.awt.event.ActionEvent evt) {
try {
PrintWriter fileOut = new PrintWriter(new FileWriter("out.csv"));
Object[][] data = model.getDataMatrix();
for (int i = 0; i < data.length; i++) {
fileOut.print(data[i][0]);
for (int j = 1; j < data[i].length; j++) {
Object object = data[i][j];
if (object != null)
fileOut.print("," + object.toString());
else
fileOut.print(",");
}
fileOut.println();
}
fileOut.close();
JOptionPane.showMessageDialog(this, "Datos guardados");
} catch (IOException ex) {
JOptionPane.showMessageDialog(this, "Error al guardar!");
}
}jueves, 17 de marzo de 2011
jueves, 17 de febrero de 2011
lunes, 7 de febrero de 2011
Suscribirse a:
Entradas (Atom)