DESARROLLO DE SOFTWARE I
1. CONTENIDO
DEFINICIÓN:
Un JTable representa
una tabla de datos con sus respectivas Filas y Columnas, la información que se
muestra en ella puede ser ingresada tanto por nosotros como obtenida de una
base de datos.
JTable es una clase que me permite organizar una
determinada información en tabla, ésta difiere de una base de datos normal porque
al utilizar JTable podemos visualizar esta tabla, brindándole al usuario
organización de información, oportunidades de editar y cambiar el tamaño de las
columnas 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 que permiten hacer desde tablas con información compleja y muy estructurada hasta tablas con información sencilla y "básica".
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 tú 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 sí mismo, es decir, puede
tener la información de la tabla, pero estos datos son 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.
¿ES EDITABLE O NO?:
JTable tiene
una característica muy llamativa, este permite que el programador pueda decidir
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 tú 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 TableModel o directamente y/o desde el
programa. JTable tiene la propiedad de dejar editable las celdas si no
encuentra nada que hable de esto.
¿Y 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 está 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 encargará automáticamente de colocar la
información donde se le indico.
PROPIEDADES:
Lo siguiente es un código en donde
se llena un Jtable con Netbeans, pero haciéndolo mediante una base de datos...
Solamente toca cambiar la conexión, el select y el nombre del Jtable.
//Devuelve toda la tabla producto
public static
DefaultListModel obtenerCodigos() {
DefaultListModel modelo =
new DefaultListModel();
try {
DefaultListModel
defaultListModel = new DefaultListModel();
int contador=1;
String codigo="";
ResultSet resultados =
conexion.ejecutarConsulta("SELECT * FROM producto");
//Este while es quien llega
la lista para luego utilizarla llenando el Jtable
while(resultados.next()){
codigo=
resultados.getString(1);
defaultListModel.addElement(contador+".
"+codigo);
contador++;
}
conexion.cerrarConsulta();
return defaultListModel;
} catch (SQLException ex) {
return modelo;
}
}
//aqui se llena el Jtable
con lo que retorno lo anterior
this.listMarcadores.setModel(obtenerCodigos());
EJEMPLO:
package dba;import
java.sql.Connection;
import java.sql.DriverManager;
import javax.swing.JOptionPane;
public class Mysql {
private static String db="unalm";
private static String user="root";
private static String
pass="aquitupassword";
private static String
url="jdbc:mysql://localhost:3306/"+db;
private static Connection Conn;
public static Connection getConnection(){
try{
Class.forName("com.mysql.jdbc.Driver");
Conn=DriverManager.getConnection(url, user, pass);
}catch(Exception e){
JOptionPane.showMessageDialog(null,"Error"+e.getMessage());
}
return Conn;
}
}
package form;
import javax.swing.table.DefaultTableModel;
import dba.Mysql;
import java.sql.*;
import javax.swing.JOptionPane;
public class Cliente extends javax.swing.JFrame {
DefaultTableModel
model;
Connection
Conn;
Statement
sent;
public Cliente() {
initComponents();
Conn=Mysql.getConnection();
Deshabilitar();
Llenar();
}
void
Deshabilitar(){
txtNombre.setEditable(false);
txtDireccion.setEditable(false);
txtCorreo.setEditable(false);
txtTelefono.setEditable(false);
}
void
Limpiar(){
txtNombre.setText("");
txtDireccion.setText("");
txtCorreo.setText("");
txtTelefono.setText("");
}
void
Habilitar(){
txtNombre.setEditable(true);
txtCorreo.setEditable(true);
txtDireccion.setEditable(true);
txtTelefono.setEditable(true);
txtNombre.requestFocus();
}
void Llenar(){
try{
Conn=Mysql.getConnection();
String [] titulos
={"Id","Nombre","Direccion",
"Telefono", "Correo"};
String sql="select * from contactos";
model=new
DefaultTableModel(null, titulos);
sent=Conn.createStatement();
ResultSet rs=sent.executeQuery(sql);
String
fila []= new String [5];
while(rs.next()){
fila [0]=rs.getString("id");
fila [1]=rs.getString("nombre");
fila [2]=rs.getString("direccion");
fila [3]=rs.getString("telefono");
fila [4]=rs.getString("correo");
model.addRow(fila);
}
jTable1.setModel(model);
}catch(Exception e){
e.printStackTrace();
}
}
private void
btnEliminarActionPerformed(java.awt.event.ActionEvent evt)
{
try{
int
fila=jTable1.getSelectedRow();
String sql="delete from
contactos where id="+jTable1.getValueAt(fila,0);
sent=Conn.createStatement();
int n=sent.executeUpdate(sql);
if(n>0){
Llenar();
JOptionPane.showMessageDialog(null, "datos eliminados");
Limpiar();
}
}catch(Exception e){
JOptionPane.showMessageDialog(null,
"error"+e.getMessage());
}
}
private void
btnGuardarActionPerformed(java.awt.event.ActionEvent evt)
{
try{
String sql="insert into contactos ( direccion ,nombre, telefono,
correo)" +
"Values (?,?,?,?) ";
PreparedStatement ps=Conn.prepareCall(sql);
ps.setString(1, txtNombre.getText());
ps.setString(2, txtDireccion.getText());
ps.setString(3, txtTelefono.getText());
ps.setString(4, txtCorreo.getText());
int n=ps.executeUpdate();
if(n>0)
JOptionPane.showMessageDialog(null, "datos
guardados");
}catch(Exception e){
JOptionPane.showMessageDialog(null, "error"+ e.getMessage());
}
Llenar();
Limpiar();
}
private void
btnNuevoActionPerformed(java.awt.event.ActionEvent evt)
{
Limpiar();
Habilitar();
// TODO
add your handling code here:
}
private void
jTable1MouseClicked(java.awt.event.MouseEvent evt)
{
if(evt.getButton()==1){
try{
Habilitar();
int
fila=jTable1.getSelectedRow();
String
sql="select * from contactos where id="+jTable1.getValueAt(fila,0);
sent=Conn.createStatement();
ResultSet
rs=sent.executeQuery(sql);
rs.next();
txtNombre.setText(rs.getString("nombre"));
txtDireccion.setText(rs.getString("direccion"));
txtTelefono.setText(rs.getString("telefono"));
txtCorreo.setText(rs.getString("correo"));
}catch(Exception e){
e.printStackTrace();
}
}
}
private void
btnModificarActionPerformed(java.awt.event.ActionEvent evt)
{
try{
String sql="Update contactos set nombre=?, direccion=?, telefono=?,
correo=?"+
"where id=?";
int
fila=jTable1.getSelectedRow();
String
dao=(String)jTable1.getValueAt(fila,0);
PreparedStatement
ps=Conn.prepareCall(sql);
ps.setString(1,txtNombre.getText());
ps.setString(2,txtDireccion.getText());
ps.setString(3,txtTelefono.getText());
ps.setString(4,txtCorreo.getText());//valor de campos de texto a pasar a
//BasedeDatos
ps.setString(5,dao);//la llamada sql se muestra en la tabla
int n=ps.executeUpdate();
if(n>0){
Limpiar();
Llenar();
JOptionPane.showMessageDialog(null, "datos modificados");
}
}catch (Exception e){
JOptionPane.showMessageDialog(null, "error"+ e.getMessage());
}
// TODO
add your handling code here:
}
private void
btnCerrarActionPerformed(java.awt.event.ActionEvent evt)
{
System.exit(0);
// TODO
add your handling code here:
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Cliente().setVisible(true);
}
});
}
private javax.swing.JButton btnCerrar;
private javax.swing.JButton
btnEliminar;
private javax.swing.JButton
btnGuardar;
private javax.swing.JButton
btnModificar;
private javax.swing.JButton
btnNuevo;
private javax.swing.JLabel
jLabel1;
private javax.swing.JLabel
jLabel2;
private javax.swing.JLabel
jLabel3;
private javax.swing.JLabel
jLabel4;
private javax.swing.JPanel
jPanel1;
private javax.swing.JScrollPane
jScrollPane1;
private javax.swing.JTable
jTable1;
private javax.swing.JTextField
txtCorreo;
private javax.swing.JTextField txtDireccion;
private javax.swing.JTextField
txtNombre;
private javax.swing.JTextField
txtTelefono;
// End of
variables
declaration
}
2. RESUMEN
JTable es un componente swing java que nos permite
mostrar datos en una tabla de una base de datos, sin embargo a diferencia de
otros componentes similares de otros lenguajes de programación, java no nos
permite gestionar directamente los datos.
La clase JTable controla como se
presentan los datos, siendo el TableModel quien controla los datos sí mismos.
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 tú te
puedes dirigir adentro de las celdas encontradas en una tabla se puede permitir
al usuario editar o no editar según lo desee el programador
Para crear
una JTable habrá pues que crear un TableModel.TableModel lo que hace es
predeterminar ciertas características para el JTable es decir, que tú puedes
poner ciertos parámetros dentro de un TableModel y así no tener que
determinarlos siempre.
TableModel
puede tener la información de la tabla, pero estos datos son 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.
3. SUMMARY
JTable is a java swing component that allows us to
display data in a table in a database, however unlike other similar components
of other programming languages, java does not allow us to directly manage the
data.
The JTable class controls how the data is presented,
with TableModel controlling the data themselves.
JTable automatically makes the cells within the table
editable. There are several ways to make cells editable or not inside the
table, to see these commands you can direct inside the cells found in a table
can be allowed to edit or not edit as desired by the programmer
To create a JTable will have to create a
TableModel.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.
TableModel can have the information of the table, but
these data are displayed by the computer, ie to display a table the TABLEMODEL
can have the information, but without the JTable can not be displayed for the
user.
Para
desarrollar un JTable lo primero que debemos hacer es copiar y pegar las siguientes
librerías, las cuales son sumamente necesarias para que funcione sin
inconvenientes.
import
java.sql.Connection;
import
java.sql.PreparedStatement;
import
java.sql.ResultSet;
import
java.sql.SQLException;
import
javax.swing.JOptionPane;
import javax.swing.JTable;
import
javax.swing.table.DefaultTableModel;
Es
importante manejar la estructura del lenguaje de Java para poder definir
Jtable.
5.
Existe una clase llamada JTable que permite crear objetos
con forma de tabla.
Estos objetos son ideales para mostrar el contenido
de las tablas de una base de datos, aunque pueden ser usados de forma
independiente también para mostrar cualquier tipo de datos.
Los objetos del tipo JTable contienen un modelo de datos de tipo DefaultTableModel.
Cada vez que se quiera trabajar con una tabla será
necesario construir su modelo y asignarlo a la tabla.
Cada vez que se quiera modificar de alguna forma los
datos de una tabla, será necesario acceder a su modelo y trabajar con él.
A través del modelo de una tabla podemos añadir
nuevas filas a la tabla, eliminar filas, extraer datos de las celdas de la
tabla o añadir datos a las celdas de la tabla.
La
creación de tablas se convierte en una tarea sencilla cuando comenzamos a
conocer las clases auxiliares que la acompañan para mejorar su rendimiento y
eficiencia; la finalidad de este trabajo de investigación es precisamente
empezar a familiarizarse con estas clases.
6. APRECIACIÓN
DEL EQUIPO
Como
futuros ingenieros es sumamente importante saber manejar el lenguaje de
programación Java por los múltiples beneficios, entonces mediante su estudio
podemos conocer su estructura y sobretodo como podemos acceder a una Base de
Datos desde la plataforma Java. En este tema podemos conocer cómo desarrollar
JTable con Base de Datos.
7. GLOSARIO DE TÉRMINOS
SWING:
Es un biblioteca gráfica para Java. Es parte de Sun Microsystems Java
Foundation Classes (JFC), un API para proporcionar una interfaz gráfica de
usuario(GUI) para programas de Java
,tales como cajas de texto, botones, desplegables y tablas.
REDEFINIR: Volver a definir algo cuyas características o circunstancia
han cambiado.
INSTANCIA:
es la particularización, realización específica
u ocurrencia de una determinada clase, entidad.
SCROLL: Se denomina scroll, desplazamiento, rollo o voluta al movimiento en 2D de los
contenidos que conforman el escenario de un videojuego o la ventana que se muestra en una aplicación informática (por
ejemplo, una página web visualizada en un navegador web).
PÍXEL: El píxel es la unidad más pequeña y diminuta de
una imagen digital y está presente en un inmensurable número para formar una
imagen completa. Cada píxel es una unidad homogénea de color que
en suma y con una importante variación de colores dan como resultado una imagen
más o menos compleja.
LINKOGRAFÍA
