// Fig. 13.4: PruebaEtiqueta.

java
// Demostracin de la clase JLabel.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PruebaEtiqueta extends JFrame {
private JLabel etiqueta1, etiqueta2, etiqueta3;

// configurar GUI
public PruebaEtiqueta()
{
super( "Prueba de JLabel" );

// obtener panel de contenido y establecer su esquema
Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );

// constructor de JLabel con un argumento cadena
etiqueta1 = new JLabel( "Etiqueta con texto" );
etiqueta1.setToolTipText( "Esta es la etiqueta1" );
contenedor.add( etiqueta1 );

// constructor de JLabel con argumentos cadena, Icono y alineacin
Icon insecto = new ImageIcon( "insecto1.gif" );
etiqueta2 = new JLabel( "Etiqueta con texto e icono", insecto,
SwingConstants.LEFT );
etiqueta2.setToolTipText( "Esta es la etiqueta2" );
contenedor.add( etiqueta2 );

// constructor de JLabel sin argumentos
etiqueta3 = new JLabel();
etiqueta3.setText( "Etiqueta con icono y texto en parte inferior" );
etiqueta3.setIcon( insecto );
etiqueta3.setHorizontalTextPosition( SwingConstants.CENTER );
etiqueta3.setVerticalTextPosition( SwingConstants.BOTTOM );
etiqueta3.setToolTipText( "Esta es la etiqueta3" );
contenedor.add( etiqueta3 );

setSize( 275, 170 );
setVisible( true );

} // fin del constructor

public static void main( String args[] )
{
PruebaEtiqueta aplicacion = new PruebaEtiqueta();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

} // fin de la clase PruebaEtiqueta




// Fig. 13.7: PruebaCampoTexto.java
// Demostracin de la clase JTextField.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PruebaCampoTexto extends JFrame {
private JTextField campoTexto1, campoTexto2, campoTexto3;
private JPasswordField campoContrasenia;

// configurar GUI
public PruebaCampoTexto()
{
super( "Prueba de JTextField y JPasswordField" );

Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );

// crear campo de texto con tamao predeterminado
campoTexto1 = new JTextField( 10 );
contenedor.add( campoTexto1 );

// crear campo de texto con texto predeterminado
campoTexto2 = new JTextField( "Escriba el texto aqu" );
contenedor.add( campoTexto2 );

// crear campo de texto con texto predeterminado,
// 20 elementos visibles y sin manejador de eventos
campoTexto3 = new JTextField( "Campo de texto no editable", 20 );
campoTexto3.setEditable( false );
contenedor.add( campoTexto3 );

// crear campo de contrasea con texto predeterminado
campoContrasenia = new JPasswordField( "Texto oculto" );
contenedor.add( campoContrasenia );

// registrar manejadores de eventos
ManejadorCampoTexto manejador = new ManejadorCampoTexto();
campoTexto1.addActionListener( manejador );
campoTexto2.addActionListener( manejador );
campoTexto3.addActionListener( manejador );
campoContrasenia.addActionListener( manejador );

setSize( 325, 100 );
setVisible( true );

} // fin del constructor de PruebaCampoTexto

public static void main( String args[] )
{
PruebaCampoTexto aplicacion = new PruebaCampoTexto();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

// clase interna privada para el manejo de eventos
private class ManejadorCampoTexto implements ActionListener {

// procesar eventos de campo de texto
public void actionPerformed( ActionEvent evento )
{
String cadena = "";

// el usuario oprimi Intro en objeto JTextField campoTexto1
if ( evento.getSource() == campoTexto1 )
cadena = "campoTexto1: " + evento.getActionCommand();

// el usuario oprimi Intro en objeto JTextField campoTexto2
else if ( evento.getSource() == campoTexto2 )
cadena = "campoTexto2: " + evento.getActionCommand();

// el usuario oprimi Intro en objeto JTextField campoTexto3
else if ( evento.getSource() == campoTexto3 )
cadena = "campoTexto3: " + evento.getActionCommand();

// el usuario oprimi Intro en objeto JTextField campoContrasenia
else if ( evento.getSource() == campoContrasenia ) {
cadena = "campoContrasenia: " +
new String( campoContrasenia.getPassword() );
}

JOptionPane.showMessageDialog( null, cadena );

} // fin del mtodo actionPerformed

} // fin de la clase interna privada ManejadorCampoTexto

} // fin de la clase PruebaCampoTexto























// Fig. 13.10: PruebaBoton.java
// Creacin de objetos JButton.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PruebaBoton extends JFrame {
private JButton botonSimple, botonElegante;

// configurar GUI
public PruebaBoton()
{
super( "Prueba de botones" );

// obtener panel de contenido y establecer su esquema
Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );

// crear botones
botonSimple = new JButton( "Botn simple" );
contenedor.add( botonSimple );

Icon insecto1 = new ImageIcon( "insecto1.gif" );
Icon insecto2 = new ImageIcon( "insecto2.gif" );
botonElegante = new JButton( "Botn elegante", insecto1 );
botonElegante.setRolloverIcon( insecto2 );
contenedor.add( botonElegante );

// crear una instancia de la clase interna ManejadorBoton
// a usar para el manejo de eventos de botones
ManejadorBoton manejador = new ManejadorBoton();
botonElegante.addActionListener( manejador );
botonSimple.addActionListener( manejador );

setSize( 300, 100 );
setVisible( true );

} // fin del constructor de PruebaBoton

public static void main( String args[] )
{
PruebaBoton aplicacion = new PruebaBoton();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

// clase interna para el manejo de eventos de botn
private class ManejadorBoton implements ActionListener {

// manejar evento de botn
public void actionPerformed( ActionEvent evento )
{
JOptionPane.showMessageDialog( PruebaBoton.this,
"Usted oprimi: " + evento.getActionCommand() );
}

} // fin de la clase interna privada ManejadorBoton

} // fin de la clase PruebaBoton



// Fig. 13.11: PruebaCasillaVerificacion.java
// Creacin de botones JCheckBox.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PruebaCasillaVerificacion extends JFrame {
private JTextField campo;
private JCheckBox negrita, cursiva;
// configurar GUI
public PruebaCasillaVerificacion()
{
super( "Prueba de JCheckBox" );

// obtener panel de contenido y establecer su esquema
Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );

// configurar objeto JTextField y establecer su tipo de letra
campo = new JTextField( "Observe el cambio en el estilo de tipo de letra", 25 );
campo.setFont( new Font( "Serif", Font.PLAIN, 14 ) );
contenedor.add( campo );

// crear objetos casilla de verificacin
negrita = new JCheckBox( "Negrita" );
contenedor.add( negrita );

cursiva = new JCheckBox( "Cursiva" );
contenedor.add( cursiva );

// registrar componentes de escucha para los objetos JCheckBox
ManejadorCasillaVerificacion manejador = new ManejadorCasillaVerificacion();
negrita.addItemListener( manejador );
cursiva.addItemListener( manejador );

setSize( 300, 100 );
setVisible( true );

} // fin del constructor de PruebaCasillaVerificacion

public static void main( String args[] )
{
PruebaCasillaVerificacion aplicacion = new PruebaCasillaVerificacion();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}
// clase interna privada para manejo de eventos de ItemListener
private class ManejadorCasillaVerificacion implements ItemListener {
private int valNegrita = Font.PLAIN;
private int valCursiva = Font.PLAIN;

// responder a eventos de casilla de verificacin
public void itemStateChanged( ItemEvent evento )
{
// procesar eventos de casilla de verificacin negrita
if ( evento.getSource() == negrita )
valNegrita = negrita.isSelected() ? Font.BOLD : Font.PLAIN;

// procesar eventos de casilla de verificacin cursiva
if ( evento.getSource() == cursiva )
valCursiva = cursiva.isSelected() ? Font.ITALIC : Font.PLAIN;

// establecer tipo de letra del campo de texto
campo.setFont( new Font( "Serif", valNegrita + valCursiva, 14 ) );

} // fin del mtodo itemStateChanged

} // fin de la clase interna privada ManejadorCasillaVerificacion

} // fin de la clase PruebaCasillaVerificacion
// Fig. 13.12: PruebaBotonOpcion.java
// Creacin de botones de opcin, utilizando ButtonGroup y JRadioButton.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PruebaBotonOpcion extends JFrame {
private JTextField campo;
private Font tipoLetraSimple, tipoLetraNegrita, tipoLetraCursiva,
tipoLetraNegritaCursiva;
private JRadioButton botonSimple, botonNegrita, botonCursiva,
botonNegritaCursiva;
private ButtonGroup grupoBotonesOpcion;

// crear GUI y tipos de letra
public PruebaBotonOpcion()
{
super( "Prueba de RadioButton" );

// obtener panel de contenido y establecer su esquema
Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );

// establecer JTextField
campo = new JTextField( "Observe cmo cambia el estilo del tipo de letra",
30 );
contenedor.add( campo );

// crear botones de opcin
botonSimple = new JRadioButton( "Simple", true );
contenedor.add( botonSimple );

botonNegrita = new JRadioButton( "Negrita", false );
contenedor.add( botonNegrita );

botonCursiva = new JRadioButton( "Cursiva", false );
contenedor.add( botonCursiva );

botonNegritaCursiva = new JRadioButton( "Negrita/Cursiva", false );
contenedor.add( botonNegritaCursiva );

// crear relacin lgica entre objetos JRadioButton
grupoBotonesOpcion = new ButtonGroup();
grupoBotonesOpcion.add( botonSimple );
grupoBotonesOpcion.add( botonNegrita );
grupoBotonesOpcion.add( botonCursiva );
grupoBotonesOpcion.add( botonNegritaCursiva );

// crear objetos de tipo de letra
tipoLetraSimple = new Font( "Serif", Font.PLAIN, 14 );
tipoLetraNegrita = new Font( "Serif", Font.BOLD, 14 );
tipoLetraCursiva = new Font( "Serif", Font.ITALIC, 14 );
tipoLetraNegritaCursiva = new Font( "Serif", Font.BOLD + Font.ITALIC, 14
);
campo.setFont( tipoLetraSimple ); // establecer tipo de letra inicial

// registrar eventos para objetos JRadioButton
botonSimple.addItemListener( new ManejadorBotonOpcion( tipoLetraSimple )
);
botonNegrita.addItemListener( new ManejadorBotonOpcion( tipoLetraNegrita )
);
botonCursiva.addItemListener(
new ManejadorBotonOpcion( tipoLetraCursiva ) );
botonNegritaCursiva.addItemListener(
new ManejadorBotonOpcion( tipoLetraNegritaCursiva ) );

setSize( 350, 100 );
setVisible( true );

} // fin del constructor de PruebaBotonOpcion

public static void main( String args[] )
{
PruebaBotonOpcion aplicacion = new PruebaBotonOpcion();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

// clase interna privada para manejar eventos de botn de opcin
private class ManejadorBotonOpcion implements ItemListener {
private Font tipoDeLetra;

public ManejadorBotonOpcion( Font f )
{
tipoDeLetra = f;
}

// manejar eventos de botn de opcin
public void itemStateChanged( ItemEvent evento )
{
campo.setFont( tipoDeLetra );
}

} // fin de la clase interna privada ManejadorBotonOpcion

} // fin de la clase PruebaBotonOpcion















// Fig. 13.13: PruebaCuadroComb.java
// Uso de un objeto JComboBox para seleccionar una imagen a mostrar.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PruebaCuadroComb extends JFrame {
private JComboBox cuadroCombImagenes;
private JLabel etiqueta;

private String nombres[] =
{ "insecto1.gif", "insecto2.gif", "insectoviaje.gif", "insectanim.gif" };
private Icon iconos[] = { new ImageIcon( nombres[ 0 ] ),
new ImageIcon( nombres[ 1 ] ), new ImageIcon( nombres[ 2 ] ),
new ImageIcon( nombres[ 3 ] ) };

// configurar GUI
public PruebaCuadroComb()
{
super( "Prueba de JComboBox" );

// obtener panel de contenido y establecer su esquema
Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );

// establecer objeto JComboBox y registrar su manejador de eventos
cuadroCombImagenes = new JComboBox( nombres );
cuadroCombImagenes.setMaximumRowCount( 3 );
cuadroCombImagenes.addItemListener(

new ItemListener() { // clase interna annima

// manejar evento para JComboBox
public void itemStateChanged( ItemEvent evento )
{
// determinar si la casilla de verificacin est seleccionada
if ( evento.getStateChange() == ItemEvent.SELECTED )
etiqueta.setIcon( iconos[
cuadroCombImagenes.getSelectedIndex() ] );
}

} // fin de la clase interna annima

); // fin de la llamada a addItemListener

contenedor.add( cuadroCombImagenes );

// establecer objeto JLabel para mostrar objetos ImageIcon
etiqueta = new JLabel( iconos[ 0 ] );
contenedor.add( etiqueta );

setSize( 350, 150 );
setVisible( true );

} // fin del constructor de PruebaCuadroComb

public static void main( String args[] )
{
PruebaCuadroComb aplicacion = new PruebaCuadroComb();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

} // fin de la clase PruebaCuadroComb






// Fig. 13.14: PruebaLista.java
// Seleccin de colores de un objeto JList.
import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;

public class PruebaLista extends JFrame {
private JList listaColores;
private Container contenedor;

private final String nombresColores[] = { "Negro", "Azul", "Cyan",
"Gris oscuro", "Gris", "Verde", "Gris claro", "Magenta",
"Naranja", "Rosa", "Rojo", "Blanco", "Amarillo" };

private final Color colores[] = { Color.BLACK, Color.BLUE, Color.CYAN,
Color.DARK_GRAY, Color.GRAY, Color.GREEN, Color.LIGHT_GRAY,
Color.MAGENTA, Color.ORANGE, Color.PINK, Color.RED, Color.WHITE,
Color.YELLOW };

// configurar GUI
public PruebaLista()
{
super( "Prueba de JList" );

// obtener panel de contenido y establecer su esquema
contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );

// crear una lista con elementos del arreglo nombresColores
listaColores = new JList( nombresColores );
listaColores.setVisibleRowCount( 5 );

// no permitir selecciones mltiples
listaColores.setSelectionMode( ListSelectionModel.SINGLE_SELECTION );

// agregar un objeto JScrollPane, que contiene a JList, al panel de contenido
contenedor.add( new JScrollPane( listaColores ) );
listaColores.addListSelectionListener(

new ListSelectionListener() { // clase interna annima

// manejar eventos de seleccin en la lista
public void valueChanged( ListSelectionEvent evento )
{
contenedor.setBackground(
colores[ listaColores.getSelectedIndex() ] );
}

} // fin de la clase interna annima

); // fin de la llamada a addListSelectionListener

setSize( 350, 150 );
setVisible( true );

} // fin del constructor de PruebaLista

public static void main( String args[] )
{
PruebaLista aplicacion = new PruebaLista();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

} // fin de la clase PruebaLista





// Fig. 13.15: PruebaSeleccionMultiple.java
// Cmo copiar elementos de una lista a otra.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class PruebaSeleccionMultiple extends JFrame {
private JList listaColores, listaCopia;
private JButton botonCopiar;
private final String nombresColores[] = { "Negro", "Azul", "Cyan",
"Gris oscuro", "Gris", "Verde", "Gris claro", "Magenta", "Naranja",
"Rosa", "Rojo", "Blanco", "Amarillo" };

// configurar GUI
public PruebaSeleccionMultiple()
{
super( "Listas de seleccin mltiple" );

// obtener panel de contenido y establecer su esquema
Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout() );

// establecer objeto JList listaColores
listaColores = new JList( nombresColores );
listaColores.setVisibleRowCount( 5 );
listaColores.setSelectionMode(
ListSelectionModel.MULTIPLE_INTERVAL_SELECTION );
contenedor.add( new JScrollPane( listaColores ) );

// crear botn copiar y registrar su componente de escucha
botonCopiar = new JButton( "Copiar >>>" );
botonCopiar.addActionListener(

new ActionListener() { // clase interna annima

// manejar evento de botn
public void actionPerformed( ActionEvent evento )
{
// colocar valores seleccionados en listaCopia
listaCopia.setListData( listaColores.getSelectedValues() );
}

} // fin de clase interna annima

); // fin de la llamada a addActionListener

contenedor.add( botonCopiar );

// establecer objeto JList listaCopia
listaCopia = new JList( );
listaCopia.setVisibleRowCount( 5 );
listaCopia.setFixedCellWidth( 100 );
listaCopia.setFixedCellHeight( 15 );
listaCopia.setSelectionMode(
ListSelectionModel.SINGLE_INTERVAL_SELECTION );
contenedor.add( new JScrollPane( listaCopia ) );

setSize( 325, 130 );
setVisible( true );

} // fin del constructor PruebaSeleccionMultiple

public static void main( String args[] )
{
PruebaSeleccionMultiple aplicacion = new PruebaSeleccionMultiple();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

} // fin de la clase PruebaSeleccionMultiple
// Fig. 13.17: RastreadorRaton.java
// Demostracin de los eventos de ratn.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class RastreadorRaton extends JFrame
implements MouseListener, MouseMotionListener {

private JLabel barraEstado;

// configurar GUI y registrar manejadores de eventos de ratn
public RastreadorRaton()
{
super( "Demostracin de los eventos de ratn" );

barraEstado = new JLabel();
getContentPane().add( barraEstado, BorderLayout.SOUTH );

addMouseListener( this ); // escucha sus propios eventos de ratn
addMouseMotionListener( this ); // y de movimiento de ratn

setSize( 300, 125 );
setVisible( true );
}

// Manejadores de eventos de MouseListener
// manejar el evento cuando el botn del ratn se suelta inmediatamente
despus de oprimir
public void mouseClicked( MouseEvent evento )
{
barraEstado.setText( "Se hizo clic en [" + evento.getX() +
", " + evento.getY() + "]" );
}

// manejar evento cuando se oprime el botn del ratn
public void mousePressed( MouseEvent evento )
{
barraEstado.setText( "Se oprimi en [" + evento.getX() +
", " + evento.getY() + "]" );
}

// manejar evento cuando se suelta el ratn despus de arrastrar
public void mouseReleased( MouseEvent evento )
{
barraEstado.setText( "Se solt en [" + evento.getX() +
", " + evento.getY() + "]" );
}

// manejar el evento cuando el ratn entra al rea
public void mouseEntered( MouseEvent evento )
{
barraEstado.setText( "Ratn entro en [" + evento.getX() +
", " + evento.getY() + "]" );
getContentPane().setBackground( Color.GREEN );
}

// manejar evento cuando el ratn sale del rea
public void mouseExited( MouseEvent evento )
{
barraEstado.setText( "Ratn fuera de la ventana" );
getContentPane().setBackground( Color.WHITE );
}

// Manejadores de eventos de MouseMotionListener
// manejar el evento cuando el usuario arrastra el ratn con el botn
oprimido
public void mouseDragged( MouseEvent evento )
{
barraEstado.setText( "Se arrastr en [" + evento.getX() +
", " + evento.getY() + "]" );
}

// manejar el evento cuando el usuario mueve el ratn
public void mouseMoved( MouseEvent evento )
{
barraEstado.setText( "Se movi en [" + evento.getX() +
", " + evento.getY() + "]" );
}

public static void main( String args[] )
{
RastreadorRaton aplicacion = new RastreadorRaton();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

} // fin de la clase RastreadorRaton























// Fig. 13.19: Pintor.java
// Uso de la clase MouseMotionAdapter.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Pintor extends JFrame {
private int cuentaPuntos = 0;

// arreglo de 1000 referencias a java.awt.Point
private Point puntos[] = new Point[ 1000 ];

// configurar GUI y registrar manejador de eventos de ratn
public Pintor()
{
super( "Un programa simple de dibujo" );

// crear una etiqueta y colocarla en la parte SOUTH del esquema BorderLayout
getContentPane().add( new JLabel( "Arrastre el ratn para dibujar" ),
BorderLayout.SOUTH );

addMouseMotionListener(

new MouseMotionAdapter() { // clase interna annima

// almacenar coordenadas de arrastre y llamar a repaint
public void mouseDragged( MouseEvent evento )
{
if ( cuentaPuntos < puntos.length ) {
puntos[ cuentaPuntos ] = evento.getPoint();
++cuentaPuntos;
repaint();
}
}

} // fin de la clase interna annima

); // fin de la llamada a addMouseMotionListener

setSize( 300, 150 );
setVisible( true );

} // fin del constructor de Pintor

// dibujar valo en un cuadro delimitador de 4 por 4 en ubicacin especificada en
ventana
public void paint( Graphics g )
{
super.paint( g ); // borra el rea de dibujo

for ( int i = 0; i < puntos.length && puntos[ i ] != null; i++ )
g.fillOval( puntos[ i ].x, puntos[ i ].y, 4, 4 );
}

public static void main( String args[] )
{
Pintor aplicacion = new Pintor();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

} // fin de la clase Pintor
// Fig. 13.27: DemoPanel.java
// Uso de un objeto JPanel para ayudar a distribuir los componentes.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class DemoPanel extends JFrame {
private JPanel panelBotones;
private JButton botones[];

// configurar GUI
public DemoPanel()
{
super( "Demostracin JPanel" );

// obtener panel de contenido
Container contenedor = getContentPane();

// crear arreglo botones
botones = new JButton[ 5 ];

// configurar panel y establecer su esquema
panelBotones = new JPanel();
panelBotones.setLayout( new GridLayout( 1, botones.length ) );

// crear y agregar botones
for ( int cuenta = 0; cuenta < botones.length; cuenta++ ) {
botones[ cuenta ] = new JButton( "Botn " + ( cuenta + 1 ) );
panelBotones.add( botones[ cuenta ] );
}

contenedor.add( panelBotones, BorderLayout.SOUTH );

setSize( 425, 150 );
setVisible( true );

} // fin del constructor de DemoPanel

public static void main( String args[] )
{
DemoPanel aplicacion = new DemoPanel();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

} // fin de la clase DemoPanel










// Fig. 15.3: UsoExcepciones.java
// Demostracin del mecanismo try-catch-finally para manejar excepciones.
public class UsoExcepciones {

public static void main( String args[] )
{
try {
lanzarExcepcion(); // llamar al mtodo lanzarExcepcion
}

// atrapar excepciones lanzadas por el mtodo lanzarExcepcion
catch ( Exception excepcion ) {
System.err.println( "La excepcion se manejo en main" );
}

noLanzaExcepcion();
}

// demostrar try/catch/finally
public static void lanzarExcepcion() throws Exception
{
// lanzar una excepcin y atraparla inmediatamente
try {
System.out.println( "El metodo lanzarExcepcion" );
throw new Exception(); // generar excepcin
}

// atrapar la excepcin lanzada en el bloque try
catch ( Exception excepcion ) {
System.err.println(
"La excepcion se manejo en el metodo lanzarExcepcion" );
throw excepcion; // volver a lanzar para procesarla posteriormente

// cualquier cdigo aqu no llegara a ejecutarse
}

// este bloque se ejecuta, sin importar lo que ocurra en try/catch
finally {
System.err.println( "Finalmente se ejecuto en lanzarExcepcion" );
}

// cualquier cdigo aqu no llegara a ejecutarse

} // fin del mtodo lanzarExcepcion

// demostrar finally cuando no ocurre excepcin
public static void noLanzaExcepcion()
{
// el bloque try no lanza una excepcin
try {
System.out.println( "El metodo noLanzaExcepcion" );
}

// catch no se ejecuta, porque no se lanz una excepcin
catch( Exception excepcion ) {
System.err.println( excepcion );
}

// la clusula this se ejecuta, sin importar lo que ocurra en try/catch
finally {
System.err.println(
"Finalmente se ejecuto en noLanzaExcepcion" );
}

System.out.println( "Fin del metodo noLanzaExcepcion" );

} // fin del mtodo noLanzaExcepcion

} // fin de la clase UsoExcepciones
// Fig. 2.9: Suma.java
// Programa que muestra la suma de dos nmeros.

// Paquetes de Java
import javax.swing.JOptionPane; // el programa utiliza JOptionPane

public class Suma{

// el mtodo main empieza la ejecucin de la aplicacin de Java
public static void main( String args[] )
{
String primerNumero; // primera cadena introducida por el usuario
String segundoNumero; // segunda cadena introducida por el usuario

int numero1; // primer nmero a sumar
int numero2; // segundo nmero a sumar
int suma; // suma de numero1 y numero2

// leer el primer nmero del usuario como una cadena
primerNumero = JOptionPane.showInputDialog( "Escriba el primer entero" );

// leer el segundo nmero del usuario como una cadena
segundoNumero =
JOptionPane.showInputDialog( "Escriba el segundo entero" );

// convertir los nmeros de tipo String a tipo int
numero1 = Integer.parseInt( primerNumero );
numero2 = Integer.parseInt( segundoNumero );

// sumar los nmeros
suma = numero1 + numero2;

// mostrar el resultado
JOptionPane.showMessageDialog( null, "La suma es " + suma,
"Resultados", JOptionPane.PLAIN_MESSAGE );

System.exit( 0 ); // terminar aplicacin con la ventana

} // fin del mtodo main

} // fin de la clase Suma














// Fig. 4.7: Promedio1.java
// Programa del promedio de una clase mediante la repeticin controlada por
contador.
import javax.swing.JOptionPane;

public class Promedio1 {

public static void main( String args[] )
{
int total; // suma de las calificaciones introducidas por el
usuario
int contadorCalif; // nmero de calificacin a introducir a continuacin
int calificacion; // valor de la calificacin
int promedio; // promedio de calificaciones

String cadenaCalif; // calificacin introducida por el usuario

// fase de inicializacin
total = 0; // inicializar total
contadorCalif = 1; // inicializar contador de ciclo

// fase de procesamiento
while ( contadorCalif <= 10 ) { // iterar 10 veces

// pedir la entrada y leer la calificacin del usuario
cadenaCalif = JOptionPane.showInputDialog(
"Escriba la calificacin como un entero: " );

// convertir cadenaCalif en int
calificacion = Integer.parseInt( cadenaCalif );

total = total + calificacion; // sumar calificacion al total
contadorCalif = contadorCalif + 1; // incrementar el contador

} // fin de instruccin while

// fase de terminacin
promedio = total / 10; // divisin de enteros

// mostrar el promedio de las calificaciones del examen
JOptionPane.showMessageDialog( null, "El promedio de la clase es " +
promedio,
"Promedio de la clase", JOptionPane.INFORMATION_MESSAGE );

System.exit( 0 ); // terminar el programa

} // fin de main

} // fin de la clase Promedio1






// Fig. 12.22: Figuras.java
// Demostracin de algunas figuras de Java2D.
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import javax.swing.*;

public class Figuras extends JFrame {

// establecer cadena de barra de ttulo y dimensiones de la ventana
public Figuras()
{
super( "Dibujo de figuras en 2D" );

setSize( 425, 160 );
setVisible( true );
}

// dibujar figuras con la API Java2D
public void paint( Graphics g )
{
super.paint( g ); // llamar al mtodo paint de la superclase

Graphics2D g2d = ( Graphics2D ) g; // convertir g a Graphics2D

// dibujar elipse 2D rellena con un gradiente azul-amarillo
g2d.setPaint( new GradientPaint( 5, 30, Color.BLUE, 35, 100,
Color.YELLOW, true ) );
g2d.fill( new Ellipse2D.Double( 5, 30, 65, 100 ) );

// dibujar rectngulo 2D en rojo
g2d.setPaint( Color.RED );
g2d.setStroke( new BasicStroke( 10.0f ) );
g2d.draw( new Rectangle2D.Double( 80, 30, 65, 100 ) );

// dibujar rectngulo 2D redondeado con fondo tamponado
BufferedImage buffImage = new BufferedImage( 10, 10,
BufferedImage.TYPE_INT_RGB );

Graphics2D gg = buffImage.createGraphics();
gg.setColor( Color.YELLOW ); // dibujar en amarillo
gg.fillRect( 0, 0, 10, 10 ); // dibujar un rectngulo relleno
gg.setColor( Color.BLACK ); // dibujar en negro
gg.drawRect( 1, 1, 6, 6 ); // dibujar un rectngulo
gg.setColor( Color.BLUE ); // dibujar en azul
gg.fillRect( 1, 1, 3, 3 ); // dibujar un rectngulo relleno
gg.setColor( Color.RED ); // dibujar en rojo
gg.fillRect( 4, 4, 3, 3 ); // dibujar un rectngulo relleno

// pintar buffImage en el objeto JFrame
g2d.setPaint( new TexturePaint( buffImage,
new Rectangle( 10, 10 ) ) );
g2d.fill( new RoundRectangle2D.Double( 155, 30, 75, 100, 50, 50 ) );

// dibujar arco 2D en forma de pastel, en color blanco
g2d.setPaint( Color.WHITE );
g2d.setStroke( new BasicStroke( 6.0f ) );
g2d.draw( new Arc2D.Double( 240, 30, 75, 100, 0, 270, Arc2D.PIE ) );

// dibujar lneas 2D en verde y amarillo
g2d.setPaint( Color.GREEN );
g2d.draw( new Line2D.Double( 395, 30, 320, 150 ) );

float guiones[] = { 10 };

g2d.setPaint( Color.YELLOW );
g2d.setStroke( new BasicStroke( 4, BasicStroke.CAP_ROUND,
BasicStroke.JOIN_ROUND, 10, guiones, 0 ) );
g2d.draw( new Line2D.Double( 320, 30, 395, 150 ) );

} // fin del mtodo paint

// ejecutar la aplicacin
public static void main( String args[] )
{
Figuras aplicacion = new Figuras();
aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
}

} // fin de la clase Figuras