EjemploJInternalFrame ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JInternalFrame; import javax.swing.JLabel; public class EjemploJInternalFrame extends JInternalFrame { /* ÉSTE MAIN LO GENERA ECLIPSE PARA PRUEBAS, LO DEJO * COMENTADO PORQUE YA ESTÁ FUNCIONANDO Y SE EJECUTARÁ * DENTRO DE UN JDesktopPane COMO TODO BUEN JInternalFrame * TAMBIÉN SE PUEDE EJECUTAR DENTRO DE OTROS PANELES * PERO ESO NO SE SUELE UTILIZAR. public static void main(String[] args) { EventQueue.invokeLater(new Runnable() { public void run() { try { EjemploJInternalFrame frame = new EjemploJInternalFrame(); frame.setVisible(true); } catch (Exception e) { e.printStackTrace(); } } }); }*/ // ÉSTE ES EL CONSTRUCTOR DE LA CLASE public EjemploJInternalFrame() { // coordenadas con las dimensiones de la ventana setBounds(100, 100, 245, 134); // disposición de capas a nulo para poder posicionar // con coordenadas en vez de con el esquema determinado getContentPane().setLayout(null); // un etiqueta... JLabel lblstoEsUna = new JLabel("\u00C9sto es una ventana interna..."); lblstoEsUna.setBounds(10, 11, 333, 14); getContentPane().add(lblstoEsUna); // el botón que cierra ésta ventana interna JButton btnAprietaAquPara = new JButton("Aprieta aqu\u00ED para cerrar"); btnAprietaAquPara.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { // ésto se ejecuta cuando se aprieta el botón // manda la clase a la basura, // con lo que se cierra la ventana dispose(); } }); btnAprietaAquPara.setBounds(10, 36, 209, 58); getContentPane().add(btnAprietaAquPara); } }

1. EjemploJInternalFrame
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JInternalFrame;
import javax.swing.JLabel;
public class EjemploJInternalFrame extends JInternalFrame {
/* ÉSTE MAIN LO GENERA ECLIPSE PARA PRUEBAS, LO DEJO
* COMENTADO PORQUE YA ESTÁ FUNCIONANDO Y SE EJECUTARÁ
* DENTRO DE UN JDesktopPane COMO TODO BUEN JInternalFrame
* TAMBIÉN SE PUEDE EJECUTAR DENTRO DE OTROS PANELES
* PERO ESO NO SE SUELE UTILIZAR.
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
EjemploJInternalFrame frame = new
EjemploJInternalFrame();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}*/
// ÉSTE ES EL CONSTRUCTOR DE LA CLASE
public EjemploJInternalFrame() {
// coordenadas con las dimensiones de la ventana
setBounds(100, 100, 245, 134);
// disposición de capas a nulo para poder posicionar
// con coordenadas en vez de con el esquema determinado
getContentPane().setLayout(null);
// un etiqueta...
JLabel lblstoEsUna = new JLabel("u00C9sto es una ventana
interna...");
lblstoEsUna.setBounds(10, 11, 333, 14);
getContentPane().add(lblstoEsUna);
// el botón que cierra ésta ventana interna
JButton btnAprietaAquPara = new JButton("Aprieta aquu00ED
para cerrar");
btnAprietaAquPara.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// ésto se ejecuta cuando se aprieta el botón
// manda la clase a la basura,
// con lo que se cierra la ventana
dispose();
}
});
btnAprietaAquPara.setBounds(10, 36, 209, 58);
getContentPane().add(btnAprietaAquPara);

2. 48
49
50
51
52
53
54
55
}
}
Java + Swing020.Modo diseño enNetBeans.Llamarun jDialoginterno desdeun
jFrame.
Ejercicio:Realizarunapequeñaaplicaciónque permitaejecutarunformulariojDialoginterno
desde unjFrame.
Diseñamosel formularioenJFrame.El nombre parael jFrame esa criteriode cada uno, lo
importante esel diseñode lamisma.Enla imagenpodemosverel diseñoylosnombresde
variablesde cadaobjeto(etiquetasenrojoparalosnombresde variable),estoesmuy
importante yaque cada métodoutilizael nombre de variablecorrespondienteparareferenciar
al objetoenespecífico.Se puede cambiarel “Nombre de variable”de cadaobjetohaciendo
clicderechosobre lamismay clic en“Cambiarnombre de variable…”.
Diseñodel jDialog:adiferenciade enotrassituaciones,estejDialogdebe serinterno,portanto
se agrega como cualquierotroobjeto,tomandode lapaletaysoltandosobre el diseñodel
jFrame principal comose muestraenla imagenmásabajo,lo demásesigual a como se trabaja
con un formulario.Se puede alternarconel del jFrame seleccionadodesde el “Inspector”al
costadoizquierdo.(clicparaampliarimagen)

3. Observación:Tomar en cuentaque hay que utilizarlasimportaciones“import”,básicopara
utilizarciertosmétodosyobjetos.El “setLocationRelativeTo(null)”sirve paracentrarel
formulario.Lasvariablesde clase se puedenllamardesde cualquiermétodo,portantose
utilizaparaobjetosque se necesitanutilizarenvariasubicaciones.
Creamoslosmétodossiguientesenel apartado“Fuente”.Normalmente estosmétodoslos
podemosagregardebajodel constructordel jFrame oal final de la declaraciónde variables.
Estos métodosutilizanconversionesde tiposde datos,controlesde excepcionesydemáspara
controlarlo mejorposible el resultado.Se agregancomentariosparatratarde facilitarel
entendimientodel funcionamientode cadacódigo.
private void tableModel(){
//Configuramos tamaño de las columnas
jTbl.getColumnModel().getColumn(0).setPreferredWidth(10);
jTbl.getColumnModel().getColumn(1).setPreferredWidth(200);
jTbl.getColumnModel().getColumn(2).setPreferredWidth(100);
jTbl.getColumnModel().getColumn(3).setPreferredWidth(20);
//Utilizamos nuestra variable model para asignar a nuestra tabla
el Model
model = (DefaultTableModel)jTbl.getModel();
model.setNumRows(0);
//Cargamos datos en la tabla si los campos no estan vacios.
//El signo ! sirve para negar. Por tanto decimos "si el campos es
diferente de vacío".
if(!nom.getText().isEmpty() || !nac.getText().isEmpty() ||
!edad.getText().isEmpty()){
for (int i = 0; i < 10; i++) {
model.addRow(new Object[]{
i,nom.getText(),nac.getText(),edad.getText()
});
}
}
}
private void llamarJFrame(){
//Llamamos nuestra metodo para manejar la tabla y llenarla
tableModel();
//Centramos nuestro jDialog
jDialog.setLocationRelativeTo(null);
//La hacemos modal
jDialog.setModal(true);
//Establecemos dimensiones.

4. jDialog.setMaximumSize(new Dimension(800, 600));
jDialog.setMinimumSize(new Dimension(480, 230));
//Establecemos un título para el jDialog
jDialog.setTitle("Lista de Datos.");
//La hacemos visible.
jDialog.setVisible(true);
}
Utilizamosel evento“ActionPerformed”parallamarlosmétodosdesde losbotones.Para
utilizarun“Evento”hacemosclicderechosobre el objetoyseleccionamos“Eventos”de lalista
utilizamoslaque podamosaplicaral objeto.Enlamayoría de loscasosse utilizael
“ActionPerformed”.Se agregancomentariosparatratar de facilitarel entendimiento.
private void mostrarActionPerformed(java.awt.event.ActionEvent
evt) {
//Método para llamar al jDialog
llamarJDialog();
}
Ejecutamosel formulariojFrame yllamamosanuestrojDialogdesde el botón.(clícpara
ampliarimagen)
JFrame. Existe un control Swing llamado Internal Frame que se utiliza para agregar
Frames dentro otro. Sin embargo, debemos recordar que un Frame tiene propiedades
tales como la barra de títulos, los botones de maximizar, minimizar y cerrar, coloca un
nuevo ítem en la barra de tareas en Windows, KDE y Gnome, entre otras propiedades.
Cabe destacar que muchas veces estos atributos no serán necesarios y entorpecerían el
accionar de la aplicación. Muchas veces necesitamos unicamente un pequeño recuadro e
insertarlo en uno u otro JFrame. Así que para esos efectos están los JPanels.
Realizaremos un pequeño ejemplo con éstos.
Vamos a realizar una pequeña aplicación, que consiste en realizar dos de las
operaciones básicas: sumas y restas. Para realizar cada una de ellas, el JFrame añade

5. entre sus componentes a dos JPanels, uno para cada operación respectivamente.
Antes de mostrar cómo crear los JPanels, debemos de cambiar el layout al JFrame que
utilizaremos. El Layout es una propiedad de los contenedores Swing para colocar todos
los elementos que se contienen dentro de él. Como Java es multiplataforma, y en cada
una de ella se disponen de manera distinta el orden de los elementos o componentes.
Por lo tanto, Swing lo realiza con la ayuda de los layouts. En modo diseño del JFrame,
hacemos click derecho a la opción Set Layout y le asignamos Null Layout, ya que
nosotros colocaremos otro tipo de layout diferente al del diseño libre que nos brinda el
editor de diseño de Netbeans. De esta forma:
Ahora sí, creamos dos JPanels desde el navegador de proyectos, uno llamado
panelHijoSuma y otro panelHijoResta. Deben quedar de la siguiente manera:
Vean que el último TextBox se encuentra deshabilitado para que sea modificado por el
usuario. Este solo presentará el resultado y el usuario jamás lo podrá tocar.
Al JFrame, tal y como lo observaron al inicio de este artículo solo le agregamos una
Menu Bar, y un par de ítems para que luzca así:

6. Ahora, dentro del JFrame, en su constructor, y luego de la inicialización de
componentes, vamos a establecer el layout a utilizar. Para este ejercicio, escogí el
FlowLayout, que dispone un orden de los elementos horizontal uno tras otro y con
cierto espaciado que podemos asignar.
El código dentro del constructor deberá ser el siguiente:
//Constructor
public framePadre() {
//llamo al constructor padre y le mando el nombre del título de la ventana
super("Operaciones Básicas");
//Función de inicialización de componentes. Netbeans la coloca por defecto
initComponents();
//Colocamos el nuevo tipo de layout que queremos que tenga nuestro JFrame
this.setLayout(new FlowLayout());
}
También creamos dos atributos al JFrame, para más facilidad. Serán dos atributos del
tipo de datos de cada uno de los JPanel.
private panelHijoSuma hs;
private panelHijoResta hr;
Ahora, en cada una de los ítems de la barra de menú, para mostrar el JPanel deseado,
colocamos el siguiente código:
//Nombre evento
private void nSumaActionPerformed(java.awt.event.ActionEvent evt) {
//Si ya está el otro Jpanel añadido al contenedor, entonces se elimina
try{
this.remove(hr);
}
catch(Exception e){
}
//Creamos una nueva instancia de panelHijoSuma
hs = new panelHijoSuma();
//Agregamos la instancia al JFrame, con un layout al centro
this.add(hs, BorderLayout.CENTER);

7. //Hacemos que el JFrame tenga el tamaño de todos sus elementos
this.pack();
}
Este código debe de ser similar en los restantes ítems de la Menu Bar, siempre con el
evento ActionPerformed.
Ahora, la parte final de este artículo. Realizaremos cada una de las operaciones dentro
del evento de los TextBox, KeyReleased(). De esta forma:
Ahi agregaremos el siguiente código:
//Nombre del evento. Lo genera Netbeans
private void txtnum1KeyReleased(java.awt.event.KeyEvent evt) {
//Asignamos el texto del textBox a una variable Integer
int num1 = Integer.parseInt(this.txtnum1.getText());
//Si el otro TextBox no esta vacio, entonces se debe realizar la operación
if (!this.txtnum2.getText().equals("")){
int num2 = Integer.parseInt(this.txtnum2.getText());
//Se realiza la operación, y se coloca en el TextBox del resultado
this.txtresultador.setText(String.valueOf(num2+num1));
}
}
La aplicación debe lucir así:

8. El mismo JFrame con uno y otro JPanel
Espero que les sea útil este código.
Ejemplo sencillo conJInternalFrame
Saltar a: navegación,buscar
Un JInternalFrame es una ventana que va metida dentro de un panel y no puede salirse
de él. En java el panel adecuado y especializado en el manejo de JInternalFrame es el
JDesktopPane.
Vamos a hacer un ejemplo sencillo de uso. El siguiente código crea un JFrame con un
JDesktopPane dentro. Luego se crea una ventana JInternalFrame que tiene un JLabel y
un JTextField. El JInternalFrame se mete dentro del JDesktopPane y se visualiza todo.
Es importante darle tamaño al JInternalFrame, ya que si no, no lo veremos -tiene
tamaño 0,0-. Por defecto el JInternalFrame no es redimensionable, ni se puede cerrar ni
tiene botones de maximizar y minimizar. Tendremos que decirle con los métodos
adecuados si queremos que tenga esas características. También es importante hacer
visible a posta el JInternalFrame, ya que por defecto es oculto.
/**
* Ejemplo de uso de un JInternalFrame
*/
package chuidiang.ejemplos;
import java.awt.FlowLayout;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.WindowConstants;
/**
* Instancia un JFrame con un JDesktopPane y dentro de este
* un JInternalFrame.
* @author chuidiang
*

9. */
public class PruebaInternalFrame {
/** Instancia esta clase */
public static void main(String[] args) {
new PruebaInternalFrame();
}
/**
* Crea el JFrame, el JDesktopPane, un JInternalFrame de
* muestra y lo visualiza.
*/
public PruebaInternalFrame()
{
// El JFrame con el JDesktopPane
JFrame v = new JFrame("Prueba JInternalFrame");
JDesktopPane dp = new JDesktopPane();
v.getContentPane().add(dp);
// Se construye el panel que ira dentro del
JInternalFrame
JPanel p = new JPanel();
p.setLayout(new FlowLayout());
p.add (new JLabel("Una etiqueta"));
p.add (new JTextField(10));
// Se construye el JInternalFrame
JInternalFrame internal = new JInternalFrame("Un
Internal Frame");
internal.add(p);
// Es importante darle tamaño -pack()- al
JInternalFrame,
// porque si no, tendrá tamaño 0,0 y no lo veremos.
internal.pack();
// Por defecto el JInternalFrame no es redimensionable
ni
// tiene el botón de cerrar, así que se lo ponemos.
internal.setResizable(true);
internal.setClosable(true);
// Se mete el internal en el JDesktopPane
dp.add(internal);
// Se visualiza todo.
v.setSize(500,500);
v.setVisible(true);
v.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
// Se visualiza el JInternalFrame
internal.setVisible(true);
}
}