lunes, 14 de abril de 2008

CONEXIONES JAVA

CONECTAR JAVA CON MYSQL:

"Para empezar, debe tener instalado NetBeans 5.0 y haber descargado el conector Java.

1. Primero crearemos un proyecto normal (Java application)

2. Abrimos el manejador de bibliotecas. Menu Tools -> Library Manager

3. Nos aparecera el cuadro de dialogo Library Manager. Ahora debemos dar de alta una nueva biblioteca dando click en New Library...

4. En el cuadro que nos aparece, debemos llenarlo de la siguiente forma: Library Name: MySQL (no puede tener espacios)Library Type: Class LibrariesClick en el boton OK

5. Ahora debemos agregar unos detalles a la biblioteca. Asegurece que la nueva biblioteca creada este seleccionada (izquierda).

6. Seleccionamos la pestaña Class Path y damos clic en el botón Add JAR/Folder...

7. Se abre un dialogo llamado Browse JAR/Folder que permite seleccionar archivos. Buscamos el jar descargado para conectarnos a MySQL (mysql-3.1.11.jar) los seleccionamos y damos click en el boton Add JAR/Folder

8. Aparecera en la sección Class Path el archivo que acabamos de agregar, damos clic en Ok del cuadro de dialogo Library Manager.

9. Ahora debemos agregar la librería al proyecto. Dentro del proyecto (explorador del proyecto) seleccionar el nodo Libraries. Dar click derecho para mostrar el menu contextual

*Seleccionar opción Add Library
*Seleccionar de la lista, la biblioteca recien creada con el nombre MySQL

Debe aparecer como una nueva entrada dentro del nodo LibrariesY Listo."[1]



CONECTAR JAVA CON ACCESS:

"JDBC y ODBC:

La capacidad para acceder a bases de datos desde Java la ofrece la API JDBC (Java DataBase Conectivity). JDBC es un estándar para manejar bases de datos en Java. ODBC es un estándar de Windows para manejar bases de datos, de forma que cualquier programa en Windows que desee acceder a bases de datos genéricas debe usar este estándar. La necesidad de crear un estándar propio para acceder a bases de datos desde Java se explica porque el estándar ODBC está programado en C y un programa que use este estándar, por lo tanto, depende de la plataforma.

Controladores JDBC-ODBC:


Necesitamos acceder a un origren de datos ODBC pero contamos con una API que usa el estándar JDBC. Para solventar este problema las empresas realizan drivers que traducen el ODBC a JDBC. Hay varios tipos de Driver, pero para nuestro ejemplo usaremos los llamados puentes JDBC-ODBC. Estamos de suerte porque el JDK de Windows incorpora el driver necesario para conectar bases de datos Access.

Crear un nuevo DSN (Data Source Name):


Para realizar la conexión a una base de datos ODBC necesitaremos crear un perfil DSN desde el panel de control y posteriormente accederemos a la base de datos a partir del nombre del perfil. En el perfil DSN lo que se hace es indicar el driver a utilizar, así como el archivo o archivos del origen de datos. Estos son los pasos a llevar a cabo para configurar un perfil DSN.


1. Iremos a Panel de Control. Ello se hace desde Inicio->Configuración o desde MiPC.


2. Ahora hacemos doble-click en el icono de Fuentes de datos ODBC (32 bits).


3. En nuestra pantalla aparecerá ahora la pestaña DSN usuario seleccionada. Para crear un nuevo perfil haremos click en Agregar...


4. A continuación se nos pide que ingresemos el controlador que vamos a usar en el nuevo perfil. En nuestro caso será Microsoft Access Driver (*.mdb).

5. Una vez aquí sólo nos queda dar un nombre al origen de datos y especificar el archivo .mdb de origen. Tras aceptar la ventana ya tenemos creado un perfil con lo que ya podemos comenzar a programar." [2]

CONECTAR JAVA CON ORACLE:

"Para poder conectar a Java con ORACLE lo primero que necesitamos es la implementación de JDBC para ORACLE. Esta implementación se encuentra en el archivo Classes12.jar que podemos encontrar en el siguiente directorio del servidor de Oracle.


%ORACLE_HOME%\jdbc\lib" [3]

"Oracle proporciona los siguientes drivers en su implementacion JDBC:


JDBC Thin Driver: No requiere de la instalación cliente de ORACLE. Ideal para Applets.
JDBC OCI :API nativa de ORACLE, para aplicaciones J2EE.
JDBC KPRB driver: (default connection) para Java Stored Procedures y Database JSP's.


Todos los drivers soportan la misma sintaxis y funcionalidad, por lo que nuestro código variará únicamente en la forma de crear la conexion.


Conectar a ORACLE con JDBC Thin Driver:

El driver JDBC Thin se conecta y comunica con ORACLE a nivel de sockets. Proporciona su propia versión del protocolo Net8 (SQL*Net) sobre TCP/IP, por lo que no es necesario que exista una instalación de la parte cliente de ORACLE. Dado que este driver es código 100% Java es completamente independiente de la plataforma de ejecución, y como implementa su propia versión del protocolo es ideal para aplicaciones que se ejecutan sobre un navegador Web (applets).


import java.sql.*;

class dbAccess {

public static void main (String args []) throws SQLException {

DriverManager.registerDriver (new oracle.jdbc.driver.OracleDriver());
Connection conn = DriverManager.getConnection

("jdbc:oracle:thin:@WIN01:1521:oracleBD", "user", "passw");

// driver@machineName:port:SID , userid, password
Statement stmt = conn.createStatement();

ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");

while (rset.next()) System.out.println (rset.getString(1));

// Print col 1

stmt.close();

}

}


Conectar a ORACLE con JDBC OCI Driver:

El driver JDBC OCI usa el API ORACLE OCI (Oracle Call Interface) para interactuar con ORACLE, por lo que es necesaria la instalación y configuración de la parte cliente de ORACLE. El driver OCI trabaja con SQL*Net o Net8, por lo que tamdebemos haber creado un alias en el archivo TNS names:

(%ORACLE_HOME%\network\ADMIN):


ORACLEBD =

(DESCRIPTION =

(ADDRESS_LIST =

(ADDRESS = (PROTOCOL = TCP)(HOST = WIN01)(PORT = 1521))

)

(CONNECT_DATA =

(SERVICE_NAME = ORACLEBD)

)

)


El driver JDBC OCI permite realizar llamadas a ORACLE OCI directamente desde Java proporcionandoun alto grado de compatibilidad con una versión específica de ORACLE utilizando métodos nativos, pero específicos de la plataforma.


import java.sql.*;

class dbAccess {

public static void main (String args []) throws SQLException {

try {

Class.forName ("oracle.jdbc.driver.OracleDriver");

}

catch (ClassNotFoundException e) {

e.printStackTrace();

}


Connection conn = DriverManager.getConnection

("jdbc:oracle:oci:@ORACLEBD", "user", "passw");

// @TNSNames_Entry, userid, password


Statement stmt = conn.createStatement();

ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");

while (rset.next()) System.out.println (rset.getString(1)); // Print col 1 stmt.close();

}

}


Conectar a ORACLE con JDBC KPRB Driver:


Por último el driver ORACLE JDBC KPRB es utilizado para escribir en Java procedimientos almacenados, funciones, triggers ... Ofrece acceso a la conexion activa por lo que no es necesario crear ninguna conexión adicional.

El driver JDBC KPRB de ORACLE permite obtener un handle de la conexion actual del contexto a través del método OracleDriver.defaultConenction(). Como hemos dicho, se utiliza para procedimientos almacenados, triggers .... Para ejecutar un procedimiento almacenado debemos estar conectados a ORACLE a través de una herramienta cliente como SQL*Plus., lo que hacemos con defaultConenction() es acceder a está conexion.


CREATE OR REPLACE AND COMPILE JAVA SOURCE NAMED BANNER AS

import java.sql.*;

class dbAccess{

public static String showBanner() throws SQLException {

String banner="";

Connection conn = (new oracle.jdbc.driver.OracleDriver()).defaultConnection();


Statement stmt = conn.createStatement();

ResultSet rset = stmt.executeQuery("select BANNER from SYS.V_$VERSION");

while (rset.next())banner += rset.getString(1);

//stmt.close();

NO CERRAR LA CONEXION

return banner;

}

}


Es necesario crear un "wrapper" para poder ejecutar el programa desde PL/SQL o SQL:


CREATE OR REPLACE FUNCTION ShowBanner

RETURN VARCHAR2

IS

LANGUAGE JAVA NAME 'dbAccess.showBanner() return java.lang.String';


Una vez hecho esto, podemos ejecutar la función como si se tratase de una función PL/SQL:


SELECT ShowBanner FROM DUAL;" [3]


CONECTAR JAVA CON SQL SERVER:

"... Antes de establecer la conexión a una base de datos de SQL Server, SQL Server se debe instalar en el equipo local o en un servidor y el controlador JDBC se debe instalar en el equipo local.


Establecer ruta de clase:


El controlador JDBC no forma parte del SDK de Java. Por consiguiente, debe establecer la ruta de clase para que incluya el archivo sqljdbc.jar si desea usarlo. Si en la ruta de clase falta una entrada para sqljdbc.jar, la aplicación genera la excepción común "Clase no encontrada".


El archivo sqljdbc.jar se instala en la siguiente ubicación:


\sqljdbc_\\sqljdbc.jar


El siguiente es un ejemplo de la instrucción CLASSPATH usada para una aplicación de Windows:


CLASSPATH = .;C:\Program Files\Microsoft SQL Server 2005 JDBC Driver\sqljdbc_1.2\enu\sqljdbc.jar


El siguiente es un ejemplo de la instrucción CLASSPATH usada para una aplicación de Unix/Linux:


CLASSPATH = .:/home/usr1/mssqlserver2005jdbc/Driver/sqljdbc_1.2/enu/sqljdbc.jar


Aplicaciones que se ejecutan directamente en el símbolo del sistema:


La ruta de clase se configura en el sistema operativo. Anexe sqljdbc.jar a la ruta de clase del sistema. Además, puede especificar la ruta de clase en la línea de comandos de Java que ejecuta la aplicación con la opción java -classpath .


Aplicaciones que se ejecutan en un IDE:


Cada proveedor de IDE ofrece un método distinto para establecer la ruta de clase en el IDE. Establecer sin más la ruta de clase en el sistema operativo no funciona. Debe agregar sqljdbc.jar a la ruta de clase del IDE.


Servlets y JSP:


Los servlets y JSP se ejecutan en un motor de servlet/JSP como Tomcat. La ruta de clase se debe establecer de acuerdo con la documentación del motor de servlet/JSP. Establecer sin más la ruta de clase en el sistema operativo no funciona. Algunos motores de servlet/JSP incluyen pantallas de configuración que puede utilizar para establecer la ruta de clase del motor. En este caso, debe adjuntar el archivo JAR del controlador JDBC correcto a la ruta de clase del motor y reiniciar el motor. En otras situaciones, puede configurar el controlador copiando sqljdbc.jar en un directorio específico, con extensión lib, durante la instalación del motor. La ruta de clase del controlador del motor también se puede especificar en un archivo de configuración específico del motor.


Enterprise Java Beans:


Enterprise Java Beans (EJB) se ejecuta en un contenedor EJB. Los contenedores EJB son distribuidos por varios proveedores. Los subprogramas Java se ejecutan en un explorador, pero se descargan desde un servidor web. Copie sqljdbc.jar en la raíz del servidor web y especifique el nombre del archivo JAR en la ficha de archivo HTML del subprograma (por ejemplo, (applet archive="sqljdbc.jar")).


Establecer una conexión sencilla con una base de datos:


Para establecer una conexión a una base de datos con la clase DriverManager, debe registrar primero el controlador como en el ejemplo siguiente:


Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
Una vez cargado el controlador, puede establecer una conexión con una URL de conexión:

String connectionUrl = "jdbc:sqlserver://localhost:1433;" +
"databaseName=AdventureWorks;user=MyUserName;password=*****;";
Connection con = DriverManager.getConnection(connectionUrl);" [4]


CONECTAR JAVA CON POSTGRES:


"PostGres, que es un sistema de base de datos relacional que une las estructuras clásicas con los conceptos de programación orientada a objetos." [5]

"Primero, es necesario descargarel JDBC Driver para PostgreSQL. Obviamente, será necesario contar con nuestra Base de Datos funcionando para realizar las consultas necesarias.

Posteriormente hay que determinar la manera de agregar este Driver a nuestro proyecto. NetBeans ofrece una manera mas que sencilla.

Conociendo la ubicación de nuestro Driver y con el proyecto abierto, en el Panel de Proyectos, ubicamos en el Árbol de Proyecto la opción Libraries, clic Derecho en ella y seleccionamos Add JAR / Folder..., de esta manera estaremos agregando ej .JAR del Driver que descargamos. Esto nos crea en nuestro proyecto una carpeta llamada "dist" y en ella otra de nombre "lib" donde esta nuestro Driver.

Ahora, teniendo lo necesario, podemos probar nuestra conexión con PostgreSQL y realizar lo que nos concierne, Altas, Bajas y Modificaciones a nuestras tablas.

Para empezar, debemos de importar lo siguiente:

import java.sql.*; " [6]



BIBLIOGRAFIA:


1.http://diario-de-un-programador.blogspot.com/2006/10/conectar-java-con-mysql-en-netbeans.html
2.http://www.gamarod.com.ar/articulos/como_conectar_java_y_access.asp
3.http://www.devjoker.com/asp/ver_contenidos.aspx?co_contenido=132
4.http://msdn2.microsoft.com/es-es/library/ms378526.aspx
5.http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte21/cap21-3.html
6.http://www.mygnet.net/articulos/java/conectando_postgrestql_con_java.1162
Publicado por en 1 comentario:

miércoles, 9 de abril de 2008

EXCEPCIONES

· QUE ES UNA EXCEPCION?:

“Una excepción es un evento que ocurre durante la ejecución de un programa y detiene el flujo normal de la secuencia de instrucciones de ese programa; en otras palabras, una excepción es una condición anormal que surge en una secuencia de código durante su ejecución.

Las excepciones en Java están destinadas, al igual que en el resto de los lenguajes que las soportan, para la detección y corrección de errores. Si hay un error, la aplicación no debería morirse y generar un core (o un crash en caso del DOS). Se debería lanzar (throw) una excepción que a su vez debería capturar (catch) y resolver la situación de error, o poder ser tratada finalmente (finally) por un gestor por defecto u omisión. Java sigue el mismo modelo de excepciones que se utiliza en C++. Utilizadas en forma adecuada, las excepciones aumentan en gran medida la robustez de las aplicaciones.

La gestión de excepciones en Java proporciona un mecanismo excepcionalmente poderoso para controlar programas que tengan muchas características dinámicas durante su ejecución. Las excepciones son formas muy limpias de manejar errores y problemas inesperados en la lógica del programa, y no deberían considerarse como un mecanismo general de ramificaciones o un tipo de sentencias de salto. Los lugares más indicados para utilizar excepciones son aquellos en los que se usan valores como 0 o 1, en C/C++, para indicar algún fallo funcional.” [1]

“… Una excepción es un objeto derivado directa, o indirectamente, de la clase Throwable. Tanto el intérprete Java como muchos métodos de las múltiples clases de Java pueden lanzar excepciones y errores.

La clase Throwable tiene dos subclases: Error y Exception. Un Error indica que se ha producido un fallo no recuperable, del que no se puede recuperar la ejecución normal del programa, por lo tanto, en este caso no hay nada que hacer. Los errores, normalmente, hacen que el intérprete Java presente un mensaje en el dispositivo estándar de salida y concluya la ejecución del programa. El único caso en que esto no es así, es cuando se produce la muerte de un thread, en cuyo caso se genera el error ThreadDead, que lo que hace es concluir la ejecución de ese hilo, pero ni presenta mensajes en pantalla ni afecto a otros hilos que se estén ejecutando.

Una Exception indicará una condición anormal que puede ser subsanada para evitar la terminación de la ejecución del programa. Hay nueve subclases de la clase Exception ya predefinidas, y cada una de ellas, a su vez, tiene numerosas subclases.” [2]

· CLASE DE EXCEPCIONES:

EXCEPCIONES PREDEFINIDAS:

“Las excepciones predefinidas por la implementación actual del lenguaje Java y su jerarquía interna de clases son las que se representan en el esquema de la figura que aparece a continuación:

Los nombres de las excepciones indican la condición de error que representan.” [2]


EXCEPCIONES PROPIAS:

“También el programador puede lanzar sus propias excepciones, extendiendo la clase System.exception. Por ejemplo, considérese un programa cliente/servidor. El código cliente se intenta conectar al servidor, y durante 5 segundos se espera a que conteste el servidor. Si el servidor no responde, el servidor lanzaría la excepción de time-out:

class ServerTimeOutException extends Exception { }

public void conectame( String nombreServidor ) throws Exception {
int exito; int puerto = 80;
exito = open( nombreServidor,puerto );
if( exito == -1 )
throw ServerTimeOutException;
}


Si se quieren capturar las propias excepciones, se deberá utilizar la sentencia try:

public void encuentraServidor() {
...
try {
conectame( servidorDefecto );
catch( ServerTimeOutException e ) {
g.drawString( "Time-out del Servidor, intentando alternativa",5,5 );
conectame( servidorAlterno );
}
...
}


Cualquier método que lance una excepción también debe capturarla, o declararla como parte del interfaz del método. Cabe preguntarse entonces, el porqué de lanzar una excepción si hay que capturarla en el mismo método. La respuesta es que las excepciones no simplifican el trabajo del control de errores. Tienen la ventaja de que se puede tener muy localizado el control de errores y no hay que controlar millones de valores de retorno, pero no van más allá.” [2]


· QUE ES MANEJO DE EXCEPCIONES?:

“El manejo de excepciones es una estructura de control de los lenguajes de programación diseñada para manejar condiciones anormales que pueden ser tratadas por el mismo programa que se desarrolla.

Por ejemplo, un programa puede admitir cierto número de errores en el formato de los datos y continuar su proceso para producir el mejor resultado posible en lugar de producir una salida aparatosa llena de mensajes de error probablemente incomprensibles para el usuario. Muchas veces la acción asociada a una excepción es simplemente producir un mensaje informativo y terminar, otras veces, es sólo indicación de la necesidad de un cambio en la estrategia de resolución del problema.” [3]


· MANEJO DE EXCEPCIONES EN JAVA:

“… Cuando el error ocurre dentro de un método Java, el método crea un objeto ‘exception’ y lo maneja fuera, en el sistema de ejecución. Este objeto contiene información sobre la excepción, incluyendo su tipo y el estado del programa cuando ocurrió el error. El sistema de ejecución es el responsable de buscar algún código para manejar el error. En terminología java, crear una objeto exception y manejarlo por el sistema de ejecución se llama lanzar una excepción. Después de que un método lance una excepción, el sistema de ejecución entra en acción para buscar el manejador de la excepción. El conjunto de “algunos” métodos posibles para manejar la excepción es el conjunto de métodos de la pila de llamadas del método donde ocurrió el error. El sistema de ejecución busca hacia atrás en la pila de llamadas, empezando por el método en el que ocurrió el error, hasta que encuentra un método que contiene el “manejador de excepción” adecuado. Un manejador de excepción es considerado adecuado si el tipo de la excepción lanzada es el mismo que el de la excepción manejada por el manejador. Así la excepción sube sobre la pila de llamadas hasta que encuentra el manejador apropiado y una de las llamadas a métodos maneja la excepción, se dice que el manejador de excepción elegido captura la excepción. Si el sistema de ejecución busca exhaustivamente por todos los métodos de la pila de llamadas sin encontrar el manejador de excepción adecuado, el sistema de ejecución finaliza (y consecuentemente y el programa Java también).” [4]


· EJEMPLOS:

“Ejemplo de manejo de una excepción en Java:
import java.io.IOException;

// ...

public static void main(String[] args) {
try {
// Se ejecuta algo que puede producir una excepción
} catch (IOException e) {
// manejo de una excepción de entrada/salida
} catch (Exception e) {
// manejo de una excepción cualquiera
} finally {
// código a ejecutar haya o no excepción
}
} ” [3]



“A continuación se muestra cómo se utilizan las excepciones, reconvirtiendo en primer lugar el applet de saludo a partir de la versión iterativa de HolaIte.java:

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

public class HolaIte extends Applet {

private int i = 0; private String Saludos[] = {
"Hola Mundo!",
"HOLA Mundo!",
"HOLA MUNDO!!"
};

public void paint( Graphics g ) {

g.drawString( Saludos[i],25,25 );
i++;
}
}


Normalmente, un programa termina con un mensaje de error cuando se lanza una excepción. Sin embargo, Java tiene mecanismos para excepciones que permiten ver qué excepción se ha producido e intentar recuperarse de ella.


Vamos a reescribir el método paint() de esa versión iterativa del saludo:

public void paint( Graphics g ) {
try {
g.drawString( Saludos[i],25,25 );
}
catch( ArrayIndexOutOfBoundsException e ) {
g.drawString( "Saludos desbordado",25,25 );
}
catch( Exception e ) {
// Cualquier otra excepción
System.out.println( e.toString() );
}
finally {
System.out.println( "Esto se imprime siempre!" );
}
i++;
}


La palabra clave finally define un bloque de código que se quiere que sea ejecutado siempre, de acuerdo a si se capturó la excepción o no. En el ejemplo anterior, la salida en la consola, con i=4 sería:

C:\>java HolaIte
Saludos desbordado
¡Esto se imprime siempre! ” [1]


BIBLIOGRAFIA:
Publicado por en 1 comentario:

JTABLE

· QUE ES UN JTABLE?:

“… es una clase que me permite organizar una determinada información en tabla, esta difiere de una base de datos normal porque al utilizar Jtable tu puedes visualizar esta tabla, brindándole a el usuario organización de información, oportunidades de editar y cambiar el tamaño de las columna entre otras.” [1]

· QUE ES UN TABLEMODEL?:

“… es un programa que guarda los datos de la tabla para si mismo, es decir, puede tener la información de la tabla pero estos datos son los visualizados por el computador, es decir, para visualizar una tabla el TABLEMODEL puede tener la información pero sin el Jtable no se puede visualizar para el usuario.” [1]

· COMO SE MANEJA UN JTABLE?:

“…. le da al programador muchas facilidades, pues este posee varias características que permiten hacer desde tablas con información compleja y muy estructurada hasta tablas con información sencilla y "básica". La clase Jtable controla como se presentan los datos, siendo el TableModel quien controla los datos sí mismos. para crear una Jtable habrá pues que crear un TableModel antes, normalmente. TableModel lo que hace es predeterminar ciertas características para el Jtable es decir que tu puedes poner ciertos parámetros dentro de un TableModel y así no tener que determinarlos siempre” [1]

“… Jtable tiene una característica muy llamativa, este permite que el programador pueda decirdir que se edita y que no, sin embargo si el programador dentro de su programa o de su TABLEMODEL no tiene determinado este aspecto, Jtable automáticamente hace editable las celdas dentro de la tabla. Existen varias maneras de hacer editable o no las celdas dentro de la tabla, para ver estos comandos tu te puedes dirigir a Dentro de las celdas encontradas en una tabla se puede permitir al usuario editar o no editar según lo desee el programador, esta propiedad se puede arreglar desde el table model o directamente y/o desde el programa. Jtable tiene la propiedad de dejar editable las celdas si no encuentra nada que hable de esto.” [1]

“Jtable te brinda muchas facilidades para poder crear una table, y así mismo de llenarla con la información que desees ( números, letras etc...) por lo que sencillamente dentro de una tabla esta automáticamente esta a través de la información debidamente separada - por ""(comillas) o por , (coma) - es capaz de contabilizarlas y al mismo tiempo llenarla con la información que se le dio; es decir el programador solo se debe encargar de poner los títulos de las tablas y así mismo de escribir la información en el mismo orden en que desee que salga de acuerdo con los títulos y Jtable se encargara automáticamente de colocar la información donde se le indico.” [1]

BIBLIOGRAFIA:

1. http://www.gfc.edu.co/estudiantes/anuario/2002/sistemas/alejandra/Tutorial.sgml
Publicado por en 1 comentario:

JCOMBOBOX

QUE ES UN JCOMBOBOX?:

“…es una lista que se despliega hacia abajo y nos permite elegir entre varias opciones diferentes. Utilizar un JComboBox es muy sencillo ya que únicamente necesitamos un arreglo de String para iniciarlo y si queremos podemos añadir más elementos de una manera muy sencilla. El JComboBox es muy útil cuando queremos mostrar una lista muy larga de la que solamente se va a elegir una sola opción o cuando no tenemos mucho espacio.” [1]

“El JComboBox nos permite mostrar una caja de selección en la que podemos seleccionar una sola opción. Se utilizan en programas como Word para permitirnos seleccionar el tipo de letra que queremos poner. Para agregar un JComboBox en un proyecto de NetBeans selecciona su icono en la paleta (regularmente se encuentra a la derecha).


Vamos a crear una interfaz gráfica como la que se ve en la siguiente imagen:


El rectángulo blanco con borde negro que se ve en la parte inferior es un JLabel al que le cambié el color de fondo y le puse un borde. Nuestra ventana nos va a permitir seleccionar un objeto del combo box y dependiendo del objeto que esté seleccionado va a dibujar una figura geométrica diferente.


Una vez que ya tenemos la interfaz vamos a agregar elementos al modelo estático de nuestro JComboBox, para hacer esto debemos seleccionar el combo box y en la parte de propiedades modificamos la propiedad llamada model. En la ventana que aparece podemos agregar elementos al JComboBox escribiéndolos en la caja de texto y después presionando el botón Add.



Vamos a agregar las siguientes opciones:

Cuadrado
Círculo
Triángulo


Como nosotros mismos agregamos las opciones al combo box y sabemos el orden en el que están, lo único que necesitamos es saber el indice que seleccionó el usuario, y de esa manera podemos saber qué figura vamos a dibujar. Por ejemplo, si el usuario seleccionó el indice cero sabemos que tenemos que dibujar un cuadrado.

Para poder obtener el indice seleccionado debemos utilizar el método getSelectedIndex() del combo box. Entonces vamos a poner el código de la siguiente manera:
int selectedIndex = cboShapes.getSelectedIndex();
switch (selectedIndex) {
case 0: // Square
break;
case 1: // Circle
break;
case 2: // Triangle
break;
}

De esta manera sabemos qué indice seleccionó el usuario y podemos actuar dependiendo de este, ya completo el código incluyendo lo que dibuja:
private void btnDrawActionPerformed(java.awt.event.ActionEvent evt) {
Graphics g = lblPaint.getGraphics();
int width = lblPaint.getWidth();
int height = lblPaint.getHeight();
int halfWidth = width / 2;
int halfHeight = height / 2;
int selectedIndex = cboShapes.getSelectedIndex();
switch (selectedIndex) {
case 0: // Square
g.drawRect(halfWidth - 50, halfHeight - 50, 100, 100);
break;
case 1: // Circle
g.drawOval(halfWidth - 50, halfHeight - 50, 100, 100);
break;
case 2: // Triangle
Polygon p = new Polygon();
p.addPoint(halfWidth, halfHeight - 20);
p.addPoint(halfWidth - 20, halfHeight + 10);
p.addPoint(halfWidth + 20, halfHeight + 10);
g.drawPolygon(p);
break;
}
g.dispose();
}


Un modelo estático es muy útil cuando sólo queremos que el usuario seleccione una de entre varias opciones predefinidas, pero algunas veces queremos que las opciones se lean de un archivo o se agreguen desde una base de datos. Para poder hacer esto debemos utilizar un modelo dinámico.

Antes de comenzar es preciso entender que dentro del combo box se están guardando objetos, y que estos objetos tienen todos sus métodos y atributos. Es decir que podemos guardar un objeto completo dentro del combo box y una vez que el usuario lo seleccione tendremos acceso a mucha más información que la simple cadena de texto que se muestra en el combo box. Esto es importante siempre tenerlo en cuenta porque nos va a facilitar mucho la programación.
Primero vamos a crear una nueva interfaz gráfica como la que se muestra a continuación:



Ahora vamos a crear el objeto que va a ir guardado en el combo box, crea una clase User con el siguiente código:

public class User {
public String name;
public String favoriteFood;
public User(String name, String favoriteFood) {
this.name = name;
this.favoriteFood = favoriteFood;
}
public String getFavoriteFood() {
return favoriteFood;
}
public void setFavoriteFood(String favoriteFood) {
this.favoriteFood = favoriteFood; } public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return this.name;
}
}

Ahora vamos a crear algunos objetos de la clase User dentro de la ventana principal, en la interfaz gráfica. En el constructor de la ventana principal agrega el siguiente código (después de la llamada a initComponents()):
User magus = new User("Magus", "Pastel azteca");
User juan = new User("Juan", "Quesadillas");

Ahora vamos a agregar estos objetos a nuestro combo box con las siguientes instrucciones:
cboShapes.removeAllItems();
cboShapes.addItem(magus);
cboShapes.addItem(juan);

Todo junto queda así:
public MainFrame() {
initComponents();
User magus = new User("Magus", "Pastel azteca");
User juan = new User("Juan", "Quesadillas");
cboShapes.removeAllItems();
cboShapes.addItem(magus);
cboShapes.addItem(juan);
}

Pero ahora tenemos un problema, como el modelo es dinámico (y podríamos haber obtenido los datos de un archivo, de internet o de cualquier otro lugar) entonces no sabemos los índices y no podemos utilizar un switch para realizar las acciones como lo hicimos la vez anterior, y es aquí donde entra la magia de los objetos, porque podemos obtener el objeto seleccionado y tomar decisiones en base a este objeto, en el botón de saludar vamos a poner el siguiente código:
private void btnGreetActionPerformed(java.awt.event. ActionEvent evt) {
User user = (User) cboUsers.getSelectedItem();
JOptionPane.showMessageDialog(this, "Bienvenido " + user.getName() + ".\n " +
"A mi también me gusta el " + user.getFavoriteFood());
}

Como podemos observar estamos obteniendo el objeto que seleccionó el usuario y mostramos el mensaje dependiendo de los parámetros de este usuario.” [2]


Publicado por en 11 comentarios:
Suscribirse a: Entradas (Atom)