011 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Formulario referencial Proveedor.

Primeramente vemos el diseño final del formulario (img. 01), que como siempre es un “jDialog”. Ponemos en letra roja como referencia los nombre de variable para cada objeto del diseño, esto es importante para que se ajusten a los métodos y eventos que vayamos creando. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre el mismo y en el menú desplegable seleccionar “Cambiar nombre de variable…”.
"Clic, ampliar imagen..."
En la imagen siguiente (img. 02) podemos ver las importaciones que agregamos para hacer funcionar nuestro formulario. También vemos los métodos que llamamos desde el constructor de la clase, que como sabemos se ejecutan al crear el formulario. Y las variables de clase que necesitaremos. Se agregan comentario para facilitar la comprensión de ciertas líneas de código.
En la imagen siguiente (img. 03) vemos los eventos que utilizaremos. Como ya vimos en anteriores tutoriales, debemos de saber cómo implementarlas y sobre que objetos. Obs.: Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Se utiliza el evento “MouseClicked” para el jTable. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para tratar de facilitar el entendimiento.
A continuación vemos los métodos que utilizaremos para hacer funcionar a nuestro formulario. A cada método le asignamos un nombre que nos indica la función que está cumpliendo, esto facilita entender en qué lugar la aplicamos. En partes específicas se agregan comentarios para facilitar el entendimiento de ciertas líneas de código.
Código Java
public void hibernateSession(){
//Abrimos una sesión, como la variable es de clase, podremos utilizarla
//desde cualquier método.
st = HibernateUtil.getSessionFactory().openSession();
}
public void arranque(){
//Limpiamos campos, configuramos objetos.
this.id.setEnabled(false);
this.id.setText(null);
this.des.setEnabled(false);
this.des.setText(null);
this.dir.setEnabled(false);
this.dir.setText(null);
this.tel.setEnabled(false);
this.tel.setText(null);
this.guardar.setText("Guardar");
this.nuevo.setEnabled(true);
this.guardar.setEnabled(false);
this.editar.setEnabled(false);
this.eliminar.setEnabled(false);
this.jTable1.setEnabled(true);
defaultTableModel();
cargarTable();
}
public void defaultTableModel(){
//Configuramos nuestra tabla de la forma siguiente.
this.jTable1.getColumnModel().getColumn(0).setPreferredWidth(20);
this.jTable1.getColumnModel().getColumn(1).setPreferredWidth(200);
this.jTable1.getColumnModel().getColumn(2).setPreferredWidth(150);
this.jTable1.getColumnModel().getColumn(3).setPreferredWidth(70);
//La variable model es de clase, podremos utilizar en cualquier método.
//Nos permitira agregar, editar y eliminar datos de la tabla.
model = (DefaultTableModel) this.jTable1.getModel();
model.setNumRows(0);
}
public void cargarTable(){
//Llamamos a la variable "st" para iniciar una transacción con la DB.
st.beginTransaction();
//Obtenemos una lista de todos los registros de la tabla proveedor de la siquiente forma.
List<Proveedor> list = (List<Proveedor>)st.createQuery("from Proveedor").list();
//Con Iterator podremos navegar por la lista anterior creada.
for (Iterator<Proveedor> it = list.iterator(); it.hasNext();) {
//Casteo a clase Proveedor de la lista para poder utilizar los get y set.
Proveedor proveedor = it.next();
//Cada ciclo carga un fila nueva a la tabla con registros del DB.
model.addRow(new Object[]{
proveedor.getId(),proveedor.getDes(),proveedor.getDir(),proveedor.getTel()
});
}
}
public void nuevo(){
//Habilitamos campos y objetos para cargar un nuevo registro a la DB.
this.id.setText("Auto");
this.des.setEnabled(true);
this.des.setText(null);
this.dir.setEnabled(true);
this.dir.setText(null);
this.tel.setEnabled(true);
this.tel.setText(null);
this.nuevo.setEnabled(false);
this.guardar.setText("Guardar");
this.guardar.setEnabled(true);
this.jTable1.setEnabled(false);
}
public void guardar(){
//Antes de proceder a guardar comprobamos que no hayan campos vacios.
if(this.des.getText().isEmpty()){
this.des.setText("-");
guardar();
}
else{
if(this.dir.getText().isEmpty()){
this.dir.setText("-");
guardar();
}
else{
if(this.tel.getText().isEmpty()){
this.tel.setText("-");
guardar();
}
else{
//Tendremos dos posibles casos, un nuevo registro o actualización.
//Si el botón guardar muestra la etiqueta "Guardar", se creará un nuevo registro.
if(this.guardar.getText().equals("Guardar")){
st.beginTransaction();
Proveedor prov = new Proveedor();
prov.setDes(this.des.getText());
prov.setDir(this.dir.getText());
prov.setTel(this.tel.getText());
//save para nuevo registro
st.save(prov);
//El commit permite confirmar la transacción y procesarla
st.getTransaction().commit();
arranque();
JOptionPane.showMessageDialog(null, "Proveedor guardado correctamente.");
}
else{
//Caso contrario a la anterior, se cargará el registro seleccionado
//y se podra actualizar los cambios.
st.beginTransaction();
int idProv = Integer.parseInt(this.id.getText());
//Para cargar un registro se utiliza un load con los parámetros de clase e "id"
Proveedor prov = (Proveedor)st.load(Proveedor.class, idProv);
prov.setDes(this.des.getText());
prov.setDir(this.dir.getText());
prov.setTel(this.tel.getText());
//Para el caso será un update.
st.update(prov);
st.getTransaction().commit();
arranque();
JOptionPane.showMessageDialog(null, "Proveedor actualizado correctamente.");
}
}
}
}
}
public void cargarProveedor(){
//Lo siguiente permite rellenar los campos con los datos que se obtengan
//de la fila seleccionada del jTable1
if(this.jTable1.isEnabled()){
//Se obtiene la fila seleccionada
int selectedRow = this.jTable1.getSelectedRow();
//Se obtiene el "id" del registro que esta en la columna "0"
int idProv = Integer.parseInt(String.valueOf(model.getValueAt(selectedRow, 0)));
//Se utiliza un load para cargar el objeto.
Proveedor prov = (Proveedor)st.load(Proveedor.class, idProv);
//Cargado el objeto se pueden utilizar los "get".
this.id.setText(String.valueOf(prov.getId()));
this.des.setText(prov.getDes());
this.dir.setText(prov.getDir());
this.tel.setText(prov.getTel());
this.editar.setEnabled(true);
this.eliminar.setEnabled(true);
this.nuevo.setEnabled(false);
}
}
public void editar(){
//Activa campos para edición.
this.des.setEnabled(true);
this.dir.setEnabled(true);
this.tel.setEnabled(true);
this.nuevo.setEnabled(false);
this.eliminar.setEnabled(false);
this.guardar.setEnabled(true);
this.guardar.setText("Actualizar");
this.jTable1.setEnabled(false);
}
public void eliminar(){
//Forma de confirmar una eliminación de registro.
int showConfirmDialog = JOptionPane.showConfirmDialog(null, "Eliminación de Registro", "Desea eliminar este registro.", JOptionPane.YES_NO_OPTION);
if(showConfirmDialog == 1){
JOptionPane.showMessageDialog(null, "Registro no eliminado.");
}
else{
//Iniciamos una transacción
st.beginTransaction();
//Obtenemos la fila seleccionada de la tabla.
int selectedRow = this.jTable1.getSelectedRow();
//Obtenemos el "id" del registro de la columna "0" de la tabla.
int idProv = Integer.parseInt(String.valueOf(model.getValueAt(selectedRow, 0)));
//Cargamos el objeto.
Proveedor prov = (Proveedor)st.load(Proveedor.class, idProv);
//Eliminamos con delete
st.delete(prov);
//Confirmamos la transacción
st.getTransaction().commit();
JOptionPane.showMessageDialog(null, "Registro eliminado.");
arranque();
}
}
Por último, (img. 04) vemos el resultado ejecutando el formulario.
Obs.: Resulta difícil explicar todo el proceso y función de cada línea de código por tanto pueden realizar un comentario con sus dudas.

Java básico 059. Función, imprimir un triángulo hueco utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un triángulo (hueco) con tantos asteriscos (*) de altura como indique el número leído.
Por ejemplo, para un número leído con valor 5, escribirá:
    *
   * *
  *   *
 *     *
*********
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class FuncionDibujSeis {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Declaramos un entero, cantidad de elementos.
int n;
//Utilizamos Scanner para capturar datos del teclado.
Scanner num = new Scanner(System.in);
//El try sirve para capturar las excepciones de entrada de datos.
try {
System.out.print("Ingresa una cantidad entera: ");
//Forma de capturar datos de teclado con Scanner.
n = num.nextInt();
//Llamamos la función pasando el entero capturado como argumento.
asterisco(n);
} catch (Exception e) {
//En caso que el dato ingresado no sea de tipo entero, se indica el error.
System.out.println("ERROR: se espera dato entero.");
}
}
//Creamos la función al cual le pasamos un entero como argumento.
static void asterisco(int n){
//Creamos una variable tipo constante para utilizarla.
final char simbolo = '*';
//Creamos el primer for.
//Se hace con un preincremento ++j.
for (int i = 0; i < n; ++i) {
//Cada primer for, se hace un salto de línea.
System.out.println();
//Utilizamos dos for para lograr la forma.
for (int j = 0; j < n-i-1; ++j) {
System.out.print(" ");
}
for (int j = 0; j < 2*i+1; ++j){
//Condición para imprimir solo los bordes.
if ((i==0)||(i==n-1)||(j==0)||(j==2*i)) {
System.out.print(simbolo);
}
else{
System.out.print(" ");
}

}
}
System.out.println();
}
}

Java básico 058. Función, imprimir un triángulo relleno utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un triángulo (relleno) con tantos asteriscos (*) de altura como indique el número leído.
Por ejemplo, para un número leído con valor 5, escribirá:
    *
   ***
  *****
 *******
*********
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class FuncionDibujCinco {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Declaramos un entero, cantidad de elementos.
int n;
//Utilizamos Scanner para capturar datos del teclado.
Scanner num = new Scanner(System.in);
//El try sirve para capturar las excepciones de entrada de datos.
try {
System.out.print("Ingresa una cantidad entera: ");
//Forma de capturar datos de teclado con Scanner.
n = num.nextInt();
//Llamamos la función pasando el entero capturado como argumento.
asterisco(n);
} catch (Exception e) {
//En caso que el dato ingresado no sea de tipo entero, se indica el error.
System.out.println("ERROR: se espera dato entero.");
}
}
//Creamos la función al cual le pasamos un entero como argumento.
static void asterisco(int n){
//Creamos una variable tipo constante para utilizarla.
final char simbolo = '*';
//Creamos el primer for.
//Se hace con un preincremento ++j.
for (int i = 0; i < n; ++i) {
//Cada primer for, se hace un salto de línea.
System.out.println();
//Utilizamos dos for para lograr la forma.
for (int j = 0; j < n-i-1; ++j) {
System.out.print(" ");
}
for (int j = 0; j < 2*i+1; ++j){
System.out.print(simbolo);
}
}
System.out.println();
}
}

Java básico 057. Función, imprimir un triángulo rectángulo hueco utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un numero entero del teclado y escriba un triángulo rectángulo (hueco) con tantos asteriscos (*) de base y altura como indique el número leído.
Por ejemplo, para un número leído con valor 5, escribirá:
*
**
* *
*  *
*****
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class FuncionDibujCuatro {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Declaramos un entero, cantidad de elementos.
int n;
//Utilizamos Scanner para capturar datos del teclado.
Scanner num = new Scanner(System.in);
//El try sirve para capturar las excepciones de entrada de datos.
try {
System.out.print("Ingresa una cantidad entera: ");
//Forma de capturar datos de teclado con Scanner.
n = num.nextInt();
//Llamamos la función pasando el entero capturado como argumento.
asterisco(n);
} catch (Exception e) {
//En caso que el dato ingresado no sea de tipo entero, se indica el error.
System.out.println("ERROR: se espera dato entero.");
}
}
//Creamos la función al cual le pasamos un entero como argumento.
static void asterisco(int n){
//Creamos una variable tipo constante para utilizarla.
final char simbolo = '*';
//Creamos el primer for.
//Se hace con un preincremento ++j.
for (int i = 0; i < n; ++i) {
//Cada primer for, se hace un salto de línea.
System.out.println();
//Anidamos otro for con el mismo proceso.
for (int j = 0; j <= i; ++j) {
//Establecemos una condición para que se imprima el "*".
if(((i==0)||(i==n-1)||(j==0)||(j==i))){
System.out.print(simbolo);
}
else{
System.out.print(" ");
}
}
}
System.out.println();
}
}

Java básico 056. Función, imprimir un triángulo rectángulo lleno utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un triángulo rectángulo (relleno) con tantos asteriscos (*) de base y altura como indique el número leído.
Por ejemplo, para un número leído con valor 5, escribirá:
*
**
***
****
*****

Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class FuncionDibujTres {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Declaramos un entero, cantidad de elementos.
int n;
//Utilizamos Scanner para capturar datos del teclado.
Scanner num = new Scanner(System.in);
//El try sirve para capturar las excepciones de entrada de datos.
try {
System.out.print("Ingresa una cantidad entera.");
//Forma de capturar datos de teclado con Scanner.
n = num.nextInt();
//Llamamos la función pasando el entero capturado como argumento.
asterisco(n);
} catch (Exception e) {
//En caso que el dato ingresado no sea de tipo entero, se indica el error.
System.out.println("ERROR: se espera dato entero.");
}
}
//Creamos la función al cual le pasamos un entero como argumento.
static void asterisco(int n){
//Creamos una variable tipo constante para utilizarla.
final char simbolo = '*';
//Creamos el primer for.
//Se hace con un preincremento ++i al igual que ++j.
for (int i = 0; i < n; ++i) {
//Cada primer for, se hace un salto de línea.
System.out.println();
//Anidamos otro for con el mismo proceso.
//Mientra "j" sea menor o igual a "i" se imprime, esto dará forma al
//Triángulo Rectángulo..
for (int j = 0; j <= i; ++j) {
System.out.print(simbolo);
}
}
System.out.println();
}
}

Java básico 055. Función, imprimir un cuadrado lleno utilizando asteriscos “*”.

Ejercicio: Diseñe una función que lea un número entero del teclado y escriba un cuadrado (relleno) con tantos asteriscos (*) de lado como indique el número leído. Por ejemplo, para un número leído con valor 5, escribirá:
*****
*****
*****
*****
*****
Código Java
import java.util.Scanner;

/**
*
* @author Ariel
*/

public class FuncionDibujDos {

/**
* @param args the command line arguments
*/

public static void main(String[] args) {
//Declaramos un entero, cantidad de elementos.
int n;
//Utilizamos Scanner para capturar datos del teclado.
Scanner num = new Scanner(System.in);
//El try sirve para capturar las excepciones de entrada de datos.
try {
System.out.print("Ingresa una cantidad entera.");
//Forma de capturar datos de teclado con Scanner.
n = num.nextInt();
//Llamamos la función pasando el entero capturado como argumento.
asterisco(n);
} catch (Exception e) {
//En caso que el dato ingresado no sea de tipo entero, se indica el error.
System.out.println("ERROR: se espera dato entero.");
}
}
//Creamos la función al cual le pasamos un entero como argumento.
static void asterisco(int n){
//Creamos una variable tipo constante para utilizarla.
final char simbolo = '*';
//Creamos el primer for.
//Se hace con un preincremento ++j.
for (int i = 0; i < n; ++i) {
//Cada primer for, se hace un salto de línea.
System.out.println();
//Anidamos otro for con el mismo proceso.
for (int j = 0; j < n; ++j) {
System.out.print(simbolo);
}
}
System.out.println();
}
}

Java + Swing 018. Modo diseño en NetBeans. Agregar JComboBox y JCheckBox a un jTable.

Ejercicio: Realizar una pequeña aplicación que permita agregar JComboBox y JCheckBox a una tabla, dentro de una columna específica. La aplicación debe permitir eliminar, mover y editar cada fila de la tabla.
Diseño de formulario con JFrame.
En la imagen podemos ver el diseño y los nombres de variables de cada objeto, es importante para que se ajuste a los métodos que se crean. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho y “Cambiar nombre de variable…”. Es fácil distinguir cual corresponde a cada objeto, los nombre de variables son iguales a la etiqueta asignada al objeto.
Observación: Tomar en cuenta que hay que utilizar las importaciones “import”, básico para utilizar ciertos métodos y objetos. El “setLocationRelativeTo(null)” sirve para centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario. Las variables de clase se pueden llamar desde cualquier método, por tanto se utiliza para objetos que se necesitan utilizar en varias ubicaciones.
Creamos los métodos siguientes en el apartado “Fuente”. Estos métodos utilizan conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor posible el resultado. Se agregan comentarios para tratar de facilitar el entendimiento del funcionamiento de cada código.
Código Java
private void tableModel(){
//Metodo para configurar el DefaultTableModel.
//Se llama desde el constructor del JFrame para que la tabla arranque con el
//formato deseado.
//Indicamos el tamaño de las columnas.
jTable1.getColumnModel().getColumn(0).setPreferredWidth(5);
jTable1.getColumnModel().getColumn(1).setPreferredWidth(100);
jTable1.getColumnModel().getColumn(2).setPreferredWidth(100);
jTable1.getColumnModel().getColumn(3).setPreferredWidth(100);
jTable1.getColumnModel().getColumn(4).setPreferredWidth(100);
jTable1.getColumnModel().getColumn(5).setPreferredWidth(5);
//Asigamos a la variable model el objeto jTable1.
//Esto permite utilizar la variable model para trabajar con la tabla.
model = (DefaultTableModel)jTable1.getModel();
//Indicamos que al principio tendrá cero filas.
model.setNumRows(0);
}
private void arranque(){
//Desactivamos estos botones al arranque.
subir.setEnabled(false);
bajar.setEnabled(false);
}
private void limpiar(){
//Permite poner a cero las filas del jTable1
model.setNumRows(0);
arranque();
}
private void agregar(){
//Método par agregar filas al jTable1.
//Cada fila tendrá también un JComboBox y un JCheckBox.
//Declaramos un nuevo objeto JComboBox.
JComboBox combo = new JComboBox();
//Le asiganamos dos valores.
combo.setModel(new DefaultComboBoxModel(new Object[]{
"Masculino","Femenino"
}));
//Indicamos que vaya seleccionado por defecto el primer valor, para esto
//utilizando el setSelectedIndex y como parémetro el índice del valor.
//El índice empieza de cero, por tanto le corresponde al primer valor.
combo.setSelectedIndex(0);
//Obtenemos el valor seleccionado como String.
String toString = combo.getSelectedItem().toString();
//Creamos un objeto JCheckBox.
JCheckBox check = new JCheckBox();
//Forma en la que daremos valor a la columna id.
int id = jTable1.getRowCount() + 1;
//Utilizamos el model para agregar la fila, el valor de la columna que corresponde
//al JCheckBox debe ser de tipo boolean, el del JComboBox tipo String.
model.addRow(new Object[]{
id,"","",toString,"", false});
//Utilizamos el CellEditor para agregar el JComboBox y el JCheckBox.
//Para el JCheckBox también utilizamos el CellRenderer que nos permitirar tener dibujado el objeto.
jTable1.getColumnModel().getColumn(3).setCellEditor(new DefaultCellEditor(combo));
jTable1.getColumnModel().getColumn(5).setCellEditor(new DefaultCellEditor(check));
//Como parámetro para el CellRenderer le pasamos una clase que se crea más adelante.
//Es una clase predefinida con métodos predefinidos.
jTable1.getColumnModel().getColumn(5).setCellRenderer(new Render_CheckBox());
jTable1.repaint();
}
public void seleccion(){
//Método para activar y desactivar los botones "subir" y "bajar" según corresponda.
if(jTable1.getRowCount() > 0){
int selectedRow = jTable1.getSelectedRow() + 1;
int inferior = 1;
int superior = 1;
for (int i = 0; i < jTable1.getRowCount(); i++) {
superior = i + 1;
}
if(inferior == jTable1.getRowCount()){
subir.setEnabled(false);
bajar.setEnabled(false);
}
else{
if(selectedRow == inferior){
subir.setEnabled(true);
bajar.setEnabled(false);
}
else{
if(selectedRow == superior){
bajar.setEnabled(true);
subir.setEnabled(false);
}
else{
subir.setEnabled(true);
bajar.setEnabled(true);
}
}
}
}
}
private void removerSelec(){
//Este método nos permitiré eliminar una o varias filas que tengan el JCheckBox
//en true o seleccionado.
try {
if(jTable1.getRowCount() > 0){
for (int i = 0; i < jTable1.getRowCount(); i++) {
//Forma de obtener el valor boolean de la columna indicada.
boolean res = Boolean.valueOf(model.getValueAt(i, 5).toString());
while (res) {
model.removeRow(i);
res = false;
orden();
}
}
}
//El try es para controlar posibles errores, en caso de darse alguno el programa no
//realiza ninguna acción.
} catch (Exception e) {

}

}
public void moverArriba(){
//Método asignado al botón subir.
//Nos permitira mover una fila arriba utilizando moveRow
//El primer parámetro indica desde, el segundo hasta y tercero donde.
try {
int selc = jTable1.getSelectedRow();
int mov = jTable1.getSelectedRow() + 1;
model.moveRow(selc, selc, mov);
//Abajo como se explica en la documentación.
//public void moveRow(int start, int end, int to)
//start - the starting row index to be moved
//end - the ending row index to be moved
//to - the destination of the rows to be moved
//El método orden nos permitirá reescribir el orden del id.
orden();
seleccion();
jTable1.repaint();
} catch (Exception e) {
jTable1.repaint();
}

}
public void moverAbajo(){
//Método asignado al botón bajar.
//Similar el funcionamiento al método moverArriba().
try {
int selc = jTable1.getSelectedRow();
int mov = jTable1.getSelectedRow() - 1;
model.moveRow(selc, selc, mov);
orden();
seleccion();
jTable1.repaint();
} catch (Exception e) {
jTable1.repaint();
}

}
public void orden(){
//Método para reescribir el orden del id.
for (int i = 0; i < jTable1.getRowCount(); i++) {
model.setValueAt(i + 1, i, 0);
}
}
//Clase predefinida que hereda de un JCheckBox e implementa el TableCellRenderer.
//La clase está predefinida. Copia del blog de jc-mouse.
class Render_CheckBox extends JCheckBox implements TableCellRenderer {
//
private JComponent component = new JCheckBox();

/** Constructor de clase */
public Render_CheckBox() {
setOpaque(true);
}

@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
//Color de fondo de la celda
( (JCheckBox) component).setBackground( new Color(98,138,183) );
//obtiene valor boolean y coloca valor en el JCheckBox
boolean b = ((Boolean) value).booleanValue();
( (JCheckBox) component).setSelected( b );
return ( (JCheckBox) component);
}
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Se utiliza el evento “MouseClicked” para el jTable. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para tratar de facilitar el entendimiento.
Código Java
    private void agregarActionPerformed(java.awt.event.ActionEvent evt) {                                        
//Método botón agregar.
agregar();
}

private void limpiarActionPerformed(java.awt.event.ActionEvent evt) {
//Método botón limpiar.
limpiar();
}

private void jTable1MouseClicked(java.awt.event.MouseEvent evt) {
//Método para el jTable 1, obtener fila seleccionada.
seleccion();
}

private void eliminarActionPerformed(java.awt.event.ActionEvent evt) {
//Método botón eliminar.
removerSelec();
}

private void subirActionPerformed(java.awt.event.ActionEvent evt) {
//Método botón subir.
moverArriba();
}

private void bajarActionPerformed(java.awt.event.ActionEvent evt) {
//Método botón bajar.
moverAbajo();
}
Por último tenemos el formulario en ejecución.