"AÑO DEL BUEN SERVIDOR AL CIUDADANO"
ESCUELA ACADÉMICA DE INGENIERÍA DE SISTEMAS Y TELEPÁTICA
ASIGNATURA
LABORATORIO DE PROGRAMACIÓN II
TEMA
Control JTable con Base de Datos
AUTORES
LUZ CLARITA PEREZ DIAZ
LUZ ISELA FLORES CHIGUEL
LUZ CLARITA CHILCON SANCHEZ
DOCENTE
ING.MARCO AURELIO PORRO CHULLI
BAGUA GRANDE-UTCUBAMBA
AMAZONAS
2017
1.
Contenido
definicion
JTABLE
Un JTable es un componente visual de Java que nos permite dibujar una
tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que
queramos; un nombre, un apellido, una edad, un número, etc.
Jtable es una clase que me permite organizar una
determinada información en tabla, esta difiere de una base de datos normal
porque al utilizar Jtable tu puedes visualizar esta tabla, brindándole a el
usuario organización de información, oportunidades de editar y cambiar el
tamaño de las columna entre otras.
INICIOS DE JTABLE
En
principio se creo la clase Jtable para constituir un interfaz ligado a bases de
datos a través de "Java Database Connectivity" (JDBC), y así evita la
complejidad que existía par el manejo de datos, dando así al programador mucha
mas facilidad a la hora de trabajar con este tipo de información.
Jtable
le da al programador muchas facilidades, pues este posee varias características
que permiten hacer desde tablas con información compleja y muy estructurada
hasta tablas con información sencilla y "básica".
TABLE MODEL
La
clase Jtable controla como se presentan los datos, siendo el TableModel quien
controla los datos sí mismos. para crear una Jtable habrá pues que crear un
TableModel antes, normalmente. TableModel lo que hace es predeterminar ciertas
características para el Jtable es decir que tu puedes poner ciertos parámetros
dentro de un TableModel y así no tener que determinarlos siempre. TableModel es
un programa que guarda los datos de la tabla para si mismo, es decir, puede
tener la información de la tabla pero estos datos son los visualizados por el
computador, es decir, para visualizar una tabla el TABLEMODEL puede tener la
información pero sin el Jtable no se puede visualizar para el usuario.
EDITABLE O NO?
Jtable
tiene una característica muy llamativa, este permite que el programador pueda
decirdir que se edita y que no, sin embargo si el programador dentro de su
programa o de su TABLEMODEL no tiene determinado este aspecto, Jtable
automáticamente hace editable las celdas dentro de la tabla. Existen varias
maneras de hacer editable o no las celdas dentro de la tabla, para ver estos
comandos tu te puedes dirigir a Dentro de las celdas encontradas en una tabla
se puede permitir al usuario editar o no editar según lo desee el programador,
esta propiedad se puede arreglar desde el table model o directamente y/o desde
el programa. Jtable tiene la propiedad de dejar editable las celdas si no
encuentra nada que hable de esto.
LA INFORMACIÓN, Y LAS COLUMNAS?
Jtable
te brinda muchas facilidades para poder crear una table, y así mismo de
llenarla con la información que desees ( números, letras etc...) por lo que
sencillamente dentro de una tabla esta automáticamente a través de la
información debidamente separada - por ""(comillas) o por , (coma) -
es capaz de contabilizarlas y al mismo tiempo llenarla con la información que
se le dio; es decir el programador solo se debe encargar de poner los títulos de
las tablas y así mismo de escribir la información en el mismo orden en que
desee que salga de acuerdo con los títulos y Jtable se encargara
automáticamente de colocar la información donde se le indico.
UN CHECK BOX?
Para
un CellRendered con un TableModel sencillo, tal vez identificar clases pueda
ser algo mas complejo que no pueda hacer, pero para uno un poco mas avanzado,
esto seria muy fácil, y para esto cito el caso de un CHECK BOX(casilal de
verificación) el cual es un componente grafico generado por Jtable después de
que identifica una información tipo boolean, dándole así la apariencia de un
cuadro rellenable, un check box no es mas que eso, una opción - que puede ser
editable o no - que simplemente se chulea para indicar un si o un no ( si esta
chuleado significa verdadero, sino lo esta indica falso), la cual el usuario
solo puede colocar mediante un TableModel que sepa identificar clases.
UN LIST BOX?
En algunas oportunidades, para cierto tipo de
información que deseamos que el usuario complete, necesitamos darle a el
usuario, cierto tipo de opciones cosa que a través de un List Box tu puedes
ofrecer al usuario el tipo de respuestas que tu desees que el selecciones, este
tipo de organización de información ya no es tan sencillo como declarar una información
tipo boolean, toca crear la lista.
La forma más sencilla de usar un JTable y tener
toda su funcionalidad es instanciar un DefaultTableModel y meterlo en el
JTable, en el constructor
DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable(modelo);
Podemos añadir columnas directamente en el modelo
modelo.addColumn("etiqueta columna 1");
modelo.addColumn("etiqueta columna 2");
Podemos añadir datos directamente en el modelo, así como borrarlos o
modificarlos
Object [] fila = new Object[2];
fila[0] = "dato columna 1";
fila[1] = "dato columna 3";
modelo.addRow ( fila ); // Añade una fila al final
modelo.setValueAt ("nuevo valor", 0, 1); // Cambia el valor de la
fila 1, columna 2.
modelo.removeRow (0); // Borra la primera fila
Todo lo que hagamos se reflejará de inmediato en el JTable.
Obtener fila y columna
del JTable en la que se hace click
A veces nos interesa seleccionar una fila del JTable para hacer algo con ella
(sacar un menú, recoger datos para mostrarlos en otro sitio, etc).
Una forma de hacerlo es añadiendo un MouseListener al JTable, de esta manera
tabla.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
int fila = tabla.rowAtPoint(e.getPoint());
int columna = tabla.columnAtPoint(e.getPoint());
if ((fila > -1) && (columna > -1))
System.out.println(modelo.getValueAt(fila,columna));
}
});
Hemos añadido un MouseAdapter para no tener que implementar todos los métodos
del MouseListener.
Con el método tabla.rowAtPoint() es posible enterarnos en qué fila de del
JTable ha ocurrido el evento del ratón (el click en este caso). Para ello basta
llamar a este método pasándole las coordenadas x,y del evento de ratón, que se
obtienen con el método e.getPoint().
Una vez que sabemos la fila, debemos comprobar si es mayor que -1. El método
rowAtPoint() nos devuelve -1 si pinchamos en el JTable, pero fuera de cualquier
fila. Es el caso de que el JTable tenga un tamaño en pixels superior al que le
corresponde según su número de filas.
Lo mismo vale para columnAtPoint().
Una vez que tenemos la fila y sabemos que no es -1, es fácil a través del
modelo obtener los datos correspondientes. En este caso se escribe por pantalla
con un System.out.prinln() el valor de la fila y columna que se ha
seleccionado.
Hacer que una celda del
JTable no sea editable
Si usamos DefaultTableModel las celdas del JTable son editables por defecto. A
veces esto no nos interesa y JTable no tiene métodos para impedirlo. La forma
de decidir qué celdas son o no editables es hacer nuestro propio modelo de
datos, nuestro TableModel. La forma sencilla de hacerlo es heredar de
DefaultTableModel y redefinir el método isCellEditable() para que sirva a
nuestros propositos
public class MiModelo extends DefaultTableModel
{
public boolean isCellEditable (int row, int column)
{
// Aquí devolvemos true o false según queramos que una celda
// identificada por fila,columna (row,column), sea o no editable
if (column == 3)
return true;
return false;
}
}
En este ejemplo, hemos creado nuestro propio modelo de datos que hace que la
columna 4 (los índices empiezan en cero) de la tabla sea editable y el resto
no. Ahora simplemente instanciamos el JTable usando este modelo y rellenamos
los datos igual que antes
MiModelo modelo = new MiModelo();
JTable tabla = new JTable(modelo);
Cambiar el tipo de dato
con DefaultTableModel
DefaultTableModel por defecto le dice al JTable que todos los datos que tiene
son Object. A veces, porque queramos cambiar el TableCellRenderer o cualquier
otro motivo, nos interesa que determinadas columnas se consideren como Boolean,
como Integer o cualquier otro tipo de dato.
Para modificar esto, tenemos que crearnos nuestro propio modelo de Datos. La
forma más sencilla es heredar de DefaultTableModel y redefinir el método
getColumnClass().
public class MiModelo extends DefaultTableModel
{
/** Primera columna Boolean, segunda Integer y el resto Object */
public Class getColumnClass(int columna)
{
if (columna == 0) return Boolean.class;
if (columna == 1) return Integer.class;
return Object.class;
}
}
En el ejemplo se ha hecho que la primera columna sea de Boolean, la segunda de
Integer y el resto de Object.
Una cosa curiosa de los Boolean, es que el JTable al pintarlos los pone como
JCheckBox.
Hacer visible una fila
concreta del JTable dentro de un JScrollPane
Para que un JTable tenga barras de scroll y tenga una "cabecera" con
las etiquetas de las columnas, es necesario meterla en un JScrollPane. Esto se
puede hacer de dos formas.
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane(tabla);
o bien
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
scroll.setViewportView(tabla);
es bastante habitual al principio equivocarse y usar el método add(), que NO
funcionará correctamente
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
// Esto NO funciona.
scroll.add(tabla);
Cuando tenemos un JTable metido dentro de un JScrollPane, a veces queremos que
las barras de scroll se desplacen para que una determinada celda sea visible.
No conozco una forma inmediata de hacerlo, pero una posible solución es esta.
...
// Nos devuelve la posición en pixels de una celda en fila,columna
Rectangle r = tabla.getCellRect( fila, columna, true);
// Mueve el scroll para que el rectangulo sea visible
scrollPane.getViewport().scrollRectToVisible (r);
La JTable controla cómo se presentan los datos,
siendo el TableModel quien controla los datos en sí mismos. Para crear una
JTable habrá pues que crear un TableModel antes, normalmente. Se puede
implementar, para ello, el interfaz TableModel, pero es mucho más simple
heredar de la clase ayuda AbstractTableModel. El ejemplo java1416.java muestra
esta circunstancia.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.table.*;
import com.sun.java.swing.event.*;
// El Modelo de la Tabla es el que controla todos
los
// datos que se colocan en ella
class ModeloDatos extends AbstractTableModel {
Object datos[][] = {
{"uno","dos","tres","cuatro"},
{"cinco","seis","siete","ocho"},
{"nueve","diez","once","doce"},
};
// Esta clase imprime los datos en la consola
cada vez
// que se produce un cambio en cualquiera de las
// casillas de la tabla
class TablaListener implements TableModelListener
{
public void tableChanged( TableModelEvent evt ) {
for( int i=0; i < j="0;" tabla
=" new" panel =" new" frame =" new">
Una vez que se tiene un TableModel, ya sólo resta
colocarlo en el constructor de JTable. Todos los detalles de presentación,
edición y actualización están ocultos al programador. En este ejemplo, se
coloca la JTable en un JScrollPane, por lo que es necesario un método especial
en JTable.
Las tablas pueden soportar un comportamiento más complejo. En el ejemplo java1417.java, se utiliza un método para cargar un array de ocho columnas por un ciento de filas y, posteriormente, la tabla es configurada para que muestre solamente las líneas verticales y permita la selección simultánea de la fila y columna en que se encuentre la celda marcada.
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.sun.java.swing.*;
import com.sun.java.swing.table.*;
class java1417 extends JPanel {
private JTable tabla;
private JScrollPane panelScroll;
private String titColumna[];
private String datoColumna[][];
public java1417() {
setLayout( new BorderLayout() );
// Creamos las columnas y las cargamos con los datos que van a
// aparecer en la pantalla
CreaColumnas();
CargaDatos();
// Creamos una instancia del componente Swing
tabla = new JTable( datoColumna,titColumna );
// Aquí se configuran algunos de los parámetros que permite
// variar la JTable
tabla.setShowHorizontalLines( false );
tabla.setRowSelectionAllowed( true );
tabla.setColumnSelectionAllowed( true );
// Cambiamos el color de la zona seleccionada (rojo/blanco)
tabla.setSelectionForeground( Color.white );
tabla.setSelectionBackground( Color.red );
// Incorporamos la tabla a un panel que incorpora ya una barra
// de desplazamiento, para que la visibilidad de la tabla sea
// automática
panelScroll = new JScrollPane( tabla );
add( panelScroll, BorderLayout.CENTER );
}
// Creamos las etiquetas que sirven de título a cada una de
// las columnas de la tabla
public void CreaColumnas() {
titColumna = new String[8];
for( int i=0; i < datocolumna =" new" iy="0;" ix="0;" ventana =" new">
Las tablas pueden soportar un comportamiento más complejo. En el ejemplo java1417.java, se utiliza un método para cargar un array de ocho columnas por un ciento de filas y, posteriormente, la tabla es configurada para que muestre solamente las líneas verticales y permita la selección simultánea de la fila y columna en que se encuentre la celda marcada.
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.sun.java.swing.*;
import com.sun.java.swing.table.*;
class java1417 extends JPanel {
private JTable tabla;
private JScrollPane panelScroll;
private String titColumna[];
private String datoColumna[][];
public java1417() {
setLayout( new BorderLayout() );
// Creamos las columnas y las cargamos con los datos que van a
// aparecer en la pantalla
CreaColumnas();
CargaDatos();
// Creamos una instancia del componente Swing
tabla = new JTable( datoColumna,titColumna );
// Aquí se configuran algunos de los parámetros que permite
// variar la JTable
tabla.setShowHorizontalLines( false );
tabla.setRowSelectionAllowed( true );
tabla.setColumnSelectionAllowed( true );
// Cambiamos el color de la zona seleccionada (rojo/blanco)
tabla.setSelectionForeground( Color.white );
tabla.setSelectionBackground( Color.red );
// Incorporamos la tabla a un panel que incorpora ya una barra
// de desplazamiento, para que la visibilidad de la tabla sea
// automática
panelScroll = new JScrollPane( tabla );
add( panelScroll, BorderLayout.CENTER );
}
// Creamos las etiquetas que sirven de título a cada una de
// las columnas de la tabla
public void CreaColumnas() {
titColumna = new String[8];
for( int i=0; i < datocolumna =" new" iy="0;" ix="0;" ventana =" new">
Aunque el ejemplo contiene un array relativamente
grande de datos, la clase JTable no manipula demasiado bien grandes cantidades
de información, resultando un rendimiento bastante pobre cuando se sobrepasan
los 2000 elementos.
Propiedades
Propiedad más usada:
●
Model: Permite definir el número de columnas y filas del objeto como también
las expresiones que irán en las columnas.
Métodos más usados:
●
addColumn(): Añade la columna al final de la matriz de columnas.
●
setModel(): Asigna el modelo de datos al objeto JTable.
●
GetRowCount(): Devuelve el número de filas en la tabla. DefaultTableModel Esta
clase permite construir el modelo para el objeto Table. Los métodos más
utilizados son:
●
addColumn(): Añade una columna al modelo.
● AddRow(): Añade una fila al final del
modelo.
● getColumnCount(): Devuelve el número de
columnas en esta tabla de datos.
●
getRowCount(): Devuelve el número de filas en esta tabla de datos.
● getValueAt(): Devuelve un valor de atributo
para la celda en la posición row, column.
●
insertRow(): Inserta una fila en el modelo.
●
RemoveRow(): Elimina del modelo según la posición de la fila indicada.
Aplicación
Construir
una aplicación que permita calcular el promedio de las notas obtenidas en el
curso de Programación Visual. La aplicación debe permitir el ingreso del nombre
del alumno, la nota de la I Unidad, la nota de la II Unidad y la nota de la III
Unidad. Además debe permitir la selección del turno a la que pertenece el
alumno. A través de un botón de comando debe agregar los datos en un objeto
Jtable, calculando el promedio de las notas; y a través de otro botón de
comando debe eliminar la fila seleccionada en el objeto JTable. También se debe
mostrar el total de filas agregadas en el objeto JTable.
Solución:
●
Usaremos el mismo proyecto utilizado en la sesión anterior y sólo agregarás un
formulario (Jframe).
Inmediatamente se muestra la
siguiente ventana:
Colocar como nombre de clase frmNotas
Luego
dar clic en el botón de comando Finish.
● A continuación se muestra el entorno de
desarrollo de NetBeans y no olvides de dar clic en el botón derecho del mouse
sobre el formulario y establece AbsoluteLayout en Set Layout.
●
Procedemos a colocar un objeto Jlabel con la expresión “CALIFICACIONES DEL
Elaborado por: Ing. Martín Gustavo Salcedo Quiñones
CURSO
DE PROGRAMACION VISUAL”. Debajo de éste título ubicar un objeto Jlabel con la
expresión “ALUMNO:” acompañado de un cuadro de texto (JTextField) . A
continuación, colocar otro Jlabel con la expresión “Nota de la I Unidad”
acompañado de un cuadro de texto y de igual manera hacerlo para la segunda y
tercera unidad. Luego agregamos un objeto JCombobox para seleccionar el turno.
●
Seleccionamos el objeto JComboBox y elegimos en la ventana de propiedades, la
propiedad model que permite colocar los ítems dentro de la caja de lista
desplegadle. Elegimos el botón de comando referido a la propiedad model se
muestra la siguiente ventana:
●
Ingresamos “”,“Mañana”, “Tarde” y “Noche” y luego hacemos click en el botón de
comando OK. Continuamos con el diseño del formulario agregando un botón de
comando “Agregar” y un botón de comando “Eliminar”. Luego procedemos a agregar
el objeto JTable.
● Al
ser dibujado el objeto JTable se observa en el panel de la izquierda que se
vincula a un objeto JScrollPane. El objeto Jtable tiene como propiedad principal
a model.
● Luego de seleccionar el botón de comando referido a la propiedad model
se muesiguiente ventana:
●
Observamos en la ventana anterior que por defecto el objeto Table propone la
conformación
de 4 columnas y 4 filas, dando la posibilidad de aumentar o disminuir el número
de columnas y filas. Además podemos establecer los títulos de cada columna.
Aquí debemos hacer hincapié que las columnas y las filas son tipo Object esto
quiere decir que un objeto JTable es una matriz de objetos (arreglo
bidimensional). Nosotros vamos a establecer el número de columnas a través de
la programación y las filas se crearán en la medida que se necesiten.
●
Los nombres de los objetos de control dibujados en el formulario queda de la
siguiente manera:
●
Vamos a proceder a programar. Comenzamos con hacer uso del paquete swing y
específicamente a las clases JoptionPane y a la clase JTable.
●
Luego procedemos a crear un modelo para el objeto JTable llamado Tabla a través
de la clase DefaultTableModel. Lo hacemos dentro de la clase frmNotas. Usar la
clase DefaultTableModel es posible gracias al import javax.swing.table.*;
Declaramos
y creamos una variable de memoria dtm del tipo DefaultTableModel.
● En
el Método constructor programamos lo siguiente (sólo escribe lo que se señala
la llave de color rojo):
Declaramos
y creamos una variable de memoria titulos del tipo cadena y es un arreglo. Esta
variable titulos se inicializa con los valores “Alumno”, ”I Unidad”, “II
Unidad”, “III Unidad”, “Promedio” y “Turno”, que serán los títulos de las
columnas del objeto JTable. Luego, con el método setColumnIdentifiers() se
define las columnas con sus respectivos títulos en la variable dtm (modelo del
JTable llamado Tabla). Finalmente, se vincula el modelo, representado en la
variable dtm, al objeto JTable llamado Tabla.
● Si en estos momentos decidimos ejecutar
nuestra aplicación, quedaría nuestro formulario así:
Observamos
que el objeto JTable muestra las columnas definas en la programación hecha en
el método constructor.
● Procedamos con la programación del botón de
comando Agregar (sólo escribe lo que se señala la llave de color rojo).
Declaramos
y creamos una variable de memoria datos de tipo String y de tamaño 6. Luego,
declaramos las variables de memoria n1, n2, n3 y total de tipo entero, la
variable promedio de tipo double y una variable de memoria verifica de tipo
booleano. Las variables de memoria n1, n2 y n3 reciben los valores ingresado en
los cuadros de textos txtn1, txtn2 y txtn3 respectivamente. Con la variable de
memoria verifica se pretende evaluar si se llegó a escribir en los cuadros de
textos y se haya seleccionado un turno. Con la sentencia IF evaluamos la
variable verifica y con el operador ! hacemos negación, es decir, si la
variable verifica es falso entonces con ! se convierte en verdadero. Si la
variable verifica es falso significa que se ingresó los datos en los cuadros de
textos y se seleccionó el turno, entonces procedemos a calcular el promedio
teniendo presente que las variables n1,n2, n3 siendo enteras deben ser tratadas
como reales (double). Posteriormente, hacemos uso del arreglo datos asignando
los datos ingresados y el turno seleccionado en cada uno de los elementos. Con
el método addRow() logramos crear una fila con los valores contenidos con el
vector o arreglo datos. Luego, limpiamos los cuadros de textos y hacemos que el
objeto JComboBox quede en al dar el valor cero al método setSelectedIndex(). Si
la variable verifica es verdadero significa que falta ingresar algún dato o
seleccionar el turno. Finalmente, se muestra la cantidad de filas agregadas en
el cuadro de texto txtTotal y haciendo uso del método setRowCount()
perteneciente a dtm.
1.
Resumen
Definición Jtable
Jtable es una clase que me permite organizar una
determinada información en tabla, esta difiere de una base de datos normal
porque al utilizar Jtable tú puedes visualizar esta tabla, brindándole al
usuario organización de información, oportunidades de editar y cambiar el
tamaño de las columna entre otras.
INICIOS DE JTABLE
En principio se creó la clase Jtable para constituir un
interfaz ligado a bases de datos a través de "Java Database Connectivity"
(JDBC), y así evita la complejidad que existía para el manejo de datos, dando
así al programador mucha más facilidad a la hora de trabajar con este tipo de
información.
Jtable le da al programador muchas facilidades, pues este
posee varias características
TABLE MODEL
La clase Jtable controla como se presentan los datos,
siendo el TableModel quien controla los datos sí mismos. Para crear una Jtable
habrá pues que crear un TableModel antes, normalmente. TableModel lo que hace
es predeterminar ciertas características para el Jtable es decir que tu puedes
poner ciertos parámetros dentro de un TableModel y así no tener que
determinarlos siempre.
Todo lo que hagamos se reflejará de inmediato en el
JTable.
Obtener fila y columna del JTable en la que se hace click
A veces nos interesa seleccionar una fila del JTable para
hacer algo con ella (sacar un menú, recoger datos para mostrarlos en otro
sitio, etc).
Una forma de hacerlo es añadiendo un MouseListener al
JTable, de esta manera
tabla.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
int fila = tabla.rowAtPoint(e.getPoint());
int columna = tabla.columnAtPoint(e.getPoint());
if ((fila > -1) && (columna > -1))
System.out.println(modelo.getValueAt(fila,columna));
});
2.
Summary
JTable
Control with Database
Definition Jtable
Jtable
is a class that allows me to organize a certain information in a table, this
differs from a normal database because when using Jtable you can visualize this
table, giving the user information organization, opportunities to edit and
resize the columns between Others.
JTABLE
STARTINGS
In
principle, the Jtable class was created to constitute a database-bound
interface through "Java Database Connectivity" (JDBC), thus avoiding
the complexity that existed for managing data, thus giving the programmer much
easier Time to work with this kind of information.
Jtable
gives the programmer many facilities, as it has several features
TABLE
MODEL
The
Jtable class controls how the data is presented, with TableModel controlling
the data itself. To create a Jtable, you must create a TableModel before,
normally. TableModel what it does is to predetermine certain characteristics
for the Jtable ie you can put certain parameters inside a TableModel and thus
not have to always determine them.
Everything
we do will be reflected immediately in the JTable.
Get
row and column of JTable in which you click
Sometimes
we are interested in selecting a row of JTable to do something with it (take a
menu, collect data to show them elsewhere, etc).
One
way to do this is by adding a MouseListener to the JTable, in this way
Table.addMouseListener
(new MouseAdapter ()
{
Public
void mouseClicked (MouseEvent e)
{
Int
row = table.rowAtPoint (e.getPoint ());
Int
column = table.columnAtPoint (e.getPoint ());
If
((row> -1) && (column> -1))
System.out.println
(template.getValueAt (row, column));
});
3.
Recomendaciones
Ø Es un control que
nos permite mostrar la información en el orden que queramos.
Ø Además funciona como el
datagridview el cual es un control utilizado en visual que si deseas puedes
editar la información mostrado o sino deseas puedes hacerlo que no sea
editable.
Ø Es recomendable porque
puedes mostrar todos los datos que deseas.
5. Conclusiones:
Ø En conclusión ente control
es de mucha ayuda para los programadores que sirve para mostrar información.
Ø Este control también
sirve para registrar información si lo desea.
Ø Además a este control
usted lo podrá dar el número de columnas y de filas que desee.
6. Apreciación del
Equipo:
Este control es de mucha ayuda para poder desarrollar software en los
cuales se va a tener que mostrar la información que esta almacenada en la besa
de datos o la información que desea guardar en la base de datos como se da en
el caso de los detalles para que la persona que este manipulando pueda
verificar la información guardada.
LINKOGRAFÍA:
http://www.jc-mouse.net/java/jtable-editable-con-base-de-datos
ahí les dejo un LINK de diapositiva espero les guste
https://www.slideshare.net/LUZCLARITAPEREZDIAZ/subir-hoy-81540105
Se debe tener al menos 10 términos en su GLOSARIO. Muchas gracias por su aporte. Saludos
ResponderEliminar