APÉNDICE B )

Crear Java beans

Los Java beans son la respuesta de Sun a los controles ActiveX de Microsoft. Los
beans son componentes de código reutilizables escritos en Java que se pueden usar
en distintos entornos de programación. De hecho, funcionan de un modo muy similar a
los controles ActiveX, pues contienen propiedades, métodos y eventos para otros
componentes de código. Utilizando los beans, puede crear sus propios "controles"
Java personalizados, como botones que cambian de color cuando se hace clic sobre
ellos o paneles de cotizaciones de bolsa (stock tickers) que obtienen información de
Internet.

Los Java beans están diseñados para ser utilizados en herramientas de

preparación de aplicaciones, que son entornos de programación que permiten
configurar beans. Una de tales herramientas, el beanbox, se proporciona con en Sun
Bean Development Kit (BDK, o Kit de desarrollo de beans de Sun), que puede
descargarse desde www.java.sun.com e instalarse.
Utilizaremos BDK para diseñar y utilizar beans. Los beans permiten al usuario
crear sus propias aplicaciones partiendo de componentes preescritos, añadiendo sólo
lo que se necesita, y nada más.

Sun soporta Java beans en el paquete java.beans. Observe las interfaces de dicho
paquete:

* AppletInitializer-- Inicializa applets y está diseñado para funcionar con

java.beans.Beans.instantiate.
* BeanInfo—Esta interfaz proporciona información explícita sobre los métodos,
propiedades, eventos, etc. de un bean.
*Customizer—Una clase customizer class facilita una completa GUI predefinida
para personalizar un Java bean.
* DesignMode—Esta interfaz está destinada a la implementación o delegación
de instancias de java.beans.BeanContext con el fin de determinar si un bean está
diseñado mediante la propiedad designTime.
* PropertyChangeListener—Administra eventos PropertyChange si un bean
cambia una propiedad dependiente.
* PropertyEditor—Proporciona soporte para GUIs que permiten a los usuarios
editar el valor de una propiedad de un tipo dado.
* VetoableChangeListener—Administra eventos rechazados cuando un bean
modifica una propiedad de limitación.
* Visibility—Indica si un bean es visible (en algunas circunstancias, un bean
puede ejecutarse en servidores donde no hay disponible un GUI).
 Y éstas son las clases en java.beans:

* BeanDescriptor—Proporciona información global sobre un bean, incluyendo

sus clases Java, su nombre, etc.
* Beans—Proporciona algunos métodos de control de beans de propósito
general.
* EventSetDescriptor—Describe un grupo de eventos activado por un Java
bean.
*FeatureDescriptor—La clase base para PropertyDescriptor,
EventSetDescriptor, y MethodDescriptor.
* IndexedPropertyDescriptor—Describe una propiedad que actúa como una
selección.
* Introspector—Facilita un modo estándar.
* MethodDescriptor—Describe un método específico para obtener información
acerca de las propiedades, los eventos y los métodos soportados por un Java bean.
* ParameterDescriptor—Facilita información de cada uno de los parámetros de
los métodos, además de la información de bajo nivel proporcionada por la clase
java.lang.reflect.Method.
* PropertyChangeEvent—Busca eventos PropertyChange ejecutados cuando
un bean cambia una propiedad vinculada.
* PropertyChangeSupport—Una clase de utilidad que pueden usar los beans
que soportan propiedades de vinculación.
* PropertyDescriptor—Describe una propiedad que exporta un Java bean.
*PropertyEditorManager—Puede utilizarse para localizar un editor de
propiedades para cualquier nombre dado.
* PropertyEditorSupport—Una clase de soporte que ayuda a configurar editores
de propiedades.
* SimpleBeanInfo—Una clase que hace más fácil a los usuarios proporcionar
datos BeanInfo.
* VetoableChangeSupport—Una clase de utilidad que puede usarse por los
beans que soportan propiedades de vinculación.

A continuación, veremos cómo crear Java beans, desde los más sencillos hasta
los que soportan propiedades y métodos y permiten a los usuarios incrustar otros
controles dentro de ellos.

Diseñar programas utilizando Java beans

"¿Cómo utilizo Java Beans?" quiere saber el programador novato.
"Utilícelos en herramientas de desarrollo de aplicaciones" le recomiendan, "como
la herramienta beanbox que se proporciona con el Bean Development Kit”.
"Muéstreme cómo" dice el programador novato.

Después de haber descargado e instalado Bean Development Kit (BDK), puede

trabajar con los beans del beanbox de BDK. Asumiendo que ha instalado BDK en su
ruta de acceso predeterminada (C:\BDK), puede abrir el beanbox con el archivo
run.bat de la ruta C:\BDK\beanbox. Al ejecutar el archivo bat, se abre el beanbox.
 En la caja de herramientas (toolbox) puede ver los beans disponibles. Cuando
añade beans a una aplicación, aparecerán en la ventana del beanbox situados junto a
la toolbox. También puede utilizar la ventana Properties (propiedades) para definir las
propiedades que hayan sido diseñadas en un bean, y puede utilizar la ventana
Method Tracer para administrar la ejecución del método. Se puede dibujar un bean en
el beanbox arrastrando el ratón.

También puede conectar los beans de un beanbox, con el fin de crear una única
aplicación utilizando varios beans. Por ejemplo, podría conectar un botón al bean
Juggler para que cuando haga clic sobre este botón, el juggler deje de ejecutarse.

Primero, haga clic sobre el bean Button en el beanbox. La ventana Properties

mostrará las propiedades que puede establecer para este bean, incluyendo su etiqueta
(si desea añadir una nueva etiqueta para este botón, puede hacerlo en la ventana
Properties).
Para conseguir que el botón realice una acción cuando haga clic sobre él,
seleccione el elemento de menú Edit|Events|action|actionPerformed. Una vez lo haga,
aparece una línea roja entre la ubicación del ratón y el botón. Extienda esa línea hacia
el bean Juggler y haga clic sobre él. Así se conecta el botón y el bean Juggler.

Cuando hace clic sobre el bean Juggler, aparece el cuadro de diálogo Event
target, ofreciendo los métodos disponibles a los que se puede llamar en el bean
Juggler cuando se hace clic sobre el botón. Para este ejemplo, seleccione el método
stopJuggling para que el juggler deje de ejecutarse; después, haga clic sobre el
botón OK para cerrar el cuadro de diálogo Event Target.

Eso es todo. Ahora, cuando hace clic sobre el botón del beanbox, el juggler dejará
de ejecutarse.
¡Enhorabuena! Ya ha conectado dos beans, y por lo tanto, ha creado un nuevo
programa.

Cómo puede ejecutar este programa fuera del beanbox? Lea detenidamente la
sección siguiente.

Crear applets que utilizan Java beans

"De acuerdo" dice el programador novato. "He diseñado un applet con varios
beans y ahora quiero crear un archivo JAR que pretendo pueda utilizar quien lo
necesite. ¿Cómo puedo hacerlo?".
"Es muy fácil" respondo.
"Veamos cómo".
 Una vez ha diseñado un applet utilizando el beanbox, puede usar el elemento
MakeApplet del menú File para crear un archivo JAR que contenga su nuevo applet y
todos los bean que necesite. Cuando seleccione este comando de menú, se abre el
cuadro de diálogo Make an Applet. En él hay que fijar el nombre de archivo JAR
predeterminado, myApplet.jar, con a clase applet MyApplet. Al hacer clic sobre el
botón OK, se crea el archivo myApplet.jar.

Nota: si desea utilizar cualquiera de los bean que proporciona BDK en un archivo
applet JAR, tendrá que compilarlos primero y asegurarse de que el compilador Java
puede localizar sus archivos de clase. Encontrará estos bean en
C:\BDK\demo\sunw\demo. Además, necesitará compilar el archivo AppletSupport.java
en C:\BDK\beanbox\sunw\beanbox y asegurarse de nuevo de que el compilador Java
localiza los archivos de clase resultantes.

El archivo myApplet.jar puede utilizarse en navegadores Web y en Sun

appletviewer. Observe un ejemplo de página HTML que utilizaré en myApplet.jar:

<HTML>

<HEAD>
<TITLE>Ejemplo de applet beans</TITLE>
</HEAD>

<BODY>
<APPLET
CODE=MyApplet.class
WIDTH=200
HEIGHT=200>
<PARAM NAME=archive VALUE="myApplet.jar">
</APPLET>
</BODY>

</HTML>

Ahora ya sabe cómo utilizar Java beans en applets.

Crear un Java bean

Ahora, el programador novato aparece y dice:

"Ya he utilizado Java beans, pero ahora quiero crear mis propios bean".
A lo que le responde "Bueno, no es muy difícil, pero lleva un poco de trabajo".
"¿Sí? ¡vamos a comprobarlo!".

Crearemos un sencillo Java bean para ver cómo funciona. Este bean se limitará a
cambiar para mostrarse en color rojo, y mostrará una cuenta del número de veces que
se ha hecho clic sobre él.
 Situaremos este bean en los directorios de demostración de BDK, de modo que
hay que crear un directorio llamado bean (C:\BDK\demo\sunw\demo\bean) y
guardaremos los archivos de clase de ese bean en ese directorio. Ejecute el código,
bean.java, indicando que este bean forma parte de un paquete llamado
sunw.demo.bean:

package sunw.demo.bean;
import java.awt.*;
import java.awt.event.*;
.
.
.

Mientras permanece activa la clase actual del bean, utilice la clase Canvas para
dibujar el propio bean (también puede usar otras clases, como la clase Panel). El resto
del código es bastane sencillo y se utiliza de manera ordinaria; se añade un
controlador de ratón para registrar los clic del ratón, y se define el tamaño del lienzo ( y
por lo tanto, en tamaño del bean):

package sunw.demo.bean;
import java.awt.*;
import java.awt.event.*;

public class bean extends Canvas

{
int count;

public bean()
{
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me) {
clicked();
}
});
count = 0;
setSize(200, 100);
}
.
.
.
}
 Finalmente, es necesario implementar el método que administra los clic del ratón,
y dibujar el bean, incluyendo el registro de clics, en el método paint:

package sunw.demo.bean;
import java.awt.*;
import java.awt.event.*;

public class bean extends Canvas

{
int count;

public bean()
{
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me) {
clicked();
}
});
count = 0;
setSize(200, 100);
}

public void clicked()

{
count++;
repaint();
}

public void paint(Graphics g)

{
Dimension dimension = getSize();
int height = dimension.height;
int width = dimension.width;

g.setColor(new Color(255, 0, 0));

g.fillRect(0, 0, --width, --height);

g.setColor(new Color(0, 0, 0));

g.drawString("Click count = " + count, 50, 50);
}
}

Crear un archivo de manifiesto bean

El programador novato sigue queriendo aprender:

"De acuerdo, he escrito el código para mi nuevo Java bean, ¿pero ahora qué?".
Sonríes y dices: "Tienes que empaquetar el bean en un archivo JAR y especificar
que se trata de un bean del archivo de manifiesto del archivo JAR".
"¡Cuéntame más!" dice el programador novato.
 Para convertir un bean en lo que es, debe almacenar los archivos de clase a
utilizar en el archivo JAR, y utilizar un manifiesto para especificar qué clases son
beans. Para ver cómo funciona esto, utilizaremos el bean desarrollado en la sección
anterior y crearemos un archivo de manifiesto, bean.mft. Situaremos este archivo de
manifiesto en C:\BDK\demo para crear de un modo más sencillo el archivo JAR (ver la
sección siguiente).

Para especificar que una clase de un archivo JAR es un Java bean, tiene que
pasar sus atributos Java-Bean a True. El archivo de clase se encuentra en el paquete
sunw.demo.bean, lo que significa que se almacenará en el archivo JAR como
sunw/demo/bean/bean (al igual que UNIX, los archivos JAR utilizan barras inclinadas
como separaciones de directorio). Para especificar que este archivo de clase es un
bean, observe cómo queda el archivo de manifiesto, bean.mft:

Name: sunw/demo/bean/bean.class
Java-Bean: True

En la sección siguiente creará el archivo JAR para este bean.

Crear un archivo Jar para bean

Ahora, el programador novato dice:

"De acuerdo, ya tengo los archivos de clase para mi nuevo bean, y el archivo de
manifiesto que deseo utilizar. ¿Ahora qué?";
A lo que le contestas "Ahora, ya estás preparado para utilizar una herramienta
jar".

A continuación, creará el archivo JAR para el bean que ha venido desarrollando

en las dos secciones anteriores. Primero, compile bean.java, que creará dos archivos
de clase: bean.class y bean$1.class. Copie esos archivos a
C:\BDK\demo\sunw\demo\bean. A continuación, sitúe el archivo de manifiesto
desarrollado en la sección anterior, bean.mft, en C:\BDK\demo. Ya está listo.
Asegúrese que se encuentra en el directorio C:\BDK\demo y utilice la herramienta jar
de este modo:

C:\BDK\demo>jar cfm ..\jars\bean.jar bean.mft sunw\demo\bean\*.class

Esto sirve para crear el Nuevo archivo JAR para este bean, bean.jar, y lo
almacena en el directorio C:\BDK\demo\jars, que es donde el beanbox lo buscará. Así
es como se instala un bean (situando su archivo JAR en ese directorio).
 Utilizar un nuevo bean
Hasta aquí se ha desarrollado un nuevo Java bean y se ha instalado en el
directorio C:\BDK\demo\jars. Cuando abra el beanbox, verá este bean en la lista
toolbox.
Este nuevo Java bean es un buen comienzo, pero ahora podría intentar algo más,
como añadirle otros controles Java.

Añadir controles a los bean

"No pretendo reinventar la rueda", dice el programador novato.

"¿Qué quieres decir?" insistimos.
"Bueno, si quiero añadir un botón a mi nuevo Java bean, ¿por qué tengo que
dibujarlo y desarrollarlo por mí mismo? ¿Por qué no puedo usar simplemente un botón
Java estándar? “
"Sí que puedes..."

Puede añadir controles Java como botones a sus bean (sólo tiene que asegurarse
en relacionar su bean en una clase que sea un contenedor, como la clase Panel).
Vea un ejemplo en el que se ha añadido un botón a un bean para que éste
muestre el número de veces que se ha hecho clic sobre él. Comience ubicando este
bean, que en este ejemplo llamaremos botón, a la clase Panel y añádalo al paquete
sunw.demo.button (lo que significa que guardará sus archivos de clase en
C:\BDK\demo\sunw\button). Observe cómo crear el panel, modificar su tamaño y
añadir un botón:

package sunw.demo.button;
import java.awt.*;
import java.awt.event.*;

public class button extends Panel implements ActionListener

{
int count;
Button button1;

public button()
{
count = 0;
setSize(200, 100);

button1 = new Button("Click me");

button1.addActionListener(this);

add(button1);
}
 Se trata de activar el botón incrementando el contador de clics, rediseñando el
bean para que muestre el contador y creando el método paint:

package sunw.demo.button;
import java.awt.*;
import java.awt.event.*;

public class button extends Panel implements ActionListener

{
int count;
Button button1;

public button()
{
count = 0;
setSize(200, 100);

button1 = new Button("Click me");

button1.addActionListener(this);

add(button1);
}

public void actionPerformed(ActionEvent e)

{
count++;
repaint();
}

public void paint(Graphics g)

{
Dimension dimension = getSize();
int height = dimension.height;
int w = d.width;
g.setColor(new Color(255, 0, 0));
g.fillRect(0, 0, w-1, h-1);

g.setColor(new Color(0, 0, 0));

g.drawString("Click count = " + count, 50, 50);
}
}

Como puede ver, es bastante sencillo añadir controles Java a un bean.

 Asignar propiedades a un bean
"Observo que se pueden ajustar las propiedades de un bean en el beanbox desde
la ventana Properties" dice el programador novato.
"Así es" le respondes.

Las propiedades de un bean le permiten configurarlo, ajustar su tamaño, color y

cualquier otro aspecto del bean ajustable mediante las propiedades. Existe un
procedimiento formal que debería seguirse para informar a la programación Java de
las propiedades de los beans: implementarla interfaz BeanInfo. Los campos de esta
interfaz se muestran en la tabla B.1 , y sus métodos en la tabla B.2.

Tabla B.1 . Campos de la interfaz BeanInfo

Campo Hace esto

static int ICON_COLOR_16x16 Indica un icono en color de 16 x 16.
static int ICON_COLOR_32x32 Indica un icono en color de 32 x 32.
static int ICON_MONO_16x16 Indica un icono monocromo de 16 x 16.
static int ICON_MONO_32x32 Indica un icono monocromo de 32 x 32

Tabla B.2 . Métodos de la interfaz BeanInfo

Método Hace esto

BeanInfo[ ] getAdditionalBeanInfo( )
BeanDescriptor getBeanDescriptor( )
int getDefaultEventIndex( )
int getDefaultPropertyIndex( )
EventSetDescriptor[
getEventSetDescriptors( )
Image getIcon(int iconKind)
MethodDescriptor[ ] getMethodDescriptors( Obtiene MethodDescriptors del bean.
)
PropertyDescriptor[
getPropertyDescriptors( )
Devuelve una colección arbitraria de otros
objetos BeanInfo.
Devuelve el BeanDescriptor del bean.
Obtiene el evento predeterminado. Un bean
puede tener un evento predeterminado que
será el que se utilice con más asiduidad.
Obtiene el índice de la propiedad
predeterminada. Un bean puede tener una
propiedad predeterminada que será la más
utilizada para las actualizaciones.
] Obtiene EventSetDescriptors del bean.
Devuelve un objeto de imagen que puede
utilizarse para representar al bean en
cuadros de herramientas, barras de
herramientas, etc.
] Genera PropertyDescriptors del bean.
 De hecho, la mayoría de los beans no implementan la interfaz BeanInfo
directamente. En su lugar, extienden la clase SimpleBeanInfo, que implementa
BeanInfo. Este es el árbol de herencia de SimpleBeanInfo:

java.lang.Object
|____java.beans. SimpleBeanInfo

Encontrará el constructor de la clase SimpleBeanInfo en la tabla B.3. y sus

métodos en la B.4.

Para describir una propiedad, utilice la clase PropertyDescriptor, derivada de la

clase FeatureDescriptor. Este es el árbol de herencia de la clase FeatureDescriptor:

java.lang.Object
|____java.beans. FeatureDescriptor

Encontrará el constructor de la clase FeatureDescriptor en la tabla B.5. y sus

métodos en la B.6.

Tabla B.3. Constructor de la clase SimpleBeanInfo

Constructor Descripción
SimpleBeanInfo( ) Construye un objeto BeanInfo.

Tabla B.4 . Métodos de la clase SimpleBeanInfo

Método Descripción
BeanInfo[ ] getAdditionalBeanInfo( ) Implementado para indicar que n hay otros
objetos BeanInfo relevantes.
BeanDescriptor getBeanDescriptor( ) Implementado para indicar que no existe
descriptor.
int getDefaultEventIndex( ) Implementado para ocultar la existencia de
un evento predeterminado.
int getDefaultPropertyIndex( ) Implementado para ocultar la existencia de
una propiedad predeterminada.
EventSetDescriptor[ ] Implementado para ocultar la existencia de
getEventSetDescriptors( ) conjuntos de eventos.
Image getIcon(int iconKind) Implementado para negar que no existen
iconos disponibles.
MethodDescriptor[ ] getMethodDescriptors( Implementado para negar la existencia de
) métodos.
PropertyDescriptor[ ] Implementado para negar la existencia de
getPropertyDescriptors( ) propiedades.
Image loadImage(String resourceName) Método usado para ayudar en la carga de
imagines de iconos.
 Tabla B. 5 . Constructor de la clase FeatureDescriptor
Constructor
FeatureDescriptor( )
Tabla B. 6 . Métodos de la clase FeatureDescriptor
Método
Enumeration attributeNames( )
String getDisplayName( )
String getName( )
String getShortDescription( )
Object getValue(String attributeName)
boolean isExpert( )
boolean isHidden( )
boolean isPreferred( )
void setDisplayName(String displayName)
void setExpert(boolean expert)
void setHidden(boolean hidden)
void setName(String name)
void setPreferred(boolean preferred)
void setShortDescription(String text)
void setValue(String attributeName, Object Se puede asociar un atributo.
value)
Descripción
Construye un FeatureDescriptor.
Descripción
Obtiene un detalle de los nombres
predeterminados de este atributo.
Visualiza el nombre personalizado de este
atributo.
Devuelve el nombre programático de este
elemento.
Obtiene la descripción breve de este
elemento.
Recupera un nombre de atributo mediante
esta utilidad.
Devuelve el valor True en elementos
pensados par usuarios expertos.
Devuelve el valor True en elementos
pensados para ser usados como una
herramienta.
Devuelve el valor True en elementos
particularmente importantes para ser
presentados a otros usuarios.
Define el nombre visualizado y localizado de
este elemento.
Define a un elemento como "de uso por
expertos".
Define a un elemento como "de uso sólo
como herramienta".
Establece el nombre de este elemento.
Marca elementos especialmente importantes
para mostrárselos a otros usuarios.
Se puede asociar una breve cadena a modo
de descripción.
 Este es el árbol de herencia de la clase PropertyDescriptor:

java.lang.Object
|____java.beans.FeatureDescriptor
|____java.beans.PropertyDescriptor

Encontrará los constructores de la clase PropertyDescriptor en la tabla B.7. y

sus métodos en la tabla B. 8.

Tabla B. 7 . Constructores de la clase PropertyDescriptor

Constructor Descripción
PropertyDescriptor(String propertyName, Construye un PropertyDescriptor.
Class beanClass)
PropertyDescriptor(String propertyName, Toma el nombre de una propiedad sencilla
Class beanClass, String getterName, además de nombres de método para leer y
String setterName)ç escribir la propiedad.
PropertyDescriptor(String propertyName, Toma el nombre de una propiedad sencilla
Method getter, Method setter) además de objetos Method para leer y
escribir la propiedad.

Tabla B. 8 . Métodos de la clase PropertyDescriptor

Método
Class getPropertyEditorClass( )
Class getPropertyType( )
Method getReadMethod( )
Method getWriteMethod( )
boolean isBound( )
boolean isConstrained( )
void setBound(boolean bound)
void setConstrained(boolean constrained)
void setPropertyEditorClass(Class Normalmente, PropertyEditors será
propertyEditorClass)
Descripción
Genera una clase PropertyEditor explícita
que ha sido registrada para esta propiedad.
Obtiene el objeto Class de la propiedad.
Obtiene el método que debería utilizarse
para leer el valor de la propiedad.
Obtiene el método que debería utilizarse
para escribir el valor de la propiedad.
Actualiza las propiedades que activen el
evento PropertyChange.
Intenta actualizar las propiedades que
activen el evento VetoableChange.
Intenta actualizar las propiedades que
activen el evento PropertyChange.
Intenta actualizar las propiedades que
activen el evento VetoableChange.
localizado mediante
PropertyEditorManager.
void setReadMethod(Method getter) Establece el método que debería utilizarse
para leer el valor de la propiedad.
void setWriteMethod(Method setter) Establece el método que debería utilizarse
para escribir el valor de la propiedad.

Ahora, eche un vistazo a un ejemplo donde se implementa una propiedad en un

Java bean. En este caso, se añadirá una propiedad llamada filled a la operación de
registro de clics del ratón desarrollada anteriormente. Se trata de una propiedad
booleana que, cuando está definida en True, asegura que el bean será rellenado de
color. A este nuevo bean le llamaremos Bean2.

Para mantener un registro de la nueva propiedad filled, añadirá una variable

privada booleana de dicho nombre a la clase Bean2:

package sunw.demo.bean2;
import java.awt.*;
import java.awt.event.*;

public class Bean2 extends Canvas

{
private boolean filled;
.
.
.

Inicialice esta propiedad al valor False cuando cree el bean:

package sunw.demo.bean2;
import java.awt.*;
import java.awt.event.*;

public class Bean2 extends Canvas

{
private boolean filled;
int count;

public Bean2()
{
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me)
{
clicked();
}
 });

count = 0;
filled = false;
setSize(200, 100);
}
.
.
.
}

Al implementar una propiedad, Java buscará dos métodos: getPropertyName y

setPropertyName, donde PropertyName es el nombre de la propiedad. El método
get devuelve el valor actual de la propiedad, que puede ser de cualquier tipo
soportado, mientras el método set toma un argumento de ese tipo, al quie se supne
vamos a vincular dicha propiedad. Así es como se implementan los métodos gtfilled y
setfilled:

package sunw.demo.bean2;
import java.awt.*;
import java.awt.event.*;

public class Bean2 extends Canvas

{
private boolean filled;
int count;

public Bean2()
{
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent me)
{
clicked();
}
});

count = 0;
filled = false;
setSize(200, 100);
}

public void clicked()

{
count++;
repaint();
}
 public boolean getfilled()
{
return filled;
}

public void setfilled(boolean flag)

{
this.filled = flag;
repaint();
}
.
.
.
}

Y lo que queda es activar la propiedad filled. Si está en True, el bean debería

rellenarse de color, de modo que este es el código a añadir al método paint:

public void paint(Graphics g)

{
Dimension dimension = getSize();
int height = dimension.height;
int width = dimension.width;

if(filled){
g.setColor(new Color(255, 0, 0));
g.fillRect(0, 0, --width, --height);
}

g.setColor(new Color(0, 0, 0));

g.drawString("Click count = " + count, 50, 50);
}

Ahora es necesario crear una nueva clase, Bean2BeanInfo, que devolverá

información sobre esta nueva propiedad del bean. Esta clase estará en el mismo
paquete que el propio bean, pero está basada en la clase SimpleBeanInfo:

package sunw.demo.bean2;
import java.beans.*;

public class Bean2BeanInfo extends SimpleBeanInfo

{
.
.
.
}
 Para que Java reconozca las propiedades, implemente el método
getPropertyDescriptors, que devuelve una cadena de objetos PropertyDescriptor.
Cada objeto PropertyDescriptor contiene el nombre de una propiedad y apunta hacia
la clase que soporta dicha propiedad. Así es como crearemos un objeto
PropertyDescriptor para la propiedad filled:

package sunw.demo.bean2;
import java.beans.*;

public class Bean2BeanInfo extends SimpleBeanInfo

{
public PropertyDescriptor[] getPropertyDescriptors()
{
try {
PropertyDescriptor filled = new
PropertyDescriptor("filled", Bean2.class);
.
.
.
}
catch(Exception e) {}

return null;
}
}

Ésta es la única propiedad de Bean2, de modo que añadimos el nuevo objeto

PropertyDescriptor a una secuencia de este modo:

package sunw.demo.bean2;
import java.beans.*;

public class Bean2BeanInfo extends SimpleBeanInfo

{
public PropertyDescriptor[] getPropertyDescriptors()
{
try {
PropertyDescriptor filled = new
PropertyDescriptor("filled", Bean2.class);
PropertyDescriptor propertydescriptor[] = {filled};
return propertydescriptor;
}
catch(Exception e) {}

return null;
}
}
 Una vez compilada esta nueva clase, (Bean2BeanInfo.java), se sitúa
Bean2BeanInfo.class en C:\BDK\demo\sunw\demo\bean2, junto con las clases que se
creqron al compilar Bean2.java. Ahora es necesario un nuevo archivo de manifiesto
que incluya la clase Bean2BeanInfo. Este es el aspecto de bean2.mft:

Name: sunw/demo/bean2/Bean2BeanInfo.class
Name: sunw/demo/bean2/Bean2.class
Java-Bean: True

A continuación, sitúe este nuevo manifiesto en C:\BDK\demo. Finalmente, así es

como se ha creado el nuevo archivo Bean2.jar y se ha instalado:

C:\BDK\demo>jar cfm ..\jars\bean2.jar bean2.mft sunw\demo\bean2\*.class

Ahora, al iniciar el beanbox y añadir un Nuevo Bean2 al beanbox, la nueva

propiedad filled aparecerá en la ventana Properties. Si activa el valor True para filled,
el bean será rellenado de color.

Asignar un icono a un bean

Es posible que haya observado que algunos beans muestran iconos en el beanbox.
Puede añadir sus propios iconos a los beans (todo lo que tiene que hacer es agregar
un método getIcon a la clase BeanInfo). Observe cómo implementar este método y de
qué manera administrar todas las posibilidades (iconos monocromo o en color, y de
16x16 ó 32x32 píxels):

public java.awt.Image getIcon(int iconKind)

{
if (iconKind == BeanInfo.ICON_MONO_16x16 ||
iconKind == BeanInfo.ICON_COLOR_16x16 ) {
java.awt.Image image = loadImage("Icon16.gif");
return image;
}

if (iconKind == BeanInfo.ICON_MONO_32x32 ||
iconKind == BeanInfo.ICON_COLOR_32x32 ) {
java.awt.Image image = loadImage("Icon32.gif");
return image;
}

return null;
}
APÉNDICE E)

Crear clientes y servidores TCP.-

De repente, aparece el Director General y dice: "Necesitamos un modo secreto de
comunicarnos por Internet con nuestros espías informáticos".
"Pero... ¿Tenemos espías?" preguntas.
Y el gran jefe dice: "Configure un programa cliente/servidor que permita
comunicarse a través de Internet y asegúrese de que todo está codificado".
"¡Vaya!...".

Utilizando los objetos BufferedReader y PrintWriter, puede comunicarse en

Internet con sockets; todo lo que necesita es una dirección DNS del servidor y un
puerto libre en dicho servidor (las direcciones DNS son grupos de cuatro números,
separados por puntos, que especifican direcciones de Internet).

Compruebe un ejemplo. En este caso, se configuró un programa cliente que se

conecta a un programa servidor, envía un mensaje, y obtiene un mensaje de
respuesta. En este caso, utilizaremos el DNS 127.0.0.1 (host local), lo que significa
que tanto el cliente como el servidor estarán en la misma máquina. Sin embargo,
puede utilizar cualquier DNS que desee mientras sitúe el script del servidor en la
máquina correspondiente. Usaremos un puerto arbitrario (el número 8765). Cuando
esté escogiendo un número de puerto, recuerde que ese puerto no puede estar en uso
y que tanto el cliente como el servidor se conectarán al mismo puerto. Esta es la
aplicación cliente, que envía el mensaje "¡Hola!" al servidor y lee lo que le devuelve
éste:

import java.net.*;
import java.io.*;

class client
{
public static void main(String args[]) throws Exception
{
int character;
Socket socket = new Socket("127.0.0.1", 8765);

InputStream in = socket.getInputStream();
OutputStream out = socket.getOutputStream();

String string = "¡Hola!\n";

byte buffer[ ] = string.getBytes();
out.write (buffer);

while ((character = in.read()) != -1) {

System.out.print ((char) character);
}
socket.close( );
}
}
 Y ésta es la aplicación del servidor, que lee el mensaje del cliente y contesta al
mismo, después del mensaje "Respuesta del servidor":

import java.io.*;
import java.net.*;

public class server

{
public static void main(String[] args )
{
try {
ServerSocket socket = new ServerSocket (8765);

Socket insocket = socket.accept ( ) ;

BufferedReader in = new BufferedReader (new

InputStreamReader(insocket.getInputStream( ) ) );
PrintWriter out = new PrintWriter (insocket.getOutputStream(),
true);

String instring = in.readLine( );

out.println("Respuesta del servidor: " + instring);
insocket.close( );
}
catch (Exception e) { }
}
}

Para ejecutar estas aplicaciones, necesitará dos ventanas de trabajo (por ejemplo,
en Windows, abra dos ventanas de DOS). Ejecute primero el servidor en una ventana,
y después el cliente en la otra. Cuando lo haga, observe lo que muestra el cliente:

C:\>java client
Respuesta del servidor: ¡Hola!

Como puede ver, el cliente envía su mensaje al servidor, que devuelve un

mensaje de confirmación. Ahora ya puede preparar aplicaciones cliente/servidor
para Internet en Java.
APÉNDICE D)

Crear y utilizar sockets.-

"Muy bien", dice el programador novato, "Quiero comenzar a trabajar en Internet de

un a manera sencilla y personalizada".
"¿Está seguro?" responde. "Lo estoy", dice el programador novato.
"En tal caso" responde, "Prueba con la clase Socket".

La comunicación a través de Internet requiere sockets para crear las conexiones.

Los sockets se conectan a puertos de comunicaciones numerados. Los 1,024 puertos
inferiores se reservan para uso del sistema (por ejemplo, el puerto 21 es para FTP, el
23 para Telnet, el 25 para correo electrónico, el 80 para conexiones http, y el 119 para
conexiones Usenet).
Java soporta sockets mediante la clase Socket. Observe el diagrama de herencia para
la clase Socket:

java.lang.Object
|____java.net.Socket

En la siguiente tabla, la tabla D.1., encontrará los constructores de la clase Socket; y

sus métodos en la tabla D.2.:

Tabla D.1. Constructores de la clase Socket

Constructor Descripción
protected Socket( ) Construye un socket no conectado.
Socket(InetAddress address, int Construye un socket stream y lo conecta al
port) Puerto indicado en la dirección IP.
Socket(InetAddress host, int port, Obsoleto. Utilice DatagramSocket en su lugar.
boolean stream)
Socket(InetAddress address, int Construye un socket .y lo conecta a la dirección
port, InetAddress localAddr, int remota indicada en el puerto remoto
localPort)
protected Socket(SocketImpl impl) Construye un socket desconectado mediante la
clase abstracta SocketImpl.
Socket(String host, int port) Construye un socket stream y lo conecta al
número de Puerto indicado en el host.
Socket(String host, int port, boolean Obsoleto. Use DatagramSocket en su lugar.
stream)
Socket(String host, int port, Construye un socket y lo conecta al host remoto
InetAddress localAddr, int localPort) indicado en el Puerto remoto.
 Tabla D. 2. Métodos de la clase Socket

Método
void close( )
InetAddress getInetAddress( )
InputStream getInputStream( )
InetAddress getLocalAddress( )
int getLocalPort( )
OutputStream getOutputStream( )
int getPort( )
int getReceiveBufferSize( )
int getSendBufferSize( )
int getSoLinger( )
int getSoTimeout( )
boolean getTcpNoDelay( )
void setReceiveBufferSize(int size)
void setSendBufferSize(int size)
static void Establece la implementación del socket cliente.
setSocketImplFactory(SocketImplFa
ctory fac)
void setSoLinger(boolean on, int Activa/desactiva SO_LINGER
linger) tiempo medido en segundos.
void setSoTimeout(int timeout)
void setTcpNoDelay(boolean on)
String toString( )
Descripción
Cierra este socket.
Obtiene la dirección a la que está conectado el
socket.
Obtiene un stream de entrada (input) para este
socket.
Devuelve la dirección local a la que está unido el
socket.
Devuelve el puerto local al que está unido el
socket.
Obtiene un stream de salida (output) para este
socket.
Localiza el Puerto remoto al que está conectado el
socket.
Obtiene el valor de la opción SO_RCVBUF para
este socket (el tamaño del buffer de entrada).
Obtiene el valor de la opción SO_SNDBUF para
este socket (el tamaño del buffer de salida).
Genera el ajuste de SO_LINGER.
Genera el ajuste de SO_TIMEOUT.
Prueba si TCP_NODELAY está activo.
Ajusta la opción de SO_RCVBUF al valor
indicado.
Ajusta la opción de SO_SNDBUF al valor
indicado.
transcurrido un
Activa/desactiva SO_TIMEOUT transcurridos x
milisegundos..
Activa/desactiva TCP_NODELAY.
Convierte este socket en un string (cadena).

Observe un ejemplo. En este caso, se conectará al puerto 80 de sun.com, el puerto

http, y accederá a la página Web principal en www.sun.com, index.html, escribiendo
una solicitud http a dicho puerto. Para escribir en un socket, puede utilizar el objeto
PrintWriter, y para leer desde él, el objeto BufferedReader.
Compruebe el código (observe que se ha terminado la solicitud http con dos
caracteres de nueva línea):

Import java.io.*;
import java.net.*;

public class sockets

{
public static void main(String[] args)
{
try {
Socket s = new Socket("www.sun.com", 80);

BufferedReader in = new BufferedReader(new

InputStreamReader(s.getInputStream()));
PrintWriter out = new PrintWriter(s.getOutputStream());

out.print("GET /index.html\n\n");
out.flush();

String line;

while ((line = in.readLine()) != null){

System.out.println(line);
}

} catch (Exception e){}

}
}

Y éste es el resultado de este código:

C:\>java sockets
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
"http://www.w3.org
/TR/REC-html40/loose.dtd">
<HTML>
<HEAD>
<TITLE>Sun Microsystems</TITLE>
.
.
.

Este ejemplo utilizó el Puerto HTTP del servidor Web de Sun para conectarse. Sin
embargo, puede generar ambos lados de la conexión (el cliente y el servidor) en Java.
Para ello, lea el apartado dedicado a clientes/servidores TCP.
APÉNDICE C)

Establecer las opciones de seguridad

"¡Vaya!" dice el programador novato, "¿Por qué no puedo escribir un archivo

desde un applet?"
"Por razones de seguridad" le responde. "Pero si realmente quiere hacerlo, puede
cambiarlo".
"Entonces, ¿cómo hacerlo?".

Puede utilizar la herramienta de seguridad de Java (Java policy tool) para cambiar
las preferencias de seguridad. Por ejemplo, puede hacer que los applets lean y
escriban archivos (normalmente no tienen acceso a los archivos, pues cuando un
usuario abre un applet en un navegador, no es de esperar que nadie desee modificar
archivos del sistema). Observe un ejemplo de un applet llamado writer.java que intenta
escribir un archivo:

import java.applet.Applet;
import java.awt.*;
import java.io.*;

/*
<APPLET
CODE=writer.class
WIDTH=300
HEIGHT=200 >
</APPLET>
*/

public class writer extends Applet

{
public void init()
{
byte data[] = "Esta es una cadena de texto.".getBytes();

try {
FileOutputStream fileoutputstream = new
FileOutputStream("file.txt");
fileoutputstream.write(data);
fileoutputstream.close();
} catch (Exception e) {
System.out.println("Error: " + e);
}
}
}
 Si intenta ejecutar este applet así, obtendrá un error de violación de seguridad en
la pantalla, y el applet no se iniciará. Sin embargo, puede cambiarlo mediante la
herramienta de seguridad, que le permite especificar ajustes de seguridad.

Nota: Debe ser muy cuidadoso al definir ajustes de seguridad en Java, no sea que
cause más problemas de los deseados.

Inicie la herramienta de seguridad escribiendo "policytool" en pantalla. Para añadir

un nuevo ajuste en writer.class, haga clic sobre el botón Add Policy Entry de la
herramienta de seguridad, y se abrirá el cuadro de diálogo Policy Entry.

En él, escriba el nombre del URL del applet o la aplicación donde desea
establecer los ajustes de seguridad (se podría utilizar file://URL, aunque también
puede especificar http://URL), y haga clic sobre el botón Add permission (agregar
permisos) para que aparezca el cuadro de diálogo Permissions. En este caso,
suponga que desea establecer permisos de escritura para el archivo writer.class, de
modo que seleccione la opción FilePermission, <<ALL FILES>> y comience a escribir
(no es necesario que rellene la línea Signed By a menos que el código haya sido
firmado digitalmente).

Ahora, haga clic sobre el botón OK para cerrar el cuadro de diálogo Permissions y
haga clic sobre el botón Done para cerrar el cuadro de diálogo Policy Entry. Ahora
aparecerá el nuevo valor de seguridad en la herramienta de seguridad. Además, debe
guardar en un archivo el nuevo valor de seguridad, concretamente en el archivo
c:\Windows\.java.policy.

Eso es todo. Cuando establezca un valor de seguridad en un programa

proporcionando el URL del mismo, puede conceder toda clase de permisos en el
programa. En este caso, el applet de escritura ahora puede crear el archivo file.txt y
escribir este texto en él:

Ésta es una cadena de texto.

APÉNDICE F)

Utilizar la conectividad de bases de datos de Java

(JDBC) .

De repente, aparece de nuevo el gran jefe y dice: "Necesitamos conectarnos a

una fuente de datos ODBC".
"¡Buena suerte!" dices;
"No tan buena..." responde el jefazo;
"Tienes dos días para conseguirlo".

Puede utilizar la conectividad de bases de datos de Java (JDBC), según figura en

el paquete java.sql, para conectar una fuente de datos para bases de datos, como una
fuente de datos ODBC. Así funciona: se obtiene una conexión a una fuente de base
de datos mediante un objeto que implementa la interfaz Connection, se ejecuta una
sentencia SQL en la fuente de datos mediante un objeto que implementa la interfaz
Statement, y se obtiene un resultado desde la fuente de datos, como un objeto que
implementa la interfaz ResultSet.

En la tabla F. 1. encontrará los Campos de la interfaz Connection, y sus métodos

en la tabla F. 2.; los métodos de la interfaz Statement en la tabla F. 3.; y los campos
de la interfaz ResultSet en la tabla F. 4. y sus métodos en la tabla F. 5.

Tabla F. 1. Campos de la interfaz Connection

Campo
static int TRANSACTION_NONE
Static int
TRANSACTION_READ_COMMITTED
Static int
TRANSACTION_READ_UNCOMMITTED
Static int
TRANSACTION_REPEATABLE_READ
static int TRANSACTION_SERIALIZABLE
Descripción
Indica que las transacciones no son
soportadas.
Se evitan las lecturas parciales; pueden
existir lecturas no repetitivas o fantasmas.
Pueden ocurrir lecturas parciales o no
repetitivas o fantasmas.
Se evitan las lecturas parciales y las no
repetitivas; pueden darse lecturas fantasma.
Pueden darse lecturas parciales, evitándose
las no repetitivas y las fantasma.
 Tabla F. 2. Métodos de la interfaz Connection

Método ¿Qué hace?

void clearWarnings( )
void close( )
void commit( )
Statement createStatement( )
Statement createStatement(int
resultSetType, int resultSetConcurrency)
boolean getAutoCommit( )
String getCatalog()
DatabaseMetaData getMetaData( )
int getTransactionIsolation( )
Map getTypeMap( )
SQLWarning getWarnings( )
boolean isClosed( )
boolean isReadOnly( )
String nativeSQL(String sql)
CallableStatement prepareCall(String sql)
CallableStatement prepareCall(String sql, int Devuelve un objeto CallableStatement
resultSetType, int resultSetConcurrency)
PreparedStatement prepareStatement(String Genera un objeto PreparedStatement
sql)
PreparedStatement prepareStatement
(String sql, int resultSetType, int result
SetConcurrency)
Elimina los avisos.
Genera una base de datos de conexión y
recursos JDBC.
Establece los cambios desarrollados desde
el último volcado.
Construye un objeto Statement para
enviar sentencias SQL a la base de datos.
Construye un objeto Statement que
generará objetos ResultSet.
Obtiene el estado autocommit actual.
Obtiene el nombre del catálogo de la
conexión actual.
Devuelve metadatos sin tener en cuenta la
base de datos d la conexión.
Devuelve el nivel de aislamiento de la
transacción actual.
Obtiene el tipo de objeto mapa asociado a
esta conexión.
Genera el primer aviso indicado por
llamadas a esta conexión.
Prueba si una conexión está cerrada.
Prueba si la conexión está en modo de
solo lectura.
Convierte la sentencia SQL dada en la
gramática SQL nativa del sistema.
Genera un objeto CallableStatement en
procedimientos guardados.
que generará objetos ResultSet.
para enviar sentencias SQL
parametrizadas a las base de datos.
Obtiene un objeto PreparedStatement que
generará objetos ResultSet.
void rollback( ) Descarta los cambios realizados desde el
último volcado.
void setAutoCommit(boolean autoCommit) Fija el modo AutoCommit para esta
conexión.
void setCatalog(String catalog) Establece un nombre del catálogo en la
base de datos.
void setReadOnly(boolean readOnly) Señala esta conexión como de sólo
lectura.
void setTransactionIsolation(int level) Intenta cambiar el nivel de aislamiento de
la transacción.
void setTypeMap(Map map) Instala el tipo de mapa dado.

Tabla F. 3. Métodos de la interfaz Statement

Método Descripción
void addBatch(String sql) Añade un comando SQL a la cadena de
comandos actual.
void cancel( ) Cancela este objeto Statement.
void clearBatch( ) Vacía el conjunto de comandos del proceso
actual.
void clearWarnings( ) Elimina todos los avisos.
void close( ) Cierra esta base de datos del objeto
Statement y los recursos JDBC.
boolean execute(String sql) Ejecuta una sentencia SQL que puede
devolver múltiples resultados.
int[] executeBatch( ) Envía a la base de datos un lote de
comandos para su ejecución.
ResultSet executeQuery(String sql) Ejecuta una sentencia SQL que devuelve un
único ResultSet.
int executeUpdate(String sql) Ejecuta una sentencia SQL INSERT,
UPDATE o DELETE.
Connection getConnection( ) Devuelve el objeto Connection que produjo
este objeto Statement.
int getFetchDirection( ) Define la dirección de búsqueda de las filas
en las tablas de la base de datos.
int getFetchSize( ) Obtiene el número de conjuntos de filas
como tamaño de búsqueda predeterminado.
int getMaxFieldSize( ) Devuelve el número máximo de bytes
permitido en los valores de una columna.
int getMaxRows( )
boolean getMoreResults( )
int getQueryTimeout( )
ResultSet getResultSet( )
int getResultSetConcurrency( )
int getResultSetType( )
int getUpdateCount( )
SQLWarning getWarnings( )
void setCursorName(String name)
void setEscapeProcessing(boolean enable) Activa o desactiva la opción Escape.
void setFetchDirection(int direction)
void setFetchSize(int rows)
void setMaxFieldSize(int max)
void setMaxRows(int max)
void setQueryTimeout(int seconds)
Genera el número máximo de filas para
ResultSet.
Va al siguiente resultado de una sentencia.
Genera el número de segundos que
esperará el controlador para que se ejecute
una sentencia.
Devuelve el resultado como objeto
ResultSet.
Genera un conjunto de resultados
simultáneamente.
Obtiene el tipo del conjunto de resultados.
Devuelve el resultado actual como una
cuenta actualizada. Si el resultado es un
ResultSet o no hay más resultados, se
devuelve el valor -1.
Genera el primer aviso repostado por
llamadas hacia esta sentencia.
Define el nombre del cursor SQL.
Define la dirección de búsqueda.
Establece el número de filas que deberían
establecerse cuando se necesitan más filas.
Define el límite para el máximo número de
filas de una columna.
Define el límite para el máximo número de
filas que puede contener cualquier
ResultSet.
Selecciona el número de segundos que
esperará el controlador para que se ejecute
una sentencia.
 Tabla F. 4 . Campos de la interfaz ResultSet
Campo
static int CONCUR_READ_ONLY
static int CONCUR_UPDATABLE
static int FETCH_FORWARD
static int FETCH_REVERSE
static int FETCH_UNKNOWN
static int TYPE_FORWARD_ONLY
static int TYPE_SCROLL_INSENSITIVE
static int TYPE_SCROLL_SENSITIVE
Tabla F. 5. Métodos de la interfaz ResultSet
Método
boolean absolute(int row)
Void afterLast( )
Void beforeFirst( )
Void cancelRowUpdates( )
Void clearWarnings( )
Void close( )
Void deleteRow( )
int findColumn(String columnName)
Descripción
Modo simultáneo para objetos que pueden
no ser actualizados.
Modo simultáneo para un objeto ResultSet
que puede ser actualizado.
Indica qué filas serán procesadas, de
principio a fin.
Define qué filas de un conjunto de
resultados serán procesadas, de la última a
la primera.
Define si el orden de proceso de un conjunto
de resultados es desconocido.
Establece que el cursor sólo se pueda
mover hacia adelante.
Define que un objeto ResultSet pueda sufrir
desplazamiento, pero no sea sensible a los
cambios hechos por otros.
Define que un objeto ResultSet pueda sufrir
desplazamiento, y también sea sensible a
los cambios hechos por otros.
Descripción
Se mueve hacia una fila absoluta.
Se mueve hasta después del ultimo registro.
Se mueve hasta antes del primer registro.
Cancela las actualizaciones hechas en una
fila.
Elimina todos los avisos.
Cierra la base de datos del objeto ResultSet
y los recursos JDBC.
Borra la fila actual del conjunto de resultados
y la base de datos subyacente.
Mapea el nombre de la columna ResultSet
para su índice de columna ResultSet.
boolean first( )
Array getArray(int i)
Array getArray(String colName)
InputStream getAsciiStream(int
columnIndex)
InputStream getAsciiStream(String
columnName)
BigDecimal getBigDecimal(int
columnIndex)
BigDecimal getBigDecimal(int
columnIndex, int scale)
BigDecimal getBigDecimal(String
columnName)
BigDecimal getBigDecimal(String
columnName, int scale)
InputStream getBinaryStream(int
columnIndex)
InputStream getBinaryStream(String
columnName)
Blob getBlob(int i)
Blob getBlob(String colName)
boolean getBoolean(int columnIndex)
boolean getBoolean(String columnName)
byte getByte(int columnIndex)
byte getByte(String columnName)
Se mueve al primer registro.
Obtiene un valor SQL ARRAY de la fila
actual de este objeto ResultSet.
Obtiene un valor SQL ARRAY en la fila
actual de este objeto ResultSet.
Devuelve el valor de una columna en la fila
actual como una cadena de caracteres
ASCII.
Devuelve el valor de una columna en la fila
actual como una cadena de caracteres
ASCII
Devuelve el valor de una columna en la fila
actual como un objeto
java.math.BigDecimal con total precisión.
Obsoleto.
Genera el valor de una columna en la fila
actual como un objeto
java.math.BigDecimal con total precisión.
Obsoleto.
Devuelve el valor de una columna en la fila
actual como una cadena de bytes sin
interpretar.
Devuelve el valor de una columna en la fila
actual como una cadena de bytes sin
interpretar.
Define un valor BLOB (Binary Large Object,
o gran objeto en formato binario) en la fila
actual de este objeto ResultSet.
Define un valor BLOB (Binary Large Object,
o gran objeto en formato binario) en la fila
actual de este objeto ResultSet.
Establece el valor de una columna de la fila
actual como booleano Java.
Establece el valor de una columna de la fila
actual como booleano Java.
Establece el valor de una columna de la fila
actual como un byte Java.
Establece el valor de una columna de la fila
actual como un byte Java.
byte[] getBytes(int columnIndex)
byte[] getBytes(String columnName)
Reader getCharacterStream(int
columnIndex)
Reader getCharacterStream(String
columnName)
Clob getClob(int i)
Clob getClob(String colName)
int getConcurrency( )
String getCursorName( )
Date getDate(int columnIndex)
Date getDate(int columnIndex, Calendar Devuelve el valor de una columna de la fila
cal)
Date getDate(String columnName)
Date getDate(String columnName, Devuelve el valor de una columna de la fila
Calendar cal)
double getDouble(int columnIndex)
double getDouble(String columnName)
int getFetchDirection( )
int getFetchSize( )
float getFloat(int columnIndex)
float getFloat(String columnName)
Establece el valor de una columna de la fila
actual como una cadena de bytes Java.
Establece el valor de una columna de la fila
actual como una cadena de bytes Java.
Devuelve una secuencia de caracteres
ordenada por índice de columna.
Devuelve una secuencia de caracteres
ordenada por nombre de columna.
Define un valor CLOB (Character Large
Object, o gran objeto en formato de
caracteres) en la fila actual de este objeto
ResultSet.
Define un valor CLOB (Character Large
Object, o gran objeto en formato de
caracteres) en la fila actual de este objeto
ResultSet.
Define el modo de concurrencia de este
conjunto de resultados.
Obtiene el nombre del cursor SQL utilizado
por este ResultSet.
Devuelve el valor de una columna de la fila
actual como un objeto java.sql.Date.
actual como un objeto java.sql.Date.
Devuelve el valor de una columna de la fila
actual como un objeto java.sql.Date.
actual como un objeto java.sql.Date.
Devuelve el valor de una columna de la fila
actual como un valor doble de Java.
Devuelve el valor de una columna de la fila
actual como un valor doble de Java.
Define la dirección de búsqueda para este
conjunto de resultados.
Define el tamaño de la búsqueda para este
conjunto de resultados.
Genera el valor de una columna de la fila
actual como un valor Java flotante.
Genera el valor de una columna de la fila
actual como un valor Java flotante.
int getInt(int columnIndex)
int getInt(String columnName)
long getLong(int columnIndex)
long getLong(String columnName)
ResultSetMetaData getMetaData( )
Object getObject(int columnIndex)
Object getObject(int i, Map map)
Object getObject(String columnName)
Object getObject(String colName,
map)
Ref getRef(int i)
Ref getRef(String colName)
int getRow( )
short getShort(int columnIndex)
short getShort(String columnName)
Statement getStatement( )
String getString(int columnIndex)
String getString(String columnName)
Time getTime(int columnIndex)
Time getTime(int columnIndex, Calendar Devuelve el valor de una columna de la fila
cal)
Genera el valor de una columna de la fila
actual como un valor Java int.
Genera el valor de una columna de la fila
actual como un valor Java int.
Genera el valor de una columna de la fila
actual como un valor Java long.
Genera el valor de una columna de la fila
actual como un valor Java long.
Devuelve el número, tipos y propiedades de
las columnas de ResultSet.
Genera el valor de una columna de la fila
actual como un objeto Java.
Genera el valor de una columna de la fila
actual como un objeto Java.
Genera el valor de una columna de la fila
actual como un objeto Java.
Map Devuelve el valor de la columna indicada
como un objeto Java.
Obtiene un valor de referencia de columna
de la fila actual.
Obtiene un valor de referencia de columna
de la fila actual según el nombre de
columna.
Genera una fila.
Devuelve el valor de una columna de la fila
actual como un Java short.
Devuelve el valor de una columna de la fila
actual como un Java short.
Genera la sentencia producida por el objeto
ResultSet.
Devuelve el valor de una columna de la fila
actual como un Java string.
Devuelve el valor de una columna de la fila
actual como un Java string.
Devuelve el valor de una columna de la fila
actual como un objeto java.sql.Time.
actual como un objeto java.sql.Time.
Time getTime(String columnName)
Time getTime(String columnName,
Calendar cal)
Timestamp getTimestamp(int columnIndex) Devuelve el valor de una columna de la fila
Timestamp getTimestamp(int columnIndex, Devuelve el valor de una columna de la fila
Calendar cal)
Timestamp getTimestamp(String
columnName)
Timestamp getTimestamp(String
columnName, Calendar cal)
int getType( )
InputStream getUnicodeStream(int
columnIndex)
InputStream getUnicodeStream(String
columnName)
SQLWarning getWarnings( )
void insertRow( )
boolean isAfterLast( )
boolean isBeforeFirst( )
boolean isFirst( )
boolean isLast( )
boolean last( )
void moveToCurrentRow( )
void moveToInsertRow( )
boolean next( )
boolean previous( )
Devuelve el valor de una columna de la fila
actual como un objeto java.sql.Time.
Devuelve el valor de una columna de la fila
actual como un objeto java.sql.Time.
actual como un objeto java.sql.Timestamp.
actual como un objeto java.sql.Timestamp.
Devuelve el valor de una columna de la fila
actual como un objeto java.sql.Timestamp.
Devuelve el valor de una columna de la fila
actual como un objeto java.sql.Timestamp.
Se obtiene el tipo de este conjunto de
resultados.
Obsoleto.
Obsoleto.
Devuelve el primer aviso reportado en este
ResultSet.
Inserta los contenidos de la fila insertada en
el conjunto de resultados y la base de datos.
Devuelve el valor True después del último
registro.
Devuelve el valor True antes del primer
registro.
Devuelve True si el registro actual es el
primero.
Devuelve True si el registro actual es el
último.
Se mueve al ultimo registro.
Mueve el cursor a la posición del cursor
guardada, normalmente a la fila actual.
Mueve el cursor a la fila insertada.
Mueve el cursor una fila hacia abajo, desde
su posición actual.
Se mueve al registro anterior.
void refreshRow( ) Actualiza la fila actual con su valor más
reciente de la base de datos.
boolean relative(int rows) Se mueve con relación a la posición actual.
boolean rowDeleted( ) Señala si una fila ha sido borrada.
boolean rowInserted( ) Indica si la fila actual ha recibido una
inserción.
boolean rowUpdated( ) Indica si la fila actual ha sido actualizada.
void setFetchDirection(int direction) Proporciona un indicio acerca de la dirección
en la que serán procesadas las filas de este
conjunto de resultados.
void setFetchSize(int rows) Define el número de filas que deberían
buscarse en la base de datos cuando se
necesitan más filas.
void updateAsciiStream(int columnIndex, Actualiza una columna con un valor ASCII
InputStream x, int length) stream.
void updateAsciiStream(String Actualiza una columna con un valor ASCII
columnName, InputStream x, int length) stream basándose en un nombre de
columna.
void updateBigDecimal(int columnIndex, Actualiza una columna con un valor
BigDecimal x) BigDecimal.
void updateBigDecimal(String Actualiza una columna con un valor
columnName, BigDecimal x) BigDecimal basándose en un nombre de
columna.
void updateBinaryStream(int columnIndex, Actualiza una columna con un valor stream
InputStream x, int length) binario.
void updateBinaryStream(String Actualiza una columna con un valor stream
columnName, InputStream x, int length) binario basándose en un nombre de
columna.
void updateBoolean(int columnIndex, Actualiza una columna con un valor
boolean x) booleano.
void updateBoolean(String columnName, Actualiza una columna con un valor
boolean x) booleano basándose en un nombre de
columna.
void updateByte(int columnIndex, byte x) Actualiza una columna con un valor de byte.
void updateByte(String columnName, byte Actualiza una columna con un valor de byte
x) basándose en un nombre de columna.
void updateBytes(int columnIndex, byte[ ] Updates a column with a byte array value.
x)
void updateBytes(String columnName, Actualiza una columna con una secuencia
byte[ ] x) de bytes basándose en un nombre de
columna.
void updateCharacterStream(int Actualiza una columna con un valor de
columnIndex, Reader x, int length) caracteres stream.
void updateCharacterStream(String Actualiza una columna con un valor de
columnName, Reader reader, int length) caracteres stream basándose en un nombre
de columna.
void updateDate(int columnIndex, Date x) Actualiza una columna con un valor de
fecha.
void updateDate(String columnName, Date Actualiza una columna con un valor de fecha
x) basándose en un nombre de columna.
void updateDouble(int columnIndex, double Actualiza una columna con un valor doble.
x)
void updateDouble(String columnName, Actualiza una columna con un valor doble
double x) basándose en un nombre de columna.
void updateFloat(int columnIndex, float x) Actualiza una columna con un valor flotante.
void updateFloat(String columnName, float Actualiza una columna con un valor flotante
x) basándose en un nombre de columna.
void updateInt(int columnIndex, int x) Actualiza una columna con un valor entero.
void updateInt(String columnName, int x) Actualiza una columna con un valor entero
basándose en un nombre de columna.
void updateLong(int columnIndex, long x) Actualiza una columna con un valor largo.
void updateLong(String columnName, long Actualiza una columna con un valor largo
x) basándose en un nombre de columna.
void updateNull(int columnIndex) Proporciona a una columna nula un valor
nulo.
void updateNull(String columnName) Actualiza una columna con un valor nulo.
void updateObject(int columnIndex, Object Actualiza una columna con un valor de
x) objeto.
void updateObject(int columnIndex, Object Actualiza una columna con un valor de
x, int scale) objeto utilizando una escala.
void updateObject(String columnName, Actualiza una columna con un valor de
Object x) objeto basándose en un nombre de
columna.
void updateObject(String columnName, Actualiza una columna con un valor de
Object x, int scale) objeto basándose en un nombre de
columna, utilizando una escala.
void updateRow( ) Actualiza la base de datos subyacente con
el nuevo contenido de la fila actual.
void updateShort(int columnIndex, short x) Actualiza una columna con un valor corto.
void updateShort(String columnName, Actualiza una columna con un valor corto
short x) basándose en un nombre de columna.
void updateString(int columnIndex, String Actualiza una columna con un valor en
x) cadena.
void updateString(String columnName, Actualiza una columna con un valor en
String x) cadena basándose en un nombre de
columna.
void updateTime(int columnIndex, Time x) Actualiza una columna con un valor
temporal.
void updateTime(String columnName, Time Actualiza una columna con un valor temporal
x) basándose en un nombre de columna.
boolean wasNull( ) Indica si la última columna leída tenía un
valor Null.

Aquí se muestra un ejemplo en el que se ha utilizado una fuente de datos ODBC

formada por una tabla llamada Students, con campos Name (nombre) y Grade (curso)
para distintos estudiantes:

Name Grade
---------------
| Ann | C |
|-------|-------|
| Mark | B |
|-------|-------|
| Ed | A |
|-------|-------|
| Frank | A |
|-------|-------|
| Ted | A |
|-------|-------|
| Mabel | B |
|-------|-------|
| Ralph | B |
|-------|-------|
| Tom | B |
---------------
 Observe las columnas de la tabla. Se ha creado un nuevo objeto Connection
especificando el origen de datos y el protocolo de conexión como "jdbc:odbc:students",
lo que indica que el usuario quiere que el controlador JDBC utilice ODBC para realizar
la conexión al origen de datos de los estudiantes.

Entonces se ejecutan las sentencias SQL "SELECT Name FROM Students" y

"SELECT Grade FROM Students" para generar los resultados correspondientes a las
dos columnas de la tabla. Mediante el método next de la clase ResultSet, puede ir
hacia la siguiente fila de cada conjunto de resultados y rellenar los controles con datos
provenientes de la fuente de datos.
Observe el código (preste atención a la línea
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver), necesaria para cargar el
controlador JDBC):

import java.net.*;
import java.sql.*;
import java.awt.*;
import java.awt.event.*;

public class jdbc extends Frame

{
Choice students;
Choice grades;
Connection connection;
Statement statement;

public jdbc()
{
students = new Choice();
grades = new Choice();

setLayout(new FlowLayout());

try
{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

connection = DriverManager.getConnection(
"jdbc:odbc:students", "Steve", "password");

statement = connection.createStatement();

String SQL = "SELECT Name FROM Students";

 ResultSet resultset = statement.executeQuery(SQL);
while (resultset.next())
students.addItem(resultset.getString(1));

SQL = "SELECT Grade FROM Students";

resultset = statement.executeQuery(SQL);
while (resultset.next())
grades.addItem(resultset.getString(1));
}
catch(Exception e) {}

add(students);
add(grades);
}

public static void main (String args[])

{
Frame f = new jdbc();

f.setSize(300, 300);

f.addWindowListener(new WindowAdapter() {public void

windowClosing(WindowEvent e) {System.exit(0);}});

f.show();
}