Java.netbeans

JAVA: Practicando con FlowLayout
19012009
Continuando con los layouts, es que en esta oportunidad, tocaremos al mas facil de usar,
El FlowLayout, es aquel layout q ubica a todos los componentes en forma horizontal, en el orden
q le digamos.
Primero tenemos que crear el contenedor(JFrame, JPanel, etc), y luego atravez del metodo
“setLayout()” asignarle el layout correspondiente.
JFrame frame = new JFrame();
frame.setLayout(new FlowLayout());
Una vez, asiganado el layout al contenedor, tendremos q agregar los componentes, plenamente
ya declarados y creados.
JButton boton = new JButton("Aceptar");
frame.add(boton);
Hecho esto, el contenedor mismo, los ubicara en el centro(por defecto). Si queremos que
empieze de derecha a izquierda o izquierda a derecha o en el centro, se lo decimos.
frame.setLayout(new floLayout(FlowLayout.CENTER));
frame.setLayout(new floLayout(FlowLayout.RIGHT));
frame.setLayout(new floLayout(FlowLayout.LEFT));
Aqui un jemplo:
import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.WindowConstants;
import javax.swing.JFrame;
/*demostracion por inforux*/
public class DemoFlowLayout {

private JButton botonEnviar;
private JTextField cajaTexto;
private JLabel etiqueta;
public void construyeVentana(){
//creamos la ventana y asignamos el layout
frame.setLayout(new FlowLayout());
//Creamos los componentes a utilizar
botonEnviar = new JButton("Enviar");
cajaTexto = new JTextField(12);
etiqueta= new JLabel("Escribe tu nombre");
//Aniadimos los componentes a la ventana
frame.add(etiqueta);
frame.add(cajaTexto);
frame.add(botonEnviar);
//algunas configuraciones de la ventana
frame.pack();
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.setVisible(true);
}
public DemoFlowLayout(){//constructor de la clase
construyeVentana();
}

public static void main ( String [] Inforux){
new DemoFlowLayout();
}
}
Luego compilamos y ejecutamos
$javac DemoFlowLayout.java
$java DemoFlowLayout
El resultado sera asi:
Como ven, la misma ventana siempre ubicara a los componentes de la mejor manera..
PD: La API completa de FlowLayout
Luego seguimos con el resto de layouts.
java.awt
Class FlowLayout
 java.lang.Object

 java.awt.FlowLayout
 All Implemented Interfaces:
LayoutManager, Serializable
public class FlowLayout
extends Object
implements LayoutManager, Serializable

A flow layout arranges components in a directional flow, much like lines of text in a paragraph. The
flow direction is determined by the container's componentOrientation property and may be one
of two values:
 ComponentOrientation.LEFT_TO_RIGHT
 ComponentOrientation.RIGHT_TO_LEFT
Flow layouts are typically used to arrange buttons in a panel. It arranges buttons horizontally until no
more buttons fit on the same line. The line alignment is determined by the align property. The
possible values are:
 LEFT
 RIGHT
 CENTER
 LEADING
 TRAILING
For example, the following picture shows an applet using the flow layout manager (its default layout
manager) to position three buttons:
Here is the code for this applet:
import java.awt.*;
import java.applet.Applet;
public class myButtons extends Applet {
Button button1, button2, button3;
public void init() {
button1 = new Button("Ok");
button2 = new Button("Open");
button3 = new Button("Close");
add(button1);
add(button2);
add(button3);
}
}

A flow layout lets each component assume its natural (preferred) size.
Since:
JDK1.0
See Also:
ComponentOrientation, Serialized Form

 Field Summary
Fields
Modifier and Type Field and Description
static int CENTER
This value indicates that each row of components should be
static int LEADING
orientations.
static int LEFT
static int RIGHT
static int TRAILING
orientations.
 Constructor Summary
Constructors
Constructor and Description

FlowLayout()
Constructs a new FlowLayout with a centered alignment and a default 5-unit horizontal and vertical gap.
FlowLayout(int align)
Constructs a new FlowLayout with the specified alignment and a default 5-unit horizontal and vertical gap.
FlowLayout(int align, int hgap, int vgap)
Creates a new flow layout manager with the indicated alignment and the indicated horizontal and vertical gaps.
 Method Summary
Methods
Modifier and Type Method and Description
void addLayoutComponent(String name,
Adds the specified component to the layout.
int getAlignment()
Gets the alignment for this layout.
boolean getAlignOnBaseline()
Returns true if components are to be vertically aligned alon
int getHgap()
Gets the horizontal gap between components and between
int getVgap()
Gets the vertical gap between components and between th
void layoutContainer(Container targe
Lays out the container.
Dimension minimumLayoutSize(Container tar

Returns the minimum dimensions needed to layout the visi
Dimension preferredLayoutSize(Container t
Returns the preferred dimensions for this layout given the v
void removeLayoutComponent(Component
Removes the specified component from the layout.
void setAlignment(int align)
Sets the alignment for this layout.
void setAlignOnBaseline(boolean alig
Sets whether or not components should be vertically aligne
void setHgap(int hgap)
Sets the horizontal gap between components and between
void setVgap(int vgap)
Sets the vertical gap between components and between the
String toString()
Returns a string representation of this FlowLayout o
 Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, w
ait, wait, wait

 Field Detail
 LEFT
public static final int LEFT
This value indicates that each row of components should be left-justified.
See Also:

Constant Field Values
 CENTER
public static final int CENTER
This value indicates that each row of components should be centered.
See Also:
 RIGHT
public static final int RIGHT
This value indicates that each row of components should be right-justified.
See Also:
 LEADING
public static final int LEADING
This value indicates that each row of components should be justified to the leading edge of the container's
orientation, for example, to the left in left-to-right orientations.
Since:
1.2
See Also:
Component.getComponentOrientation(), ComponentOrientation, Constant
Field Values
 TRAILING
public static final int TRAILING
This value indicates that each row of components should be justified to the trailing edge of the container's
orientation, for example, to the right in left-to-right orientations.
Since:
1.2
See Also:
Component.getComponentOrientation(), ComponentOrientation, Constant
Field Values

 Constructor Detail
 FlowLayout
public FlowLayout()
Constructs a new FlowLayout with a centered alignment and a default 5-unit horizontal and vertical
gap.
 FlowLayout
public FlowLayout(int align)
Constructs a new FlowLayout with the specified alignment and a default 5-unit horizontal and vertical
gap. The value of the alignment argument must be one
of FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER,FlowLayout.LEADING,
or FlowLayout.TRAILING.
Parameters:
align - the alignment value
 FlowLayout
 public FlowLayout(int align,
 int hgap,
int vgap)
Creates a new flow layout manager with the indicated alignment and the indicated horizontal and vertical
gaps.
The value of the alignment argument must be one
of FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER, FlowLayout.L
EADING, or FlowLayout.TRAILING.
Parameters:
align - the alignment value
hgap - the horizontal gap between components and between the components and the borders of
the Container
vgap - the vertical gap between components and between the components and the borders of
the Container
 Method Detail
 getAlignment
public int getAlignment()

Gets the alignment for this layout. Possible values
are FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER, FlowLayout.LEADIN
G, or FlowLayout.TRAILING.
Returns:
the alignment value for this layout
Since:
JDK1.1
See Also:
setAlignment(int)
 setAlignment
public void setAlignment(int align)
Sets the alignment for this layout. Possible values are
 FlowLayout.LEFT
 FlowLayout.RIGHT
 FlowLayout.CENTER
 FlowLayout.LEADING
 FlowLayout.TRAILING
Parameters:
align - one of the alignment values shown above
Since:
JDK1.1
See Also:
getAlignment()
 getHgap
public int getHgap()
Gets the horizontal gap between components and between the components and the borders of
the Container
Returns:
the horizontal gap between components and between the components and the borders of
the Container
Since:

JDK1.1
See Also:
setHgap(int)
 setHgap
public void setHgap(int hgap)
Sets the horizontal gap between components and between the components and the borders of
the Container.
Parameters:
hgap - the horizontal gap between components and between the components and the borders of
the Container
Since:
JDK1.1
See Also:
getHgap()
 getVgap
public int getVgap()
Gets the vertical gap between components and between the components and the borders of
the Container.
Returns:
the vertical gap between components and between the components and the borders of
the Container
Since:
JDK1.1
See Also:
setVgap(int)
 setVgap
public void setVgap(int vgap)
Sets the vertical gap between components and between the components and the borders of
the Container.
Parameters:

vgap - the vertical gap between components and between the components and the borders of
the Container
Since:
JDK1.1
See Also:
getVgap()
 setAlignOnBaseline
public void setAlignOnBaseline(boolean alignOnBaseline)
Sets whether or not components should be vertically aligned along their baseline. Components that do not
have a baseline will be centered. The default is false.
Parameters:
alignOnBaseline - whether or not components should be vertically aligned on their baseline
Since:
1.6
 getAlignOnBaseline
public boolean getAlignOnBaseline()
Returns true if components are to be vertically aligned along their baseline. The default is false.
Returns:
true if components are to be vertically aligned along their baseline
Since:
1.6
 addLayoutComponent
 public void addLayoutComponent(String name,
Component comp)
Adds the specified component to the layout. Not used by this class.
Specified by:
addLayoutComponent in interface LayoutManager
Parameters:
name - the name of the component

comp - the component to be added
 removeLayoutComponent
public void removeLayoutComponent(Component comp)
Removes the specified component from the layout. Not used by this class.
Specified by:
removeLayoutComponent in interface LayoutManager
Parameters:
comp - the component to remove
See Also:
Container.removeAll()
 preferredLayoutSize
public Dimension preferredLayoutSize(Container target)
Returns the preferred dimensions for this layout given the visible components in the specified target
container.
Specified by:
preferredLayoutSize in interface LayoutManager
Parameters:
target - the container that needs to be laid out
Returns:
the preferred dimensions to lay out the subcomponents of the specified container
See Also:
Container, minimumLayoutSize(java.awt.Container), Container.getPref
erredSize()
 minimumLayoutSize
public Dimension minimumLayoutSize(Container target)
Returns the minimum dimensions needed to layout the visible components contained in the specified
target container.
Specified by:
minimumLayoutSize in interface LayoutManager

Parameters:
target - the container that needs to be laid out
Returns:
the minimum dimensions to lay out the subcomponents of the specified container
See Also:
preferredLayoutSize(java.awt.Container), Container, Container.doLay
out()
 layoutContainer
public void layoutContainer(Container target)
Lays out the container. This method lets each visible component take its preferred size by reshaping the
components in the target container in order to satisfy the alignment of this FlowLayout object.
Specified by:
layoutContainer in interface LayoutManager
Parameters:
target - the specified component being laid out
See Also:
Container, Container.doLayout()
 toString
public String toString()
Returns a string representation of this FlowLayout object and its values.
Overrides:
toString in class Object
Returns:
a string representation of this layout
JAVA: Practicando con GridLayout.
21032009

GridLayout, no es mas q otro manejador de disenio, la cual su partcularidad, conciste en crear
una matriz, totalmente configurada.
“setLayout()” asignarle el layout correspondiente:
frame.setLayout(new GridLayout(Filas, Columnas));
Tambien podemos indicar el espacio entre cada objeto de la matriz.
frame.setLayout(new GridLayout(Filas, Columnas,EspacioEntreFilas,
EspacioEntreColumnas));
Creoq con un ejemplo, se entenderia mejor.
PAra el ejemplo, he intentado, realizar una pantalla de calculadora…jejeje,
Aqui el fuente.
/*Demo hecho por INFORUX*/
import javax.swing.JPanel;
import java.awt.GridLayout;
import javax.swing.BoxLayout;
public class DemoGridLayout{
JFrame frame;
JPanel panelSuperior, panelInferior;
JButton bt1, bt2, bt3, bt4, bt5, bt6, bt7, bt8, bt9, bt0, btRT, btCE,
btCL, btMas, btMenos, btMul, btDiv, btIgual, btMN, btPunto;
JTextField pantalla;

public DemoGridLayout(){
construyePanelSuperior();
construyePanelInferior();
construyeVentana();}
void construyePanelSuperior(){
panelSuperior = new JPanel ();
panelSuperior.setLayout(new FlowLayout());
pantalla = new JTextField(20);
panelSuperior.add(pantalla);}
void construyePanelInferior(){
panelInferior= new JPanel();
panelInferior.setLayout(new GridLayout(5,4,8,8));
bt1=new JButton("1");
btRT=new JButton("Rtc");
btCE=new JButton("CE");
btCL=new JButton("CL");

btMas=new JButton("+");
btMenos=new JButton("-");
btMul=new JButton("x");
btDiv=new JButton("/");
btIgual=new JButton("=");
btMN=new JButton("+/-");
btPunto=new JButton(".");
panelInferior.add(btRT);
panelInferior.add(btCE);
panelInferior.add(btCL);
panelInferior.add(btMN);
panelInferior.add(bt7);
panelInferior.add(btDiv);
panelInferior.add(btMul);
panelInferior.add(btMenos);
panelInferior.add(btPunto);
panelInferior.add(btIgual);
panelInferior.add(btMas);}

void construyeVentana(){
frame =new JFrame("Calculadora ");
frame.setLayout(new
BoxLayout(frame.getContentPane(),BoxLayout.Y_AXIS));
frame.add(panelSuperior);
frame.add(panelInferior);
frame.pack();
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);}
public static void main(String [] inforux){
new DemoGridLayout();}
}
Una compilada, y ejecutamos.
javac DemoGridLayout.java
java DemoGridLayout
El resultado sera asi.

La idea, es manejar el GridLayout.
JAVA: Practicando con CardLayout
19032009
CardLayout, es un manejador de disenio que nos permite, ubicar componentes swing dentro de
un mismo contenedor, y poder visualizarlos solamente uno a la vez.
Este layout es usado por los JTabbedPane, con la diferencia de la separacion de los bordes de
cada panel.
Es decir, podemos tener un contenedor pricipal, y dentro de el, varios paneles, y atravez de una
seleccion, elegir cual de estos paneles queremos q se visualize.
“setLayout()” asignarle el layout correspondiente.
frame.setLayout(new CardLayout());
Una vez, asiganado el layout al contenedor, tendremos q agregar los componentes, plenamente
ya declarados y creados.
Para agregar necesitamos 2 argumentos, el objeto a agregar, y un nombre referencial al
elemento agregado
JPanel panel = new JPanel();

JPanel pane2 = new JPanel();
frame.add(panel, referenciaPanel1);
frame.add(pane2, referenciaPanel2);
Sencilo no?, espera, hay unos metodos basicos e importantes, al momento de manejar los
eventos, como son.
first (nombreContenedor) -> metodo q permite visualizar el primer objeto agregado
next (nombreContenedor) -> metodo q permite visuliza el objeto siguiente.
previous (nombreContenedor) -> permite visualizar el objeto anterior
show (nombreContenedor, referenciaPanel) -> permite visualizar un obejto especificado, aqui
necesitamos el nombre del contenedor y el nombre referencial asignado al momento de
agregarlo.
Para esta entrada he preparado un ejemplo clasico, para situaciones clasicas…jejee
La aplicacio, contiene, 1 JFrame principal, 1 PanelSuperior incluido en el JFrame,1 JComboBox
incluido en el PanelSuperior, 1 PanelInferior incluido en el JFrame, y 3 paneles incluidos en el
PanelInferior.
El ejemplo consciste en que atravez de un JComboBox, seleccionaremos un elemento de la lista,
y segun el elemento seleccionado, cambiara el panel inferior mostrando uno de los paneles
incluidos en el., es decir, el panel ira cambiando segun la seleecion del elemento de la lista del
JComboBox.
YA q en este ejericcio he utilizado manejo de eventos, he trabajado con 2 clases, la primera
(WindowCardLayout) es la interfaz de usuario y la segunda (ControlCardLayout) la q maneja los
eventos de la primera.
Aqui el fuente.WindowCardLayout
import javax.swing.JComboBox;
import javax.swing.BorderFactory;

import java.awt.CardLayout;
import java.awt.Color;
public class WindowCardLayout{
JFrame frame;
CardLayout cardLayout;
JPanel panelSuperior, panelInferior,panelInf1, panelInf2, panelInf3;
JLabel etiqueta, etiqueta1, etiqueta2,etiqueta3;
JComboBox combo;
String [] vectorCadena = {"panel1","panel2","panel3"};
public WindowCardLayout(){/*Constructor*/
construyePanelInf1();
construyeVentana();}
public void construyePanelSuperior(){
etiqueta = new JLabel("Elegir Opcion");
panelSuperior=new JPanel();
panelSuperior.setBorder(BorderFactory.createTitledBorder("Demo por
INFORUX"));
combo = new JComboBox(vectorCadena);
panelSuperior.setLayout(new FlowLayout());
panelSuperior.add(etiqueta);

panelSuperior.add(combo);
panelSuperior.getPreferredSize();}
public void construyePanelInferior(){
panelInferior= new JPanel();
panelInferior.setBorder(BorderFactory.createTitledBorder("Panel
Inferior"));
cardLayout=new CardLayout();
panelInferior.setLayout(cardLayout);
/*Al agregar necesitamos 2 argumentos, el objeto a agregar y un nombre
referencial */
panelInferior.add(panelInf1, "panel1");
panelInferior.add(panelInf2, "panel2");
panelInferior.add(panelInf3, "panel3");}
public void construyePanelInf1(){
etiqueta1 = new JLabel("Has Seleccionado el Panel 1");
panelInf1 = new JPanel(new FlowLayout());
panelInf1.setBackground(Color.white);
panelInf1.add(etiqueta1);}
etiqueta2 = new JLabel("increiblemente estas viendo el panel2");
panelInf2.setBackground(Color.orange);
etiqueta3 = new JLabel("CardLayout permite solo uno a la vez, esta vez
el panel 3");

panelInf3.setBackground(Color.green);
frame= new JFrame();
frame.setLayout(new
BoxLayout(frame.getContentPane(),BoxLayout.Y_AXIS));
frame.getPreferredSize();
frame.pack();
//creamos el objeto controlador de eventos
ControlCardLayout control= new ControlCardLayout(this);
combo.addActionListener(control);}
public static void main (String [] inforux){
new WindowCardLayout();
}
}
Aqui el fuente ControlCardLAyout
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class ControlCardLayout implements ActionListener{

WindowCardLayout ventana;
public ControlCardLayout( WindowCardLayout frame){
ventana = frame ;}
public void actionPerformed (ActionEvent evento){
if (evento.getSource()==ventana.combo){
if (ventana.combo.getSelectedIndex()==0){
ventana.cardLayout.show(ventana.panelInferior, "panel1");}
ventana.cardLayout.show(ventana.panelInferior, "panel2");}
ventana.cardLayout.show(ventana.panelInferior, "panel3");}}
}
}
Listo una compilada y ejecutamos
$ javac WindowCardLayout.java
$ java WindoCardLayout

El resultado sera asi:
JAVA: Practicando con BorderLayout
20012009
Seguimos con los layouts. Recordar que para entender este ejemplo es necesario chekear las
anteriores explicaciones sobre FlowLayout yBoxLayoutLayout
BorderLayout, es un layout que ubica los componentes en cualquiera de sus 5 regiones que
tiene..
Un componente podemos ubicarlo arriba, abajo, izquierda o a la derecha.

Para establecer a BorderLayout como manegador de Disenio,
frame.setLayout(new BorderLayout());
Luego para agregar los componentes
frame.add(etiqeuta, BorderLayout.CENTER);
frame.add(botonIzquierdo,BorderLayout.WEST);
frame.add(botonDerecho,BorderLayout.EAST);
frame.add(cajaTexto,BorderLayout.NORTH);
frame.add(panelInferior,BorderLayout.SOUTH);
No es obligatorio, llenar todas las regiones, en el caso de existir alguna region sin
componente, esta region visiblemente se anulara, es importante esto, ya que si enviamos un
componente al centro, y no enviamos nada en la parte izquierda(WESTH), entonces, el
componente enviado al centro se visaluizara en la parte WESTH.
En el ejemplo siguiente se tiene, un JFrame, este mismo los ordenara atravez de un
BorLayout, En el norte, ira una JLabel, en el centro un JTextAre, y en el sur, este y el oeste un
panel para cada region.
Cada panel, ubicara sus componentes de la forma que noosotros queramos, en este caso el del
sur, atravez de un flowLayout, y el de este y oeste con un BoxLayout.
Aqui el demo

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
public class DemoBorderLayout {
//variables y comtenedores
private JLabel etiquetaSu;
private JPanel panelIzquierdo, panelDerecho, panelInferior;
private JButton botonIz1, botonIz2, botonIz3;
private JButton botonDe1, botonDe2, botonDe3;
private JButton botonIn1, botonIn2;
private JScrollPane scroll;
public void contruyePanelIzquierdo(){
panelIzquierdo = new JPanel();
botonIz1=new JButton("Izq1");

panelIzquierdo.setLayout(new
BoxLayout(panelIzquierdo,BoxLayout.Y_AXIS));
panelIzquierdo.setBackground(Color.red);
panelIzquierdo.add(botonIz1);
}
public void contruyePanelDerecho(){
panelDerecho = new JPanel();
botonDe1=new JButton("Der1");
panelDerecho.setLayout(new BoxLayout(panelDerecho,BoxLayout.Y_AXIS));
panelDerecho.setBackground(Color.blue);
panelDerecho.add(botonDe1);
}
public void contruyePanelInferior(){
panelInferior = new JPanel();
botonIn1=new JButton("Aceptar");
botonIn2=new JButton("Cancelar");
panelInferior.setLayout(new FlowLayout());
panelInferior.setBackground(Color.green);
panelInferior.add(botonIn1);
panelInferior.add(botonIn2);

}
public void contruyeVentana(){
scroll = new JScrollPane(new JTextArea("JTextArea",10,15));
etiquetaSu = new JLabel("Demostracion por INFORUX ");
Font aux=etiquetaSu.getFont();
etiquetaSu.setFont(new Font(aux.getFontName(), aux.getStyle(), 20));
frame.setLayout(new BorderLayout());
//agregamos los paneles al frame principal
frame.add(etiquetaSu,BorderLayout.NORTH);
frame.add(scroll, BorderLayout.CENTER);
frame.add(panelIzquierdo,BorderLayout.WEST);
frame.add(panelDerecho,BorderLayout.EAST);
frame.add(panelInferior,BorderLayout.SOUTH);
//Configuramos el frame
frame.pack();
}
public DemoBorderLayout(){
contruyePanelInferior();
contruyePanelIzquierdo();
contruyePanelDerecho();
contruyeVentana();
}

new DemoBorderLayout();
}
}
Compilamos y ejecutamos.
$javac DemoBorderLayout.java
$java DemoBorderLayout
El resultador ser asi

En esta interfaz de usuario, solo se empleo los layouts, explicados FlowLayout, BoxLayout y
BorderLayout.
Sencillo.
JAVA: Practicando con BoxLayout
20012009
BoxLayout, es un Layout recontra parecido al FlowLayout, cual es la diferencia? es simple,
FlowLayout ubica todos los componentes solo de forma horizontal, mientras que BoxLayout los
ubica, tanto horizontal como vertical.
Para crear una clase BoxLayout, necesitamos 2 argumentos: el objeto contenedor, y la clase que
indica la forma de como ordenara los componetes,.
BoxLayout.X_AXIS —– Forma Horizontal
BoxLayout.Y_AXIS —– Forma Vertical
frame.setLayout(new BoxLayout(frame,BoxLayout.X_AXIS));
Luego para agregar los componentes es simple, lo mismo como hicimos con FlowLayout.
JButton boton = new JButton("Aceptar");
frame.add(boton);
Aqui tengo un ejemplo, sobre una clasica ventana de logueo, cabe destacar q para este ejemplo
demostrativo, solo me limite a usar BoxLayout.
La idea general, es crear un JFrame geeneral, el cual tendra 3 paneles y una etiqueta,
Estos estaran ordenados con BoxLayout en forma vertical.
Cada panel tendran cajas de textos y etiquetas. Estos estaran ordenados con BoxLayout en
forma horizontal.

import javax.swing.JPasswordField;
public class DemoBoxLayout{
private JPanel panelSuperior, panelMedio, panelInferior;
private JLabel etiqueta1, etiqueta2, etiqueta3;
private JTextField cajaTexto;
private JPasswordField cajaPass;
private JButton botonAceptar, botonCancelar;
private JFrame frame;
public void construyePanelSuperior(){
panelSuperior =new JPanel();
etiqueta2= new JLabel("Usuario");
cajaTexto = new JTextField(10);
panelSuperior.setLayout(new BoxLayout(panelSuperior,
BoxLayout.X_AXIS));
panelSuperior.add(etiqueta2);
panelSuperior.add(cajaTexto);
}
public void construyePanelMedio(){
panelMedio=new JPanel();
etiqueta3= new JLabel("Password");
cajaPass = new JPasswordField(10);
panelMedio.setLayout(new BoxLayout(panelMedio, BoxLayout.X_AXIS));
panelMedio.add(etiqueta3);
panelMedio.add(cajaPass);
}

public void construyePanelInferior(){
panelInferior=new JPanel();
botonAceptar=new JButton("Aceptar");
botonCancelar=new JButton("Cancelar");
panelInferior.setLayout(new BoxLayout(panelInferior,
BoxLayout.X_AXIS));
panelInferior.add(botonAceptar);
panelInferior.add(botonCancelar);
}
frame = new JFrame();
etiqueta1 = new JLabel("Demo por inforux");
frame.setLayout(new BoxLayout(frame.getContentPane(),
BoxLayout.Y_AXIS) );
frame.add(etiqueta1);
frame.add(panelMedio);
frame.pack();
}
public DemoBoxLayout(){
construyePanelMedio();

construyeVentana();
}
new DemoBoxLayout();
}
}
Compilamos y ejecutamos
$javac DemoBoxLayout.java
$java DemoBoxLayout
El resultado final sera:
Para esta interface de usuario, solo se limito a usar BoxLayout, ya q es un ejemplo demostrativo.
Aprendiendo con JFileChooser …
Parte 1
6082008
JFileChooser es un componente JAVA, que nos permite selecionar y/o grabar cualquier archivo
basicamente dentro de nuestro ordenador, en este oportunidad fijaremos la antencion en la
funcion de “Seleccion o Abrir”

El ejemplo demostracion trata sobre: “Selecionar un archivo imagen (.jpg, .gif, .png) y luego
tendremos q visualizar dicha imagen” aqui la ventana ilustrativa.
Lo Primero q tendremos q hacer es dibujar nuestra interface grafica de usuario(GUI) en este caso
“WindowDemoFile”, lo unico nuevo en esta clase es el “JFileChooser”
public JFileChooser jfcExaminarEntrada;
jfcExaminarEntrada = new JFileChooser();
Esta demas decir q la imagen se visualizara dentro de un “JDesktopPane”, aqui en fuente:
import javax.swing.*;
public class WindowDemoFile extends JFrame {
public WindowDemoFile() {
initComponents(); }
private void initComponents() {

setTitle("DEMO POR INFORUX");
setResizable(false);
jfcExaminarEntrada = new JFileChooser();
jPanel1 = new JPanel();
jtfRutaEntrada = new JTextField();
jbExaminar = new JButton();
jbLoad = new JButton();
jDesktopPane1 = new JDesktopPane();
setDefaultCloseOperation( WindowConstants.EXIT_ON_CLOSE);
getContentPane().setLayout(null);
jPanel1.setBorder( BorderFactory.createTitledBorder("Ubica el Archivo
Imagen"));
jPanel1.setLayout(null);
jPanel1.add(jtfRutaEntrada);
jtfRutaEntrada.setBounds(20, 30, 350, 19);
jbExaminar.setText("...");
jPanel1.add(jbExaminar);
jbExaminar.setBounds(400, 30, 50, 25);
jbLoad.setText("load");
jPanel1.add(jbLoad);
jbLoad.setBounds(460, 30, 70, 25);
getContentPane().add(jPanel1);
jPanel1.setBounds(30, 30, 550, 70);

jPanel3.setBorder( BorderFactory.createTitledBorder("Imagen
Cargada"));
jPanel3.add(jDesktopPane1);
jDesktopPane1.setBounds(20, 30, 530, 340);
java.awt.Dimension screenSize =
java.awt.Toolkit.getDefaultToolkit().getScreenSize();
setBounds((screenSize.width-618)/2, (screenSize.height-542)/2, 618,
542);
/*declaramos una referencia a nuestra clase control de
eventos*/
ControlaEventos controlaEventos =new ControlaEventos (this);
jbExaminar.addActionListener(controlaEventos);
jbLoad.addActionListener(controlaEventos);
}
public static void main(String args[]) {
new WindowDemoFile().setVisible(true); }
public JFileChooser jfcExaminarEntrada;
public JButton jbExaminar;
public JButton jbLoad;
public JDesktopPane jDesktopPane1;
public JPanel jPanel1;

public JTextField jtfRutaEntrada;
}
La segunda clase es de nombre “ControlaEventos”, su mismo nombre lo dice, controla todos los
eventos producidos por el usuario. solo controlaremos los 2 botones con nombres q muestran
“…” y “load”.
La novedad de esto, es q al producirse el evento en el boton q llama al “JFileChoose”. este
mostrara un dialogo y dentro de el, estara el componente. Para decirle cual de lo 2 tipos (open
y/o save), utilizamos los metodos showOpenDialog o showSaveDialog, segun nuestras
necesidades.
int result = d.showOpenDialog(ventana para seleccionar un archivo);
int result =d.showSaveDialog(ventana para guardar un archivo);
donde “d” es el frame, internalFrame, mejro dicho es la ventana donde se sobrepondra, ademas
esta llamada no entrega nada hasta que el usuario ha aceptado un archivo o cancelado la
entrada de ldialogo. El valor de retorno es:
JFileChooser.APROVE_OPTION (si haces click en entrar o gravar)
JFileChooser.CANCEL_OPTION. ( si hay evento en el boton cancelar del JFileChooser.)
Aqui el fuente:
import java.awt.event.*;
import java.io.File;
import java.awt.image.BufferedImage;
import javax.imageio.ImageIO;
public class ControlaEventos implements ActionListener{
WindowDemoFile ventana;
File fileImagen;
public ControlaEventos(WindowDemoFile objeto){
ventana = objeto;
}
public void actionPerformed(ActionEvent evento)
{
if (evento.getSource()==ventana.jbExaminar){//si hay evento
en el boton examinar

int returnVal =
ventana.jfcExaminarEntrada.showOpenDialog(ventana);//mostramos el jFileChooser
if (returnVal ==
ventana.jfcExaminarEntrada.APPROVE_OPTION) {//nos aseguramos q haya
selecionado algun archivo
fileImagen =
ventana.jfcExaminarEntrada.getSelectedFile();//obtenemos el archivo
selecionado
ventana.jtfRutaEntrada.setText(fileImagen.toString());
}}//mostramos la ruta del archivo en la caja de texto
if (evento.getSource()==ventana.jbLoad){//si hay evento en el
boton load
if ( fileImagen != null) {
cargarImagen(ventana.jDesktopPane1,fileImagen);}}
}
/*este metodo recibe el jdeskopPane y el archivo imagen*/
public void cargarImagen(javax.swing.JDesktopPane jDeskp,File
fileImagen)
{
try{
BufferedImage image = ImageIO.read(fileImagen);
jDeskp.setBorder(new PintaImagen(image)); }
catch (Exception e){ System.out.println("No cargo imagen, sorry");
}
}
}
La ultima clase, es la misma a la entrada anterior, ahy se explica la clase “PintaImagen”
de todas formas aqui el fuente:
import java.awt.Component;
import java.awt.Graphics;

import java.awt.Insets;
import javax.swing.border.Border;
public class PintaImagen implements Border{
private BufferedImage image ;
public PintaImagen(BufferedImage image ) {
this.image=image;}
public void paintBorder(Component c, Graphics g, int x, int y, int
width, int height) {
int x0 = x+ (width-image.getWidth())/2;
int y0 = y+ (height-image.getHeight())/2;
g.drawImage(image,x0,y0,null); }
public Insets getBorderInsets(Component c) {
return new Insets(0,0,0,0);}
public boolean isBorderOpaque() {
return true; }
}
Atravez de esta clase convertirlos el “File” a una imagen para pintarse en un JDesktopPane.
Aqui el pantallazo

Como ven. no es complicado mostrar un jFileChooser, solo una simple linea lo haces
Aprendiendo con JComboBox…
Parte 2
2082008
JComboBox, es un componente swing, y como tal, podemos crear nuestro propio modelo de
datos al momento de crear y manipular a este componente(en este caso: jComboBox). Puedes
leer MVC en Java para darte la idea general.
En este caso, el ejercicio intenta mostrar la forma sencilla al momento de implementar nuestro
propio Modelo de datos para un componente JComboBox.
El ejercicio consiste, en una tipica “barra de direcciones de un navegador”, ingresas la direccion,
entras a la pagina, luego el navegador comprueba si existe la direccion,en el caso de no existir,
agrega la direccion de la pagina a la barra de direcciones, para un posterior facil acceso.

Bien, para este ejercicio implementaremos 3 clase. la vista(WindowDemoEditaCombo), el
control(ControlDemoEditaCombo), y el Modelo del JComboBox (ModeloCombo).
WindowDemoEditaCombo, esta es la clase, que dibuja los componentes swing; En este caso para
crear un JComboBox, necesario primero crear nuestro modelo, el cual recibe una cadena de
caracteres, los mismos que seran mostrados como items en el combo.
String [] urls = {"www.java.com","inforux.wordpress.com","www.debian.com"};
modeloCombo = new ModeloCombo(urls);
jComboBox1 = new JComboBox(modeloCombo);
Aqui el fuente de la vista(la clase WindowDemoEditaCombo).
public class WindowDemoEditaCombo extends javax.swing.JFrame {
public WindowDemoEditaCombo() {/*el constructor de la clase*/
initComponents();}
jLabel2 = new JLabel();
modeloCombo = new ModeloCombo(urls);//creamos nuestro modelo del Combo
jComboBox1 = new JComboBox(modeloCombo);//creamos el jComboBox, le
enviamos el modelo.
jComboBox1.setEditable(true);//le decimos q sea editable
jComboBox1.setSelectedIndex(0);
jTextField1 = new JTextField();
jTextField1.setEditable(false);//le decimos q sea NO editable
jButton1 = new JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Aprendiendo
con JComboBox2"));
jLabel2.setText("Direccion Web:");
jPanel1.add(jLabel2);
jLabel2.setBounds(10, 40, 110, 20);
jPanel1.add(jComboBox1);
jComboBox1.setBounds(110, 40, 230, 24);
jPanel1.add(jTextField1);
jTextField1.setBounds(60, 80, 350, 19);
jButton1.setText("Go");
jPanel1.add(jButton1);
jButton1.setBounds(350, 40, 70, 25);
jLabel1.setText("DEMO POR INFORUX");
getContentPane().add(jLabel1);

190);
/*Creamos el objeto controlador de eventos de esta clase*/
ControlDemoEditaCombo controlDemoEditaCombo = new
ControlDemoEditaCombo(this);
jComboBox1.addActionListener(controlDemoEditaCombo);
jButton1.addActionListener(controlDemoEditaCombo);
}
new WindowDemoEditaCombo().setVisible(true);}
// declaramos las variables a usar en la ventana
public String [] urls = {"Escriba o
Selecione","www.java.com","inforux.wordpress.com","www.debian.com"};//creamos
el array, q sera enviado a nuestro propio modelo.
ModeloCombo modeloCombo;//Declaramos nuestro modelo
public JButton jButton1;
public JComboBox jComboBox1;
private JLabel jLabel1;
private JPanel jPanel1;
public JTextField jTextField1;
}
ControlDemoEditaCombo, es la clase controladora de los eventos q generara el usuario con la
aplicacion. por tal motivo implementa los metodos de las clases ActionListener..
Aqui el fuente:
public class ControlDemoEditaCombo implements ActionListener{

WindowDemoEditaCombo frame;
/*el constructor de la clase*/
public ControlDemoEditaCombo(WindowDemoEditaCombo objeto){
frame=objeto;//recibe el objeto a controlar
}
{
if (evento.getSource()==frame.jButton1 ||
evento.getSource()==frame.jComboBox1)
{
String
cadenaSelecionada=frame.modeloCombo.getSelectedItem().toString();
frame.jTextField1.setText("Direccion Web:
"+cadenaSelecionada);//muestra en l jTextFile lo selecionado
if (frame.modeloCombo.buscaItem(cadenaSelecionada)== false)
frame.modeloCombo.agregaItem(frame.jComboBox1.getSelectedItem().toStri
ng());
}
}
}
ModeloCombo, es la clase modelo del componente JComboBox. cualquier cambio realizado en
dicha clase, se vera reflejado en el componente JComboBox.
Para crear esta clase, hayq tener en cuenta q sera una clase abstracta, es decir, no sabra en q
componente se vera reflejado, ademas esta misma debera heredar de la clase
“AbstracListModel”.
Porq heredar de AbstracListModel? .- Sencillamente porque accedesmo a los metodos mas
generales, y nos permite implementar metodos propios, segun nuestras necesidades.
Tambien debera implementar algunos metodos de la clase ComboBoxModel,

Porq implemenar algunos metodos de la clase ComboBoxModel? .- Porq el componente swing es
un JComboBox. y es un componente algo especial, ya q es una combinacion de listas con
botones, ademas para acceder a los metodos “getSelectedItem()” y “setSelectedItem()”.
En nuestro caso, aparte de los metodos implementados de la clase ComboBoxModel, hemos
codificado algunos metodos adicionales, segun la necesidad del ejercicio.
Aqui el fuente:
import javax.swing.AbstractListModel;
import javax.swing.ComboBoxModel;
class ModeloCombo extends AbstractListModel implements ComboBoxModel{
boolean loEncontro;
String [] items = null;//cadena q recibira los datos a mostrar.
String itemSelecionado=null;
public ModeloCombo (String [] vector){
items = vector;
}
public Object getElementAt(int index) {
return items[index];
}
public int getSize() {
return items.length;
}
public void setSelectedItem(Object item) {
itemSelecionado = (String) item;
fireContentsChanged(this, -1, -1);
}

public void agregaItem(String cadena){
String [] nuevoItems= new String [items.length+1];
for (int i=0;i<items.length;i++)
nuevoItems[i]=items[i];
nuevoItems[items.length]=cadena;
items=nuevoItems;
fireContentsChanged(this, -1, -1);
}
public boolean buscaItem(String itemABuscar){
for(int i=0;i<items.length;i++){
if (itemABuscar==items[i]){
loEncontro=true;
break;}
else {
loEncontro=false;}
}
return loEncontro;
}
public Object getSelectedItem() { //metodo implementado por la interface
JComboBoxModel
return itemSelecionado;
}
}
Bien, una compilada, y listo.
$javac WindowDemoEditaCombo.java
$java WindowDemoEditaCombo

Listo, aqui algunos pantallazos:
La idea de esta entrada, es mostrar la eficacia q tenemos si es que nos animamos a implementar
nuesto propio modelo de datos para los componentes swing.
Espero les sirva a mas de uno.
Modelo – Vista – Controlador (MVC)
para tus Aplicaciones JAVA
2082008
Desde hace mucho tiempo, es que utilizo MVC para mis aplicaciones JAVA. y en esta ocacion
tratare de mostrarle con plabras sencillas, “La idea general del MVC”.
MVC (Modelo-Vista-Controlador), en palabras simples, es la forma(Patron de Disenio) que
utilizamos los programadores para implementar nuestras aplicaciones, ademas permite separar
nuestra aplicacion en un modelo, una vista y con controlador. este patron fue introducido por
primera vez en el lenguaje “Smalltalk”.
3 tipos de entidades, cada una especialida en su tarea.

Modelo:
Es el encargo de administrar la logica de tu aplicacion. tiene como finalidad servir de
abstracccion de algun proceso en el mundo real, ademas tiene acceso a nuestra Base de Datos,
agregando q tiene las funciones que controlan la integridad del sistema.
Vista
Sencillamente es la representacion visual del modelo. Es la encargada de representar los
componentes visuales en la pantalla, Esta asociada a un Modelo, esto le permite que al momento
de cambiar el Modelo, la vista redibujara la parte efectada para reflejar los cambios.
Controlador
Es el escuchador a los eventos que genere el usuario, es decir es el que permite que interactuen
el usuario con el sistema. Interpreta los eventos (la entradas) atravez del teclado y/o raton.
Por que usar MVC?
Porque fue diseñada para reducir el esfuerzo al momento de programar. Ademas porque permite
una clara separación entre los componentes de un programa; lo cual nos permite
implementarlos por separado.
Permite el trabajo en equipo.
Java implementa MVC?
Con decir, que la mayoria de los componentes SWING, han tomado como patron de Disenio a
MVC , esto es una gran ventaja para los programadores, porque nos permite implementar
nuestro PROPIO modelo de datos para cada componente swing.
Sin embargo es bueno recordar que El modelo original MVC prescribía un alto acoplamiento
entre controladores y vistas.
Por que es recomendable tener nuestro Propio Modelo de Datos para nuestros Compoonentes
Swing?
Swing se basa en un modelo MVC, donde la mayor parte de componentes de interfaz (JTable,
JList, JComboBox, etc.) tienen un modelo de datos por defecto. Si nos limitamos a usar el modelo
propio estaremos utilizando los modelos por defecto de Swing. y obviamente estos modelos
utilizan la clase java.util.Vector para el almacenamiento de los datos lo que provocará que
nuestros interfaces pierdan ahorro de recursos.
Por otro lado, mvc nos permite utilzar de la forma que queramos a cualquier componente swing
con tan solo implementar nuestro propio modelo. es decir nos ofrece la posibilidad de trabajar
con componentes más eficientes .
Espero haya quedado la idea general, de implementar nuestras aplicaciones tomando como
patron de disenio a MVC.

Imagenes en JAVA en
un JDesktopPane.
22072008
Imagenes en java, es quiza algo muy tedioso. sin embargo, existe formas muy practicas, de
como poner una imagen de fondo a tu aplicacion atravez de un JDesktopPane.
Por eso en esta oportunidad mostrare un ejemplo de seleciones de imagenes dentro de un
JDesktopPane,
La idea general es impleementar 3 clases(WindowImagenes, ControlaEventos, PintaImagen). La
primera clase(WindowImagenes.java) es la interactua con el usuario, mejro dicho la ventana. La
segunda clase(ControlaEventos.java), como su mismo nombre, es la encargada de controlar las
acciones ocurridas en la ventana. La tercera clase(PintaImagen.java), es la clase que me permite
pintar la imagen en algun como componente java (en este caso jDesktopPane).
La primera clase(WindowImagenes), creamos objetos del tipo “File” y le damos la ruta de nuestra
imagen.
public File imagen1 = new File ("Images/java.png");
Aqui el fuente de WindowImagenes.java

public class WindowImagenes extends JFrame {
public WindowImagenes() {
initComponents();
}
buttonGroup1 = new ButtonGroup();
jRadioButton1 = new JRadioButton();
jDesktopPane1 = new JDesktopPane();
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
setTitle("http://inforux.wordpress.com");
jPanel1.setBorder(BorderFactory.createTitledBorder("Selecione la
Imagen"));
jRadioButton1.setText("Imagen 1");
jPanel1.add(jRadioButton1);
jRadioButton1.setBounds(30, 20, 83, 23);

/*agregamos al ButtonGroup los JRadioButtons*/
buttonGroup1.add(jRadioButton1);
jPanel2.setBorder(BorderFactory.createTitledBorder("Imagen en el
JDesktopPane"));
jPanel2.add(jDesktopPane1);
jDesktopPane1.setBounds(20, 30, 390, 270);

493);
ControlaEventos controlaEventos =new ControlaEventos(this);
jRadioButton1.addActionListener(controlaEventos);
}
new WindowImagenes().setVisible(true); }
public File imagen1 = new File ("Images/java.png");
public File imagen2 = new File ("Images/JavaAnimado.gif");
public File imagen3 = new File ("Images/JavaLoro.jpg");
public JRadioButton jRadioButton1;
private ButtonGroup buttonGroup1;
public JDesktopPane jDesktopPane1;
}
La segunda clase,recibe un objeto de la clase q controlara(en este caso WindowImagenes),
ademas manejara todos los eventos realizados en la ventana. Por otro lado implementara el
metodo “cargarImagen()”, el cual recibe, un JDesktopPane, y el archivo Imagen, luego atravez de
la clase ImageIO, podremos leer el archivo, como archivo imagen. para luego agregarlo al
jDesktopPane con el metodo “setBorder()”

jDeskp.setBorder(new PintaImagen(image));
Aqui el fuente de ControlaEventos.java
import javax.imageio.ImageIO;
public class ControlaEventos implements ActionListener{/*clase escuchadora de
nuestra vista*/
WindowImagenes ventana;/*declaramos un objeto de la clase WindowImagenes*/
public ControlaEventos(WindowImagenes objeto){
ventana = objeto;
}
{
if (evento.getSource()== ventana.jRadioButton1)
cargarImagen(ventana.jDesktopPane1,ventana.imagen1);
else {
else {
}
}
}
/*este metodo recibe el jdeskopPane y el archivo imagen*/
public void cargarImagen(javax.swing.JDesktopPane jDeskp,File fileImagen)
{
try{

jDeskp.setBorder(new PintaImagen(image)); }
catch (Exception e){ System.out.println("No cargo imagen, sorry");
}
}
}
La ultima clase(PintaImagen.java), es la permite preparar la imagen para ser agregados a un
componente en este caso del tipo JDesktopPane, esta debera implementar de la Clase Border,
obligandonos a llamar a 3 metodos “paintBorder()”, “getBorderInsets()” y “isBorderOpaque()”.
Aqui el fuente:
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Insets;
import javax.swing.border.Border;
public class PintaImagen implements Border{
private BufferedImage image ;
public PintaImagen(BufferedImage image ) {
this.image=image;}
public void paintBorder(Component c, Graphics g, int x, int y, int width,
int height) {
int x0 = x+ (width-image.getWidth())/2;
int y0 = y+ (height-image.getHeight())/2;
g.drawImage(image,x0,y0,null); }
public Insets getBorderInsets(Component c) {

return new Insets(0,0,0,0);}
public boolean isBorderOpaque() {
return true; }
}
Luego, compilamos, sin antes asegurarnos de haber dado la ruta correcta del directotio de
carptas para los obejros “File” en la clase WindowImagenes
$jjavac WindowImagenes.java
Listo, aqui los pantallazos:

Espero les sirva a mas de uno.
Aprediendo con JCheckBox
y JRadioButton
21072008
Existen componentes en java, que nos permiten SELECCIONAR SOLOMENTE UNA OPCION ENTRE
VARIAS, a estos componentes en java, le denominamosJRadioButton, otros componentes que nos
permiten SELECCIONAR VARIAS OPCIONES ENTRE MUCHAS, en java les llamamos JCheckBox.
En esta oportunidad, para aprender a usar estos 2 componentes, tenemos un ejemplo:
“El ejemplo trata sobre la compra de un ordenador (Portatil o de Escritorio), luego, tendremos la
opcion de agregarle algunos accesioros mas(memoria usb, y ariculares)”

La imagen mostrada es la ventana de interfaz de usuario.
En este caso, se ha implementado solamente 2 (dos) clases (Window y ControlaWindow). la
primera(Window) es la UI(interfaz de usuario), en otras palabras la ventana dibujando los
conponentes(jTextfile, jLabel,jCheckBox, etc), la segunda clase(ControlaWidow), es la encarga de
gestionar todos los eventos de la primera, ademas de ejecutar algunas acciones(como sumar y
restar)
Ahora Entramos a implementar la primera clase(Window.java), un detalles es que para crear
los JRadiobutton, es necesario crear, un ButtonGroup que es un componente que agrupa
varios JRadiobutton con la finalidad de que todos los JRadiobuttonincluidos en el ButtonGroup
esten enlazados, de tal forma q solo uno a la vez se puede seleccionar.
ButtonGroup grupoDeBotones = new ButtonGroup();
JRadioButton jrb1 = new JRadioButton();
JRadioButton jrb2 = new JRadioButton();
grupoDeBotones.add(jrb1);
grupoDeBotones.add(jrb2);
Por otro lado en la clase Window, hay q crear un objeto de la clase de controlara todos sus
eventis, en este caso de ControlaWindow.
ControlaWindow controlawindow = new ControlaWindow();
Aqui en fuente de Window.java:
public class Window extends JFrame {
/*Demo por inforux*/
public Window() {
initComponents();
}
public void initComponents() {
grupoDeBotones = new ButtonGroup();
jrbCP = new JRadioButton();
jrbCE = new JRadioButton();

jchkUsb = new JCheckBox();
jchkAur = new JCheckBox();
jtfTotal = new JTextField();
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
setTitle("http://inforux.wordpress.com");
jPanel1.setBorder(BorderFactory.createTitledBorder("Seleccione
Equipo"));
jrbCP.setText("Comp. Portatil ( $ 1000 )");
jPanel1.add(jrbCP);
jrbCP.setBounds(10, 23, 200, 30);
jrbCE.setText("Comp. de Escritorio ( $ 800 )");
jPanel1.add(jrbCE);
jrbCE.setBounds(210, 23, 220, 30);

jPanel2.setBorder(BorderFactory.createTitledBorder("Agregados
Opcionales"));
jchkUsb.setText("Usb 2 gb ( $.20 )");
jPanel2.add(jchkUsb);
jchkUsb.setBounds(10, 20, 160, 23);
jchkAur.setText("Auriculares ( $.30 )");
jPanel2.add(jchkAur);
jchkAur.setBounds(10, 50, 170, 23);
jPanel4.setBorder(BorderFactory.createTitledBorder("Precio Total"));
jLabel2.setText("$.");
jPanel4.add(jtfTotal);
jtfTotal.setBounds(60, 20, 100, 20);

/*agregamos los JRadioButton al ButtonGroup*/
grupoDeBotones.add(jrbCE);
grupoDeBotones.add(jrbCP);
252);
/*Creamos un objeto controlador de esta clase*/
ControlaWindow controlaWindow = new ControlaWindow(this);
/* y luego los agregamos al objeto creado*/
jchkAur.addActionListener(controlaWindow);
jchkUsb.addActionListener(controlaWindow);
jrbCE.addActionListener(controlaWindow);
jrbCP.addActionListener(controlaWindow);
}
new Window().setVisible(true);}
// declaramos las variables de los componentes
public ButtonGroup grupoDeBotones;
public JLabel jLabel2;
public JCheckBox jchkAur;

public JCheckBox jchkUsb;
public JRadioButton jrbCE;
public JRadioButton jrbCP;
public JTextField jtfTotal;
}
La segunda clase, solo se dedicara a manejar los eventos de la ventana, ademas de realizar
algunas operacines del ejecicio.
Aqui el fuente:
public class ControlaWindow implements ActionListener{/*clase escuchadora de
nuestra vista*/
Window ventana;/*declaramos un objeto del tipo window*/
int aur=30,usb=20,cp,ce,total=0;/*declaramos e instanciamos nuestras
variables*/
public ControlaWindow(Window objeto){
ventana = objeto;
}
{
if (evento.getSource()== ventana.jchkAur){/*escuchamos el evento en
auriculares*/
if (ventana.jchkAur.isSelected()){/*nos aseguramos q esta
chekeado*/
total=total+aur;
ventana.jtfTotal.setText(Integer.toString(total));}
else {/*si no esta chekeado*/
total=total-aur;
ventana.jtfTotal.setText(Integer.toString(total));} }

else {
if (evento.getSource()== ventana.jchkUsb){/*escuchamos el evento en
usb*/
if (ventana.jchkUsb.isSelected()){/*nos aseguramos q esta
chekeado*/
total=total+usb;
else {/*si no esta chekeado*/
total=total-usb;
ventana.jtfTotal.setText(Integer.toString(total));} }
else {
if (evento.getSource()== ventana.jrbCE){/*escuchamos el evento en
comp. escritorio*/
total=total-cp; ce=800;
total=total+ce;
else {
if (evento.getSource()== ventana.jrbCP){/*escuchamos el evento en
comp. portatil*/
total=total-ce; cp=1000;
total=total+cp;
}} }
}
}
Luego, tendremos q compilar la clase Window.java
$javac Window.java
Listo podremos ver el ejemplo en ejecuccion, aquialgunos pantallazos para q ilustren el ejemplo

Espero les sirva de ayuda.
Una Pantalla Cargando con Imagen
para mi Aplicacion JAVA
15072008

Casi siempre , cuando ejecutamos alguna aplicacion(open office, gimp, amarok, froswire, etc),
nos muestra una ventana indicando q la aplicacion esta cargando. entonces, hay casos cuando
desarrollamos alguna aplicacion independiente del lenguaje, y deseamos q al iniciar nuestro
programita, tambien muestre una “pantalla de carga”, eso en JAVA tambien es posible.
Solo necesitamimos implementar un par de clases, y un archivo Imagen, la primera clase es la
que dibujara la ventana y configurar la velocidad de carga, el dibujo en mi caso est, arriba la
imagen, y debajo un scroll, pero es configurable( al gusto del usuario… jejee mejor dicho del
desarrolador), esta misma primera clase(PantallaCargando) hereda de JWindow, pero tambien
puede heredar de JFrame, la diferencia creo q al momento de cargar, jWindow, te permite ocultar
a pantalla cargando, con solo un click, un mismo amarok… jFrame no.
La velocidad de carga es confugurable, solo tienes q modificar el metodo “velocidadDeCarga”,
bueno, el resto del codigo creoq es muy facil interpretarlo, aqui el fuente;
import java.awt.*;
/*DEMO POR INFORUX*/
public class PantallaCargando extends JWindow {
BorderLayout borderLayout1 = new BorderLayout();
JLabel imageLabel = new JLabel();
JPanel southPanel = new JPanel();
FlowLayout southPanelFlowLayout = new FlowLayout();
JProgressBar progressBar = new JProgressBar();
ImageIcon imageIcon;
public PantallaCargando(ImageIcon imageIcon) {
this.imageIcon = imageIcon;
dibujaVentana();
}
public void dibujaVentana() {
imageLabel.setIcon(imageIcon);
this.getContentPane().setLayout(borderLayout1);
southPanel.setLayout(southPanelFlowLayout);

southPanel.setBackground(Color.BLACK);
this.getContentPane().add(imageLabel, BorderLayout.CENTER);
this.getContentPane().add(southPanel, BorderLayout.SOUTH);
southPanel.add(progressBar, null);
this.pack();
}
public void setProgresoMax(int maxProgress)
{
progressBar.setMaximum(maxProgress);}
public void setProgreso(int progress)
{
final int progreso = progress;
progressBar.setValue(progreso);}
public void setProgreso(String message, int progress)
{
final int progreso = progress;
final String theMessage = message;
setProgreso(progress);
progressBar.setValue(progreso);
setMessage(theMessage); }
private void setMessage(String message)
{
if (message==null){
message = "";

progressBar.setStringPainted(false);}
else{
progressBar.setStringPainted(true);}
progressBar.setString(message); }
public void velocidadDeCarga(){
for (int i = 0; i <= 100; i++)
{
for (long j=0; j<100000; ++j)//modifica el numero segun la velidad q
desees
{
String poop = " " + (j + i);
}
setProgreso("" + i, i); // si quieres q muestre los numeros y un mensaje
//setProgreso(i); //si no quieres q muestre nada, solo la barra
}
dispose();}
}
La segunda clase(PantallaCargandoMain), en otras palabras no es mas q la clase q llama al
primero creando un objeto de la primera(PantallaCargando), y aplicandoles los metodos, OJO q
en el metodo “inicioPantalla”. hay q darle la ruta de la imagen q deseamos. en mi caso hay una
carpeta con el nombre “imagen”, y dentro de ella esta la imagen fisica.
import javax.swing.UIManager;
import javax.swing.ImageIcon;
public class PantallaCargandoMain {
PantallaCargando screen;

public PantallaCargandoMain() {
inicioPantalla();
screen.velocidadDeCarga();
}
private void inicioPantalla() {
ImageIcon myImage = new ImageIcon("imagen/java.gif");
screen = new PantallaCargando(myImage);
screen.setLocationRelativeTo(null);
screen.setProgresoMax(100);
screen.setVisible(true);
}
public static void main(String[] args)
{
new PantallaCargandoMain();
}
}
Ahora, puedes compilar (javac PantallaCargandoMain.java) y debe funcionar, o agregar estas 2
clases en la carpeta de tu aplicacion, y en la clase q inicias tu aplicacion, en el metodo “main” de
tu proyecto, incluye solo una linea;
new PantallaCargandoMain();
Y listo.
Aqui un pantallazo

PD: la imagen puedes descargar Aqui
Aprendiendo con JComboBox…
Parte 1
11072008
holas la verdad q llevaba algunos dias q no posteaba, creanme q he tenido motivos fuertes,
…jeje en fin creo q fuera de bromas, realizar una tesis, si q es comprometedor!…en verdad lo
es!.
bien, en esta oportunidad seguire mostrandoles lo aprendido, Hoy escribire sobre el JComboBox.
JComboBox, es un componente de java q nos sirve para controlar la selecion del usuario final a
un determinado conjunto de tipos, algo asi es la idea, ademas creoq eso la lo sabran…jeje
El ejericio q les mostrare, es una aplicacion q tiene 2 JComboBox, el cual el primer combo
controla el contenido del segundo combo, es decir, si selecionas un elemento del primero, el
segundo combo, mostrara el contenido respecto a dicha selecion.
Una ves entendido, la logica de la aplicacion, lo implementamos, LA VERDAD ES REALMENTE
SENCILLO. Para este caso, tendremos 2(dos) clases WindowDemoCombo y ControlDemoCombo.
La primera clase(WindowDemoCombo), es la ventana(JFrame, JLabel, JComboBox… en fin todos
los componentes q actuan en la ventana) q visualiza el usuario.

La segunda clase(ControlDemoCombo), es la clase q controla los eventos, en este caso la accion
de selecion en el primer JComboBox.
WindowDemoCombo; Creamos los componentes swing, y CREAMOS un objeto de la clase q
controlada sus eventos, en este caso;
ControlDemoCombo controlDemoCombo = new ControlDemoCombo(this);
Veamos q al momento de crearlo estamos pasando “this”, esto quiere decir q al momento de
crear la clase q lo controlara, le pasaremos como argumento toda la ventana… es obvia la idea,
le pasamos toda la ventana, para q asi pueda acceder a ella.
Aqui el fuente
/*Demostracion Aprendiendo con JComboBox por inforux.wordpress.com */
public class WindowDemoCombo extends javax.swing.JFrame {
/** Creamos el constructor de la misma */
public WindowDemoCombo() {
initComponents();}
jComboBox1 = new JComboBox(pais);//creamos el primer combo, y le
pasamos un array de cadenas
jComboBox1.setSelectedIndex(0);//por defecto quiero visualizar el
primer item
jComboBox2 = new JComboBox();//creamo el segundo combo, vacio
jComboBox2.setEnabled(false);////por defecto q aparesca desabilidado

jPanel1.setBorder(javax.swing.BorderFactory.createTitledBorder("Aprendiendo
con JComboBox"));
jLabel1.setText("Pais");
jLabel2.setText("Region");
213);
/*Creamos el objeto controlador, para manejar los eventos*/
ControlDemoCombo controlDemoCombo = new ControlDemoCombo(this);//le
pasamos como argumento esta misma ventana
jComboBox1.addActionListener(controlDemoCombo);//agregamos escuchas
}

new WindowDemoCombo().setVisible(true);}
// Desclaramos las variables autilizar
String [] regionArgentina={"Buenos Aires","Cordova","Santa Cruz"};//array
del segundo combo
String [] regionColombia={"Bogota","Cartagena","Cali"};//array del seguno
combo
String [] regionPeru={"Arequipa","Lima","Piura"};//array del segundo combo
String [] pais={"Selecione Pais","Argentina","Colombia","Peru"};//array
del primer combo
}
ControlDemoCombo: Es una clase controladora de todas las acciones q realize el usuario en la
ventana(WindoDemoCombo). en este caso, la clase implement de ActionListener, y declara una
variable del tipo
WindowDemoCombo, este nos servira para recibir el valor “this”, enviado anteriormente.
WindowDemoCombo frameDemoCombo;
La idea es preguntar si la accion viene del primer combo
if (evento.getSource()==frameDemoCombo.jComboBox1)
luego, preguntar cual de los elementos ha hecho click, esto lo podemos hacer con el metodo
getSelectedIndex(), este nos retorna el numero del indice seleciono.
if (frameDemoCombo.jComboBox1.getSelectedIndex()==0)
despues de saber, cual esta selecionado solo nos queda llenar el segundo combo, no sin antes
elimnar, todos los elementos posibles.
frameDemoCombo.jComboBox2.removeAllItems();

frameDemoCombo.jComboBox2.addItem(frameDemoCombo.regionArgentina[i]);
Aqui elfuente:
public class ControlDemoCombo implements ActionListener{
WindowDemoCombo frameDemoCombo;
public ControlDemoCombo(WindowDemoCombo objeto){
frameDemoCombo=objeto;}
{
if (evento.getSource()==frameDemoCombo.jComboBox1)//pregunta si el
evento viene del primer combo
{/*pregunta si viene del primer elemnto*/
if (frameDemoCombo.jComboBox1.getSelectedIndex()==0){
frameDemoCombo.jComboBox2.setEnabled(false);}
/*pregunta si viene del segundo elemnto*/
for (int i=0; i<frameDemoCombo.regionArgentina.length;i++)
frameDemoCombo.jComboBox2.addItem(frameDemoCombo.regionArgentina[i]);
frameDemoCombo.jComboBox2.setEnabled(true);}
/*pregunta si viene del tercer elemnto*/
for (int i=0; i<frameDemoCombo.regionColombia.length;i++)
frameDemoCombo.jComboBox2.addItem(frameDemoCombo.regionColombia[i]);

/*pregunta si viene del cuarto elemnto*/
for (int i=0; i<frameDemoCombo.regionPeru.length;i++)
frameDemoCombo.jComboBox2.addItem(frameDemoCombo.regionPeru[i]);
}
}
}
Y listo ahora , compilar (javac *.java) y Listo, al ejecutar (java WindowDemoCombo), debe
aparecer esta pantalla:
Selecionamos y se activara el segundo combo, con sus respectivos valores del primero.

Funciona!, Espero les sea de utilidad.
Conectar MySQL desde JAVA
26062008
Bueno aprovechando lo aprendido en mis aplicaciones de escritorio, en esta oportunidad
mostrare, una forma simple y segura de conectar una Base de Datos MySQL atravez de
aplicaciones JAVA
Para empesar tenemos q tener creada o crear nuestra DB. Aqui es script
CREATE DATABASE IF NOT EXISTS DemoConexion;
USE DemoConexion;
DROP TABLE IF EXISTS `DemoConexion`.`MiTabla`;
CREATE TABLE `DemoConexion`.`MiTabla` ( `campo1` varchar(40) NOT NULL)
ENGINE=InnoDB DEFAULT CHARSET=latin1;
La idea es tener una clase solamente para nuestra Conexion(Conexion), y otra
clase(WindowConexion) q sirva para ingresar los datos, asi la clase Conexion podremos utilizarla
por el resto de la aplicacion, con una simple llamado.
1.- Implementamos la clase donde podremos ingresar el usuario y contrase;a, es decir la
ventana…jje esta ventana tendra 2 jTextFile, y un boton aceptar, este mismo se le agrega un
objeto de la clase ActionListener, para q siempre este escuchando, la interaccion con el usuario.
aqui el fuente:
class WindowConexion extends javax.swing.JFrame implements ActionListener
{
public WindowConexion()/*metodo constructor*/
{

initComponents();
centrar();
}
public void centrar(){/*metodo para centrar la ventana*/
this.setBounds((screenSize.width/2)-(this.getWidth()/2),
(screenSize.height/2)-(this.getHeight()/2), this.getWidth(),
this.getHeight());
}
setTitle("Demostracion MySQL - JAVA");
jTFUsuario = new JTextField();
jButton1 = new JButton();
jPFContraseña = new JPasswordField();
jLError = new JLabel();
jlSalida=new JLabel();
jLabel1.setForeground(new java.awt.Color(102, 102, 102));
jLabel1.setText("Demo por Inforux");
jLabel1.setToolTipText("Demo Conexion MySQL by inforux");

jLabel2.setText("User");
getContentPane().add(jTFUsuario);
jTFUsuario.setBounds(110, 100, 100, 18);
jLabel4.setText("Password");
jlSalida.setText("");
getContentPane().add(jlSalida);
jlSalida.setBounds(40, 140, 150, 14);
jButton1.setText("Aceptar");
getContentPane().add(jButton1);
jButton1.setBounds(80, 180, 100, 24);
getContentPane().add(jPFContraseña);
jPFContraseña.setBounds(110, 120, 80, 18);
jLError.setForeground(java.awt.Color.gray);
getContentPane().add(jLError);
jLError.setBounds(50, 150, 130, 0);

255);
jButton1.addActionListener(this);//agrego mi objeto escucha
}
public void actionPerformed(ActionEvent evento) //programos los eventos
{
if (evento.getSource()== jButton1){//pregunto si la accion viene del
boton aceptar
try {
if (Conexion.conectar())
jlSalida.setText("Conexion Exitosa");}
catch (Exception ex){System.out.println(ex);}
}
}
public static void main(String args[])
{
new WindowConexion().setVisible(true);
}
public static javax.swing.JButton jButton1;
public static javax.swing.JLabel jLError;
private javax.swing.JLabel jLabel1;
public static javax.swing.JPasswordField jPFContraseña;
public static javax.swing.JTextField jTFUsuario;

public static javax.swing.JLabel jlSalida;
}
2.- si compilamos en este momento nos dira error, porq no existe la conexion, trankilos…jeje
ahora iplementemos lo q nos interesa la clase Conexion.java,
Esta clase, declara variables para obtener el nombre del driver, el nombre de la base de datos,
login(para capturar lo q escribas en la caja de texto), password(igual, captura la contrase;a
ingresada),y sobre todo el importantisimo, el objeto “conn” de la clase Connection(este se podra
llamar desde cualquier clase, ya sea para hacer consultas), aqui les va el fuente.
import java.sql.*;
public class Conexion{
public final static String bd = "DemoConexion";
public final static String url="jdbc:mysql://localhost/"+bd;
public final static String driver="com.mysql.jdbc.Driver";
public static Connection conn = null;
public static String login=WindowConexion.jTFUsuario.getText();
public static String password =WindowConexion.jPFContraseña.getText();
//metodo para conectar con la BD
public static boolean conectar() throws Exception{
login=WindowConexion.jTFUsuario.getText();
password =WindowConexion.jPFContraseña.getText();
try
{
Class.forName(driver).newInstance();
conn = DriverManager.getConnection(url,login,password);
if (conn != null)

System.out.println("Conexión a
DB..."+url+"...Ok"+"...Usuario:..."+login);
return true;
}
catch(SQLException ex)
{
System.out.println("Error al conectar con la DB..."+url+"...Usuario:..."
+login );
return false;
}
}//fin del metodo conectar
}//fin de la clase
3.- Compilar( $ javac .*java) aparecera esta ventana:
Como ve, no es nada del otro mundo, el asunto es crear una clase independiente delresto, la
cual nos conectara, y a su vez nos dara la conecion(el objeto conn) en el momento oportuno, ya
sea para realizar consultas.
Espero le sirva a mas de uno, ya que personalmente, en un principio me hizo sufrir muchoo.

Instalar Driver mysql-connector-
java-version.jar en Debian
26062008
En esta oportunidad, les mostrare, una forma muy simple de copiar y pegar…jejejeee digo de
instalar el famoso driver para conecar aplicacion java con MySQL, puedes bajarlo mysql-
connector-java-508-bin.jar, pero hay un detalle wordpress, no acepta(bueno ami no me
acepto)archivos .jar, asi q opte, por renombralo y darle .odt(ejeje ) asi que si lo desgargaras
tienes q renombrarlo y quitarle e. “.odt”, O en tal caso, ve a la pagina del MySQL y bajar el
driver aqui el Enlace.
Bien una vez descargado, el driver(ojo, el driver es solamente un unico archivo, con extension
.jar), vamos a suponer q esta en el escritorio, abrimos la terminal y escribimos
$su
#cp /home/tuUsuario/Desktop/mysql-connector-java-5.0.8-bin.jar
/usr/java/jdk1.5.0_15/jre/lib/ext/
La idea, es copiar el archivo en las librerias de la maquina virtual JVM (ojo pero del JDK) Ya esta,
no dije, es un copiar y pegar… jejeje, pero a mi, inicialmente me dio mas de un dolor de cabesa.
Nota, cualquier archivo a;adido, “cualquierArchivo.jar” solamente se debe copiar a la carpeta:
…/carpetaDeTuJDK/jre/lib/ext/.

Java.netbeans

Recomendados

Recomendados

Más contenido relacionado

Similar a Java.netbeans

Similar a Java.netbeans (20)

Más de Robert Wolf

Más de Robert Wolf (20)

Último

Último (12)

Java.netbeans