JAVA desde cero

2011-12-15T23:01:00.003-08:00

Published with Blogger-droid v2.0.2

2011-12-15T23:01:00.001-08:00

Published with Blogger-droid v2.0.2

Cambiar versión de JDK en NetBeans

2011-09-03T04:14:00.001-07:00

Hoy tuve la necesidad de cambiar el JDK con el que estaba trabajando , normalmente trabajaba con la versión de 64 bits pero me vi en la necesidad de cambiarlo al JDK de 32 bits , y bueno el cambio es así de sencillo solo editar una línea .

Bueno lo que hice fue lo siguiente :

Antes que nada hay que instalar la versión de JDK con la cual vamos a trabajar.
Ahora iremos al directorio en donde tenemos instalado el Netbeans en mi caso : “C:\Program Files\NetBeans 6.9.1” allí encontraremos la carpeta etc y dentro de esta carpeta ubicaremos el archivo netbeans.conf especificamente la linea que contiene el netbeans_jdkhome en ella colocaremos la nueva ruta del jdk.

Por último comprobaremos que se halla modificado , para ello abrir el Netbeans , ir a Tools → Java Plataforms y veremos que el jdk que hemos elegido se ha colocado por defecto .

Instalación y configuración de Java en Ubuntu

2011-08-30T06:40:00.001-07:00

En este post se mostrará como instalar manualmente el JDK ( Java Developement Kit ) en Linux , más específicamente en Ubuntu 10.04 , así como configurar las variables de entorno .

Primero descargaremos el JDK para Linux que está en formato .bin ; esto lo puedes conseguir en el siguiente enlace : http://www.oracle.com/technetwork/java/javasebusiness/downloads/java-archive-downloads-javase6-419409.html#jdk-6u26-oth-JPR:
El archivo se descargará en la carpeta Descargas , luego tendremos que moverlo a la ruta /usr/local para ello abrimos el terminal y ejecutamos los siguientes comandos :

cd /home/tu_nombre_usuario/Descargas
sudo su (colocamos la clave para loguearnos como super usuario)
mv jdk-6u26-linux-i586.bin /usr/local/

Le damos permisos de ejecución al archivo .bin y lo instalamos , para ello escribir en la terminal (hecho esto se empezará a desempaquetar los archivos del JDK en la carpeta jdk1.6.0_26) :

sudo chmod+x jdk-6u26-linux-i586.bin
./ jdk-6u26-linux-i586.bin

Ahora solo nos queda configurar las variables de entorno JAVA_HOME ,para esto editaremos el archivo bash.bashrc que se encuentra en el directorio /etc (esto sirve para setear la variable en todos los perfiles) ; en el terminal abierto ejecutamos lo siguiente :

sudo pico /etc/bash.bashrc
Y agregamos lo siguiente en la última línea (después del último fi) :

Guardamos los cambios y refrescamos las variables con el comando :

source /etc/bash.bashrc

Podemos verificar que se halla incluido correctamente las variables con los siguientes comandos :

set|grep PATH
set|grep JAVA_HOME

Hecho esto ya tenemos instalado el JDK en Ubuntu , para comprobarlo también podemos crear una clase y la guardamos en el escritorio :

Abrimos el terminal y nos dirigimos al escritorio (o al lugar en donde se guardó el archivo Main.java) y lo compilamos con la orden : javac Main.java , lo cuál nos generará un archivo Main.class

Por último ejecutamos en la terminal java Main.class para correr el programa :

Instalar plugins en NetBeans

2010-11-12T08:39:00.001-08:00

NetBeans nos ofrece una serie de plugins con las que podremos trabajar ( la lista de plugins que podemos instalar la podemos encontrar en : http://plugins.netbeans.org/PluginPortal/ ).

Para descargar e instalar cualquier plugin en el IDE NetBeans tenemos que ir a Tools → Plugins

NetBeans UML

Para instalar este plugin nos vamos a Tools → Plugins
Si usamos versiones a anteriores a la versión 6.8 no tendremos problemas (ir al pto. 5) , si tenemos una versión mayor a la 6.8 tenemos que instalarlo manualmente pues a partir de esta versión NetBeans no trae el plugin por defecto la fuente, para eso nos vamos a la pestaña Settings → Add
En la ventana que sale colocaremos los siguientes datos : Name : UML y en URL : http://deadlock.netbeans.org/hudson/job/uml/lastSuccessfulBuild/artifact/build/updates/updates.xml
Ahora nos vamos a la pestaña Available plugins y le damos clic en Reload Catalog para refrescar el catálogo de plugins que podemos instalar.
Después de que se actualice el catálogo , aparecerá la opción de UML la cual seleccionaremos y le daremos clic en el botón
Después de aceptar la licencia empezará la instalación de UML , finalmente bastará con reiniciar NetBeans , para poder hacer uso del plugin.

Crear unidades con subst

2010-06-23T22:23:00.001-07:00

Hoy vi algo nuevo que me llamó mucho la atención (quizás algunos ya lo han visto) pero se puede crear unidades con tan solo usar un comando DOS (para muchos, obsoleto y sobre todo desconocido , pero me he dado cuenta que en realidad son poderosos y nos facilitan el trabajo).

Esto sirve cuando tenemos carpetas a las cuales accedemos con cierta regularidad pero están casi escondidas en nuestra PC , para resolver este problema haremos lo siguiente :

Vamos a Inicio → Ejecutar → Regedit
Nos vamos a HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
Una vez que ubicamos Run en la parte derecha le damos clic derecho → Nuevo → Valor de cadena
Al archivo que aparece le damos cualquier nombre ; en el ejemplo le hemos dado el nombre de “subst” , le damos clic derecho y en la caja de Información de valor colocamos

SUBST LETRA_DE_LA_NUEVA_UNIDAD : “PATH”
Ahora solo nos queda cerrar la sesión y cuando la iniciemos de nuevo tendremos nuestra nueva unidad creada.

Video tutorial : Desarrollo de aplicaciones de escritorio y acceso a datos con C#

2010-04-13T04:52:00.001-07:00

Hola a todos, en esta oportunidad les traigo un curso que me pareció genial , el post esta extraído de www.intercambiosvirtuales.org (donde por cierto podrán encontrar gran cantidad de materiales como este) .

El curso se divide en 21 módulos (cada módulo con su respectivo video de ejemplo ) , los cuáles se dividen en 3 partes : Diseño de formularios , acceso a dato y datos y formularios.Bueno sin mas que decir espero que les sirva tanto como me ha servido a mí , les dejo los links de descarga y el contenido de cada módulo .

Parte Nº01 : http://depositfiles.com/files/bysianw62

Parte Nº02 : http://depositfiles.com/files/ubxs2iczj

Parte Nº03 : http://depositfiles.com/files/zc3jh0w9s

Contraseña/Password: www.intercambiosvirtuales.org

Después de bajar todas las partes en una carpeta , descomprimir la primera parte y generará un archivo .iso el cuál podrás abrir con el winrar.

Módulo1. Crear aplicaciones de escritorio I.

-Crear un proyecto de tipo aplicación de escritorio.
-Como añadir formularios a un proyecto.
-El formulario desde la perspectiva de la orientación a objetos.
-Propiedades de los formularios.
-Como escoger el formulario de inicio.
-Principales eventos de los formularios.
-Ejercicio Final.

Módulo 2. Crear aplicaciones de escritorio II.

-Como añadir controles a un formulario.
-Adaptar los controles dentro del formulario.
-Posicionar y dimensionar.
-Alinear.
-Anchor y Dock.
-Establecer el orden de tabulación.
-Responder a los eventos emitidos por los controles.
-Conectar múltiples eventos a un único gestor de eventos.
-Ejercicio Final.

Módulo 3. Crear aplicaciones de escritorio III.

-Mostrar formularios en forma Modal y NoModal.
-Añadir controles en tiempo de ejecución.
-Crear teclas de acceso para controles.
-Eventos relacionados con entradas de teclado.
-Ejercicio Final.

Módulo 4. Utilizar controles standard I.

-Propiedades comunes a la mayoría de controles. -Los controles más elementales (TextBox, Label, Button).
-Listas básicas (ListBox, ComboBox, CheckedListBox).
-Controles booleanos (CheckBox, RadioButton).
-Otras listas (NumericUpDown, TreeView, ListView).
-Ejercicio Final.

Módulo 5. Utilizar controles standard II.

-Panel y GroupBox.
-SplitContainer.
-TabControl.
-ToolStrip y StatusStrip.
-PictureBox.
-ImageList.
-MonthCalendar.
-WebBrowser.
-Ejercicio Final.

Módulo 6. Crear menús.

-¿Qué es un sistema de menús?
-Introducción al control MenuStrip.
-Añadir mejoras a un ToolStripMenuItem.
-Ocultar y desactivar ToolStripMenuItems.
-Responder a eventos de menú.
-Crear menus de contexto con el componente ContextMenuStrip.
-Ejercicio Final.

Módulo 7. Los cuadros de diálogo.

-Descripción de los cuadros de diálogo.
-OpenFileDialog.
-SaveFileDialog.
-ColorDialog.
-FontDialog.
-FolderBrowserDialog.
-Ejercicio Final.

Módulo 8. La herencia entre formularios.

-Utilidad de la herencia entre formularios.
-Crear un formulario base.
-Heredar de un formulario base.
-Modificar el formulario base.
-Sobreescribir eventos del formulario base.
-Ejercicio Final.

Módulo 9. Introducción al acceso a datos.

-La necesidad de almacenar datos.
-Introducción a las bases de datos relacionales.
-Descripción del lenguaje SQL.
-Los proveedores de bases de datos.
-Descripción de ADO.NET.
-Escenarios conectados y escenarios desconectados.
-Ejercicio Final.

Módulo 10. Conectar a una base de datos.

-¿Qué es la cadena de conexión?
-Como conectar a una base de datos.
-Como desconectar de una base de datos.
-Como gestionar los eventos de conexión.
-Ejercicio Final.

Módulo 11. Operaciones en un escenario conectado I.

-Como enviar un comando a una base de datos.
-Los tipos de respuesta a un comando.
-Comandos escalares.
-Comandos que devuelven un conjunto de resultados. El DataReader.
-Como iterar a traves de un DataReader.
-Ejercicio Final.

Módulo 12. Operaciones en un escenario conectado II.

-Introducción a Microsoft SQL Server 2005 Express.
-La modificación de los datos.
-Los comandos parametrizados.
-La referencia a librerias.
-Como ejecutar procedimientos almacenados en la base de datos.
-Ejercicio Final.

Módulo 13. Operaciones en un escenario desconectado I.

-¿Qué es un DataSet?
-Crear DataSets programáticamente.
-Crear DataSets con el diseñador.
-Definir restricciones y relaciones en un DataSet.
-Ejercicio Final.

Módulo 14. Operaciones en un escenario desconectado II.

-Como añadir registros a un DataSet.
-Como modificar registros de un DataSet.
-Como eliminar registros de un DataSet.
-Como iterar a través de los registros de un DataTable.
-Iterar a través de registros relacionados.
-Buscar registros en un DataTable.
-Ejercicio Final.

Módulo 15. Operaciones en un escenario desconectado III.

-¿Qué es un DataAdapter?
-Crear DataAdapters programáticamente.
-Como cargar datos en un DataSet utilizando un DataAdapter.
-Guardar y cargar DataSets en el disco local.
-Ejercicio Final.

Módulo 16. Operaciones en un escenario desconectado IV.

-Crear DataAdapters con el diseñador.
-Crear DataAdapters con el objeto CommandBuilder.
-El estado de las filas.
-Como actualizar en el origen los cambios realizados en un DataSet.
-Personalizar la actualización de los cambios.
-Ejercicio Final.

Módulo 17. Operaciones en un escenario desconectado V.

-El problema de la concurrencia.
-La versión de las filas.
-Concurrencia optimista.
-Concurrencia pesimista.
-Formas de gestionar los conflictos de concurrencia.
-Ejercicio Final.

Módulo 18. Operaciones en un escenario desconectado VI.

-¿Qué es un DataSet tipificado?
-¿Qué es un esquema XSD?
-Crear DataSets tipificados basándose en un DataAdapter.
-La herramienta Data Sources de Visual Studio 2005.
-Como utilizar un DataSet tipificado.
-Ejercicio Final.

Módulo 19. Operaciones en un escenario desconectado VII.

-¿Qué es un TableAdapter?
-Como se crean los TableAdapters.
-Como utilizar un TableAdapter.
-Utilizar parámetors en un TableAdapter.
-Utilizar los métodos directos.
-Extender las funcionalidades del TableAdapter.
-Ejercicio Final.

Módulo 20. Mostrar y editar datos a través de formularios I.

-Formas de gestionar datos desde un formulario.
-El control BindingSource.
-Enlazar controles simples a un DataTable.
-Enlazar controles simples en tiempo de ejecución.
-El control BindingNavigator.
-Utilizar la herramientta DataSource para crear formularios de un sólo registro.
-Ejercicio Final.

Módulo 21. Mostrar y editar datos a través de formularios II.

-Utilizar el ComboBox como control de enlace simple.
-El control DataGridView.
-Personalizar la apariencia de las celdas.
-El evento CellFormating del DataGridView.
-Relación Maestro-Detalle entre dos DataGridViews.
-Ejercicio Final.

Colocar un Jar en la Paleta de NetBeans

2009-12-20T05:15:00.001-08:00

Muchas veces desarrollamos archivos JAR que queremos tenerlos siempre a la mano ( mas si son visuales ) , una alternativa para tener los Jar a la mano es agregarlo en la Paleta de NetBeans.

En esta entrada colocaremos una librería (JCalendar) en la paleta de NetBeans con el fin de arrastrar sus objetos a nuestros JFrame ; para este ejemplo voy a usar la librería JCalendar que lo pueden descargar de esta página : http://www.toedter.com/en/jcalendar/index.html (el proyecto es libre) .

En la paleta de componentes(beans) hacemos clic derecho y en el menú emergente seleccionamos Palette Manager :
Hacemos clic en New Category , y en la ventana emergente colocaremos el nombre de la categoría que deseamos que aparezca en la paleta ( Observen que si se desmarca los checks la categoría que seleccionen desaparece de la paleta).
Ahora vamos a agregar el Jar a la paleta , para ello vamos a “Add from JAR” y buscamos el directorio del JAR a agregar , seleccionamos y damos clic a Next :
En la siguiente ventana seleccionamos los componentes a agregar :
Seleccionamos la categoría que habíamos creado, clic en Finish y cerramos la ventana :
Y listo ya tenemos el Jar en nuestra paleta con los componentes que podemos arrastrar a los frame o paneles :

Obtener el código fuente a partir del JAR

2009-12-08T20:15:00.001-08:00

Bueno muchas veces que encontramos proyectos para poder estudiarlos el autor solo nos proporciona el archivo jar mas no el código fuente. Aquí encontré una forma fácil de tener el código fuente , OJO que esto solo debe usarse para fines de comprensión del código (es bueno ver la forma de como programan las demás personas) .

Antes que nada debemos tener instalado el winrar , vamos al archivo jar → clic derecho y lo descomprimimos .

Una vez que hemos descomprimido el archivo JAR encontraremos en la carpeta los archivos con la extensión .class los cuales son los que nos vana a interesar :

Ahora nos descargamos la herramienta portable DJ.Java.Decompiler.v3.11.11.95 que lo pueden descargar desde aquí .

Ejecutamos el archivo DJ.exe , nos saldrá la siguiente pantalla …. nos vamos a File → Open y buscamos los archivos .class :

Y a continuación tendremos el código fuente de nuestro archivo JAR

Ventana splash con NetBeans

2009-12-08T05:30:00.001-08:00

Una ventana splash es una ventana de presentación ; sin los botones clásicos y que va a servir para darle una mejor presentación a nuestro proyecto.

Esta ventana se debe colocar al principio de nuestra aplicación; para empezar debemos diseñar la que será nuestra imagen de presentación la cual por motivos de tiempo elegí la de NetBeans ; y a esta le vamos a agregar una barra de progreso :

Abrimos el NetBeans y creamos un nuevo proyecto , el cual lo desmarcamos para que no cree la clase main :
Creamos el folder en donde irá nuestra imagen; para ello clic derecho en Source Package → New → Other por lo que saldrá una ventana en la cual debemos elegir Other → Folder y finalmente le damos el nombre que queramos :
Ahora creamos un paquete Splash en el cual vamos a agregar un JFrame y también creamos una clase para el hilo que vamos a usar , por lo que les debe quedar así :
Vamos a trabajar en nuestro Frame, al cual le hacemos clic derecho → SetLayout y le damos BorderLayout hecho esto colocamos dos paneles : uno en el sur y otro en el centro (seguir el orden para no tener complicaciones). Después de haber agregado los paneles a cada uno le vamos a dar BorderLayout al igual que al frame. Hecho esto vamos a colocar en el panel del sur un JProgressBar al que le vamos a llamar progreso y en el panel central una etiqueta; nos debe quedar así :
Para cambiar el nombre del JProgresBar podemos darle clic derecho a la barra y elegimos “Change Variable name” a continuación nos saldrá la siguiente ventana en la cual debemos colocar el nombre de la barra :
En el panel central vamos a colocar una etiqueta al cual le vamos a colocar una imagen, ver esta entrada para ver como ccolocar una imagen :
En el diseñador del JFrame nos vamos a agregar código , para ello hacemos clic en en boton source ; y ya en la clase del JFrame (al cual llame Principal) le agregamos un objeto Hilo :
```
import java.awt.Color;

public class Principal extends javax.swing.JFrame
{
    HiloProgreso hilo;
```

Vamos a el constructor y le agregamos el siguiente código :

    public Principal()
    {
        //Método por defecto        
        initComponents();
        iniciarSplash();
        //Creamos un objeto HiloProgreso al cual 
        //le pasamos por parámetro la barra de progreso
        hilo=new HiloProgreso(progreso);
        //Iniciamos el Hilo
        hilo.start();
        //Le damos tamaño y posición a nuestro Frame
        this.setLocation(200,200);
        this.setSize(472,249);
        //Liberamos recursos 
        hilo=null;
    }

Creamos un método get para nuestro JProgressBar , para ello o bien lo agregamos directamente o bien hacemos que el NetBeans lo genere , para ello clic derecho sobre el atributo → seleccionamos Refactor → Seleccionamos Encapsule Fields y en la ventana que aparece simplemente seleccionamos los métodos set y get que deseamos que NetBeans genere

Hecho esto aparecerá la siguiente línea de código :

    public javax.swing.JProgressBar getjProgressBar1() {
        return progreso;
    }

Ahora si podemos crera nuestro método iniciar Splash :

    public void iniciarSplash() {
        this.getjProgressBar1().setBorderPainted(true);
        this.getjProgressBar1().setForeground(new Color(50, 50, 153, 100));
        this.getjProgressBar1().setStringPainted(true);
    }

NetBeans nos debe estar marcando un error , esto se da porque aún no hemos creado nuestra clase HiloProgreso ; para ello clic en el paquete Splash → New → Java Class y a la clase le damos de nombre HiloProgreso y la vamos hacer que extienda de Thread ; en esta clase debemos crear una referencia a la barra de progreso que vamos a pasar por parámetros para lo cual declaramos un JProgressBar progreso :
```
package Splash;

import javax.swing.JProgressBar;

public class HiloProgreso extends Thread
{
    JProgressBar progreso;
```

Ahora vamos a crear nuestro método constructor el cual va a tener como parámetros una barra de progreso1 , se debe observar como se da la relación de asociación ; es decir la referencia del objeto que pasó por parámetro la asigno a la referencia que cree anteriormente y con esto puedo usar todos sus métodos (el super es para llamar al método constructor de la clase Thread y por ley debe ser la primera línea en el método constructor de la clase hija) :
```
public class HiloProgreso extends Thread
{
    JProgressBar progreso;

    public HiloProgreso(JProgressBar progreso1)
    {        
        super();
        this.progreso=progreso1;
    }
```

Hecho esto vamos a crear el método run que va a servir para correr el hilo :

    public void run()
    {
        for(int i=1;i<=100;i++)
        {
            progreso.setValue(i);
            pausa(100);
        }
    }

Y por último creamos nuestro método pausa , que como el nombre indica nos va a dar una pausa para que la barra de progreso no llegue al 100% n bien corramos la aplicación :

    public void pausa(int mlSeg)
    {
        try
        {
            // pausa para el splash
            Thread.sleep(mlSeg);
        }catch(Exception e){}
    }

Hecho esto presionamos F6 y veremos algo como esto :

El ejemplo lo pueden descargar desde aquí :

* Si el link de descarga no funciona, por favor ir a la sección de carpeta compartida que se encuentra a la derecha , esta les enviará directamente a mi carpeta compartida → en la carpeta compartida ir a Ejemplos → Ejemplos de Java → Cap_18_NetBeans → Splash.

* Respecto a llamar una aplicación despues de terminado el splash les pediría tiempo para modificar la aplicación y que haga eso ( a mas tardar mañana lo estoy modificando)

Conectando SQL Server y Netbeans con JDBC – Parte 2

2009-12-02T04:58:00.000-08:00

Buenos días antes que nada quiero pedir disculpas por demorarme en publicar este post …tuve algunos problemas con la PC pero bueno ya todo se arreglo y vamos a ver la segunda parte de la conexión entre SQL Server y NetBeans.Para poder llevar a cabo la conexión de nuestra base de datos con nuestra aplicación en Java es necesario que previamente hagamos algunos ajustes al SQL Server 2005 ; los ajustes que se deben hacer se encuentran en esta entrada (Si ya revisaron este post sería bueno que lo revisen nuevamente pues se ha hecho algunos ajustes).

Hecho esto el siguiente paso es configurar nuestro NetBeans para terminar con la conexión a la base de datos :

I.- REQUISITOS

Haber configurado el Microsoft SQL Server 2005 ; sino lo hiciste visita esta entrada :
NetBeans IDE
Conector de SQL Server para Java , que se puede descargar de aquí .
Una aplicación en Java, sino la tienes aquí crearemos una sencilla.
La base de datos Pubs, si no la haz agregado a tu base de datos , lo puedes hacer de esta forma.

II.- CREACIÓN DEL PROYECTO

Abrimos el NetBeans y creamos nuestro proyecto en el cual vamos a colocar un JPanel (PanelPrincipal) y un JFrame (Principal) ; vamos al PanelPrincipal al cual le damos el Border Layout ; en el NORTE colocaremos un botón y en el CENTRO un Text Area :

OBSERVACIÓN :Antes de colocar un Txt Area es recomendable colocar un JScrollPane para poder visualizar el contenido que supera los limites del textArea

Ahora nos vamos al JFrame llamado Principal en el cual agregaremos el Panel que hemos creado previamente:

    public Principal()
    {
        initComponents();
        add(new PanelPrincipal());
        setSize(500,400);
    }

III.- AGREGANDO EL JAR AL PROYECTO

Descomprimimos el conector que habíamos descargado previamente .

Y encontraremos las siguientes carpetas :

Agregamos las librerías sqljdbc y sqljdbc4 a nuestro proyecto ; para ello clic derecho el Libraries → Add JAR

IV.- ESTABLECIENDO LA CONEXIÓN

Nos vamos al panel de nombre Panel Pricipal y importamos las siguientes librerías :

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;

Vamos a el diseño del gráfico y le damos doble clic en el boton Consultar para programar su acción y le agregamos el siguiente código:

private void btnConsultaActionPerformed(java.awt.event.ActionEvent evt) {                                            
    String connectionUrl = "jdbc:sqlserver://localhost:1433;" +
			"databaseName=pubs;user=sa; password=adminadmin;";		
    // Declaramos los sioguientes objetos
    Connection con = null;
    Statement stmt = null;
    ResultSet rs = null;
    try {
        //Establecemos la conexión
        Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
        con = DriverManager.getConnection(connectionUrl);
        // Create and execute an SQL statement that returns some data.
        String SQL = "SELECT * FROM AUTHORS";
        stmt = con.createStatement();
        rs = stmt.executeQuery(SQL);
        this.muestraData(rs);
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
    finally {
        if (rs != null) try { rs.close(); } catch(Exception e) {}
        if (stmt != null) try { stmt.close(); } catch(Exception e) {}
        if (con != null) try { con.close(); } catch(Exception e) {}
    }

}

Finalmente vamos a crear nuestro método muestraData

public void muestraData(ResultSet r) throws Exception
{
    ResultSetMetaData rmeta= r.getMetaData();
    int numColumnas= rmeta.getColumnCount();//Cuántas columnas  		
    txtSalida.setText("");		
    for(int i=1; i<=numColumnas; ++i) 
	//obtiene nombre de columna
	txtSalida.append(rmeta.getColumnName(i) + "\t"); 
	txtSalida.append("\n");
  	while(r.next())
        {	// hasta fin de archivo
            for(int i=1;i<=numColumnas;++i)
            {
                txtSalida.append(r.getString(i) + "\t");
            }
            txtSalida.append("\n");
        }
}

Hecho esto ejecutamos el proyecto y nos deberá salir lo siguiente :

El ejemplo lo pueden descargar aquí :

V.- ERRORES

Hay que actualizar el SQL Server 2005 al service Pack 3 para que esto pueda funcionar.

Conectando SQL Server y Netbeans con JDBC – Parte 1

2009-12-02T04:00:00.000-08:00

En este primer tutorial se tratará de mostrar los ajustes que se deben realizar en sql server 2005 para poder conectarlo al netbeans , para lo cual necesitaremos algunas herramientas y la base de datos pubs que previamente la descargamos y adjuntamos en nuestro SQL; sino se tiene la base de datos pubs puedes mirar este post o puedes usar cualquier base de datos que tengas.

I.- REQUISITOS

Microsoft SQL Server 2005.
Microsoft SQL Server JDBC Driver ; si no lo tienes lo puedes descargar aquí.
NetBeans IDE

II.- OBSERVACIONES

Por defecto el SQL Server 2005 no permite conexiones remotas y tiene deshabilitado la cuenta sa ; así que si tratamos de conectarnos nos mostrará el siguiente mensaje de error :
Otro problema que se nos puede presentar cuando deseemos conectarnos es que las conexiones TCP/IP estén deshabilitadas , para lo cual al tratar de conectarnos nos mostrará la siguiente excepción :
Network error IOException: Connection refused: connec

III.- CONFIGURANDO EL SQL SERVER PASO A PASO

HABILITAR TCP/IP :
- Vamos al menú inicio → Todos los programas → Microsoft SQL Server 2005 → Herramientas de configuración → SQL Server Configuration Manager :
- En el parte izquierda de la ventana del SQL Server Configuration Manager vamos a expandir la opción de Configuración de red de SQL Server 2005 y click en Protocolos de SQLEXPRESS y le damos clic derecho en TCP/IP y elegimos la opción de habilitar (al hacer esto saldrá una advertencia que indica que los cambios no surtirán efecto hasta que se reinicie el servicio) :
- Ahora iremos a las propiedades de TCP/IP y nos dirigimos a la pestaña de Direcciones IP → IPALL y cambiamos el valor de puertos dinámicos por el valor de 1433 (este valor es necesario cuando intentemos conectarnos con el netbeans) ; nuevamente al aceptar nos saldrá la advertencia de reiniciar para que los cambios tengan efecto :
- Ahora vamos a reiniciar el servicio ; para ello nos vamos al panel izquierdo → clic en la opción Servicios de SQL Server 2005 → y nos vamos al panel derecho en SQLEXPRESS y le damos reiniciar :
HABILITANDO EL MODO DUAL DE CONEXIÓN : AUTENTICACIÓN DE SQL SERVER Y AUTENTICCIÓN DE WINDOWS
- Iniciar sesión del SQL Server Management Studio 2005 en modo de autenticación de Windows :
- En el explorador , hacer clic derecho en el nombre de instancia y seleccionar propiedades.
- Seleccionamos la opción de Seguridad y cambiamos el modo de autenticación de Windows al Modo de autenticación de Windows y SQL Server
- A continuación nos saldrá una advertencia en la cual se nos indica que los cambios surtirán efecto cuando s reinicie SQL Server (esto lo haremos mas adelante).
- Nos vamos a la instancia y reiniciamos :
HABILITAR LA CONEXIÓN REMOTA EN LA CONFIGURACIÓN DE SUPERFICIE :

Abrir la Configuración se superficie de SQL Server 2005
Seleccionar la configuración de superficie para servicios y conexiones :
Expandimos la instancia de SQLEXPRESS → Motor de base de datos → Conexiones remotas y seleccionamos (en el lado derecho) : Conexiones locales y remotas → Usar TCP/IP y canalización con nombre :
En la pestaña se Servicios; cambiamos el tipo de inicio por Automático y le damos en aceptar (nuevamente nos saldrá una advertencia la cual indica que se tiene que reiniciar el servicio) :
Iniciar sesión del SQL Server Management Studio 2005 en modo de autenticación de Windows.
En el panel derecho, vamos a Seguridad → Inicio de sesión y buscamos el usuario sa clic derecho → propiedades :
En las propiedades ingresamos una contraseña para este usuario y en la pestaña de estado le damos los permisos de conexión a la base de datos y el inicio de sesión :
Ahora solo nos queda reiniciar el servicio para que los cambios se efectúen :

OBSERVACIÓN : Si al tratar de reiniciar el Servicio de SQL Server ocurre un error es porque se debe ingresar en modo de administrador;para ello damos clic derecho en el icono de SQL server → Ejecutar como administrador .

Pues bien hasta aquí ya le hemos dado permisos al usuario “sa” para que puede hacer conexión remota usando el dual boot es decir el doble inicio de sesión :

Ejemplos de JFreeChart – Parte 2

2009-11-29T04:28:00.001-08:00

En esta oportunidad les traigo otro ejemplo mas …. se trata de la gráfica PieChart que al igual que los anteriores ejemplos si se va a colocar en un proyecto aparte necesita que agreguemos las librerías que previamente configuramos.

Todos estos gráficos se colocan en un JFrame ….si alguien sabe como colocarlo dentro de un JInternalFrame le agradecería que me apoye con esa información. Hay que tener en cuenta que los métodos que estoy usando no son todos ….hay una variedad de métodos para diseñar mejor nuestro gráfico , pero ya depende de cada uno explorar esta parte y descubrir lo que JFreeChart puede y también lo que no soporta.

Una recomendación final para poder usar mejor los métodos es necesaria la documentación , esta se genera a la hora de instalar las librerías … pero yo no pude hacerla trate de hacerla con el ant de apache pero no me funcionó ( si alguien sabe como generar la documentación de JFreeChart le agradeceré que me brinde esa información para actualizar la entrada de instalación y de paso que me ayude a mí). SIn mas que decir vamos a empezar con una clase …yo la he llamado PieChart :

Esta clase así como en el anterior ejemplo la hacemos heredar de la clase ApplicationFrame
```
public class PieChart extends ApplicationFrame
```

Después de esto vamos a importar las siguientes librerías :

import java.awt.Color;
import javax.swing.JPanel;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PiePlot;
import org.jfree.data.general.DefaultPieDataset;
import org.jfree.data.general.PieDataset;
import org.jfree.ui.ApplicationFrame;

Luego de esto vamos a construir el método constructor

    public PieChart(String titulo)
    {
        super(titulo);
        this.setContentPane(crearDemoPanel());
    }

Vamos a crear el método crearDataSet en el que vamos a crear la data del gráfico ; este método lo podemos mejorar colocando un parámetro el cual nos envíe la data a colocar :

    private static PieDataset crearDataSet()
    {
        DefaultPieDataset data=new DefaultPieDataset();
        data.setValue("Uno",new Double(43.2));
        data.setValue("Dos",new Double(10.0));
        data.setValue("Tres",new Double(27.5));
        data.setValue("Cuatro",new Double(17.5));
        data.setValue("Cinco",new Double(11.0));
        data.setValue("Seis",new Double(19.4));
        return data;
    }

Luego algo simple,hacemos el método crearChart ( hay que observar que nos pide un parámetro y devuelve un objeto del tipo JFreeChart) , este método lo que hace es crear el frame donde irá el gráfico ( si le en vez de ChartFactory.createPieChart colocamos ChartFactory.createPieChart3D tendremos un gráfico en 3D) :

    private static JFreeChart crearChart(PieDataset data)
    {
        JFreeChart chart = ChartFactory.createPieChart(
                "Demo de PieChart",     //Nombre del gráfico
                data,                   //data
                true,                  //Leyenda
                true,
                false);        
        //Color de la ventana
        chart.setBackgroundPaint(Color.ORANGE);
        PiePlot plot = (PiePlot)chart.getPlot();
        //Color de las etiquetas
        plot.setLabelBackgroundPaint(Color.ORANGE);
        //Color de el fondo del gráfico
        plot.setBackgroundPaint(Color.WHITE);
        plot.setNoDataMessage("No hay data");

        return chart;
    }

Vamos a crear el último método ..este es de dos líneas nada más

    public static JPanel crearDemoPanel()
    {
        JFreeChart chart=crearChart(crearDataSet());
        return new ChartPanel(chart);
    }

Y por último en la clase main :

public class Main
{
    public static void main(String[] args)
    {
        PieChart demo2= new PieChart("PieChartDemo02");
        demo2.pack();
        RefineryUtilities.centerFrameOnScreen(demo2);
        demo2.setVisible(true);
    }
}

Finalmente este será nuestro resultado :
El ejemplo lo podremos descargar desde aquí :

Ejemplos de JFreeChart – Parte 1

2009-11-28T18:05:00.001-08:00

Después de instalar y hacer las configuraciones de la librería jfreechart ahora procedemos a ver los diferentes tipos de gráficos que podemos crear con esta librería ; para ello colocaré algunos ejemplos que se han encontrado en la librería demo de JFreeChart y en la web.

Antes que nada vamos a crear un nuevo proyecto con el NetBeans → luego agregaremos las librerías que anteriormente habíamos configurado a nuestro proyecto , para esto : clic derecho en la carpeta Libraries → Add Library y agregamos las librerías JFreeChart :

Hecho esto ya podemos empezar a crear nuestros gráficos ( esto lo vamos a hacer para cada proyecto en el que queremos usar la librería JFreeChart ).

GRÁFICO BARCHART

Creamos una clase y hacemos que herede de la clase Application frame , para ello debemos importar la librería : import org.jfree.ui.ApplicationFrame ; esto debe quedar así :
```
public class BartChart extends ApplicationFrame
```

Hecho esto vamos a importar las siguientes librerías :

import java.awt.Color;
import java.awt.Dimension;
import java.awt.GradientPaint;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.CategoryAxis;
import org.jfree.chart.axis.CategoryLabelPositions;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.renderer.category.BarRenderer;
import org.jfree.data.category.CategoryDataset;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.ui.ApplicationFrame;

Vamos a crear nuestro método constructor :

    public BartChart(String title)
    {
        super(title);
        CategoryDataset dataset= crearDataset();
        JFreeChart chart=crearChart(dataset);
        ChartPanel panel = new ChartPanel(chart,false);
        panel.setPreferredSize(new Dimension(700,500));
        this.setContentPane(panel);
    }

Hecho esto NetBeans nos pedirá que creemos dos métodos : crearDataset y crearChart que son métodos propios que nosotros crearemos y que mas adelante iremos completando :

    private static CategoryDataset crearDataset()
    {
        ........
        ........        
        return dataset;
    }

    private static JFreeChart crearChart(CategoryDataset data)
    {
        ........
        ........ 
        return chart;
    }

Ahora vamos a llenar nuestro método crearDataset :

    private static CategoryDataset crearDataset()
    {
        //Nombre de las filas
        String serie1 ="Primero";
        String serie2 ="Segundo";
        String serie3 ="Tercero";
        //Nombre de las columnas
        String categoria1="Categoria1";
        String categoria2="Categoria2";
        String categoria3="Categoria3";
        String categoria4="Categoria4";
        String categoria5="Categoria5";

        DefaultCategoryDataset dataset = new DefaultCategoryDataset();
        //Aquí vamos a llenar nuestra data
        //pero esta data la podemos pasar por parámetros 
        dataset.addValue(1.0, serie1,categoria1);
        dataset.addValue(4.0, serie1,categoria2);
        dataset.addValue(3.0, serie1,categoria3);
        dataset.addValue(5.0, serie1,categoria4);
        dataset.addValue(5.0, serie1,categoria5);

        dataset.addValue(5.0, serie2,categoria1);
        dataset.addValue(7.0, serie2,categoria2);
        dataset.addValue(6.0, serie2,categoria3);
        dataset.addValue(8.0, serie2,categoria4);
        dataset.addValue(4.0, serie2,categoria5);

        dataset.addValue(4.0, serie3,categoria1);
        dataset.addValue(3.0, serie3,categoria2);
        dataset.addValue(2.0, serie3,categoria3);
        dataset.addValue(3.0, serie3,categoria4);
        dataset.addValue(6.0, serie3,categoria5);

        dataset.addValue(1.0, serie1,categoria1);
        dataset.addValue(4.0, serie1,categoria2);
        dataset.addValue(3.0, serie1,categoria3);
        dataset.addValue(5.0, serie1,categoria4);
        dataset.addValue(5.0, serie1,categoria5);
        return dataset;
    }

Vamos a llenar el siguiente método, espero que los comentarios sean claros (si se desea cambiar la dirección de las barras debemos colocar PlotOrientation.VERTICAL por la que se encuentra en el ejemplo ) :

    private static JFreeChart crearChart(CategoryDataset data)
    {
        JFreeChart chart= ChartFactory.createBarChart(
                "Demo de BartChart",        //Nombre de la gráfica
                "Categorías",               //Nombre del eje Horizontal
                "Valores",                  //Nombre del eje vertical
                data,                       //Data
                PlotOrientation.HORIZONTAL, //Orientación
                true,                       //Incluir leyenda
                true,                       //Información al pasar el mouse
                true);                      //URls
        //Dar color al fondo del panel
        chart.setBackgroundPaint(Color.ORANGE);
        //Dar color a cada categoria
        CategoryPlot plot =(CategoryPlot) chart.getPlot();
        plot.setBackgroundPaint(Color.BLUE);
        //Color del fondo del gráfico
        plot.setBackgroundPaint(Color.WHITE);
        //Lineas divisorias
        plot.setDomainGridlinesVisible(true);
        plot.setRangeGridlinePaint(Color.BLACK);
        //Calculo de los valores en el eje x
        final NumberAxis rangeAxis=(NumberAxis) plot.getRangeAxis();
        rangeAxis.setStandardTickUnits(NumberAxis.createIntegerTickUnits());

        BarRenderer renderer = (BarRenderer) plot.getRenderer();
        renderer.setDrawBarOutline(false);
        //Dar color a cada barra
        GradientPaint gp0= new GradientPaint(0.0f,0.0f,Color.blue,0.0f,0.0f,new Color(0,0,64));
        GradientPaint gp1= new GradientPaint(0.0f,0.0f,Color.green,0.0f,0.0f,new Color(0,64,0));
        GradientPaint gp2= new GradientPaint(0.0f,0.0f,Color.red,0.0f,0.0f,new Color(64,0,0));
        renderer.setSeriesPaint(0,gp0);
        renderer.setSeriesPaint(1,gp1);
        renderer.setSeriesPaint(2,gp2);

        CategoryAxis domainAxis = plot.getDomainAxis();
        domainAxis.setCategoryLabelPositions(
                CategoryLabelPositions.createUpRotationLabelPositions(Math.PI/6.0));
        return chart;
    }

Finalmente en nuestra clase main escribiremos lo siguiente :

import org.jfree.ui.RefineryUtilities;
public class Main
{
    public static void main(String[] args)
    {
        BartChart demo1 = new BartChart("BarChartDemo01");
        demo1.pack();
        RefineryUtilities.centerFrameOnScreen(demo1);
        demo1.setVisible(true);
    }    
}

Este es el resultado final :

El ejemplo lo pueden descargar de aquí :

Tablas y gráficos dinámicas en Excel 2007

2009-11-19T04:59:00.001-08:00

Una tabla dinámica es una tabla interactiva que contiene campos , los que se usan para resumir y analizar atendiendo a varios criterios de agrupación,representado como una tabla de doble entrada que nos facilita la interpretación de dichos datos. Es dinámica porque nos permite ir obteniendo diferentes totales, filtrando datos, cambiando la presentación de los datos, visualizando o no los datos origen, etc. La tabla dinámica se puede actualiza conforme se vayan actualizando los datos de la tabla origen. A partir de esta tabla nosotros podemos crear un gráfico dinámico el cual al igual que la tabal dinámica se relaciona con los datos a propia tabla dinámica ; es decir si se modifican los datos en cualquiera de los lados el gráfico también se modifica. Sin mas preámbulo vamos a ver como crear una tabla dinámica :

Para empezar debemos contar con una tabla simple como esta (obviamente puede tener mas datos) :
El siguiente paso es seleccionar la tabla CTTRL + E ( o simplemente dejar el cursor dentro de la tabla ) y nos vamos a Insertar y elegimos tabla dinámica ( ojo que también podemos elegir crear un gráfico dinámico , pero eso lo vamos a hacer luego) :
Hecho esto nos saldrá una ventana en la que vemos que toda la tabla origen ha sido seleccionada ; en esta ventana podremos dar la opción de colocar la tabla dinámica en la actual hoja de trabajo o sino podemos colocarla en una nueva :
Hecho esto, se creará una nueva hoja como la que se muestra :
Ahora solo tenemos que agregar un check a las cabeceras que queremos aparezcan en la tabla dinámica , y veremos como se irá creando la tabla :
Podemos usar la pestaña de opciones de la tabla dinámica para realizar múltiples opciones como la de crear un gráfico dinámico ,para ello hacemos clic en la tabla dinámica y automáticamente aparecerá la opción en la parte superior :
Hacemos clic en gráficos dinámicos y automáticamente se creará nuestro gráfico dinámico (elegimos el tipo de gráfico que deseamos usar):
Y ya tendremos nuestro gráfico dinámico , el cual podremos actualizar moviendo los datos de el origen y luego actualizamos :
Podemos usar la pestaña del gráfico así como la pestaña presentación para darle una mejor presentación a nuestro gráfico :
Podemos guiarnos mejor con este video :

PARA EXCELL 2007

PARA EXCELL 2003

Cambiar la ubicación la carpeta de favoritos en IE y Firefox

2009-11-16T01:00:00.001-08:00

Cuando instalamos Firefox , IE o Google Chrome en nuestro PC, estos crean automáticamente perfiles predeterminados para su navegador.
Estas carpeta contiene toda la información relacionada con el navegador : Para firefox (marcadores, historial de navegación, extensiones instaladas, etc.) , IE (favoritos), etc. El inconveniente de esta carpeta es que se encuentra en la partición donde está el sistema operativo .Si por algún problema no pudiéramos acceder al sistema operativo, perderíamos toda esta información.
Para evitar esta pérdida de datos ( que en muchos casos son valiosos ) modificaremos el lugar donde se guardan todos estos marcadores , para ello tenemos que tener en cuenta el navegador que usamos :

I.- PARA FIREFOX

MOVIENDO LA CARPETA DE LOS FAVORITOS :
- Antes que nada debemos mostrar los archivos ocultos , esto depende del sistema operativo en el que nos encontremos :
1. En Xp es simple : Abrimos cualquier carpeta → Herramientas → Opciones de carpeta → Nos vamos a la pestaña Ver y seleccionamos la opción de mostrar archivos , carpetas y unidades ocultas.
2. Windows Vista y Windows 7 : no traen por defecto la barra de herramientas así que abrimos cualquier carpeta nos vamos a Organizar → Diseño y le damos check a la barra de menús y hacemos el punto anterior.
3. Para Linux : es algo similar , abrimos la carpeta Home → nos vamos a Ver → y activamos la opción para ver las carpetas ocultas.
- Ahora vamos a mover el contenido de la carpeta por defecto a una nueva ubicación que hemos creado :
1. Para XP : C:\Documents and Settings\NOMBRE_DE_USUARIO\ApplicationData\Mozilla \Firefox\Profiles
2. Para Windows 7 y Vista : C:\users\NOMBRE_DE_USUARIO\ApplicationData\Local\Mozilla \Firefox\Profiles
3. Para Linux : /home/ NOMBRE_DE_USUARIO/.mozilla/firefox/
- En esta carpeta encontraremos una carpeta con el siguiente nombre : xxxx.default ; es esta carpeta la que vamos a mover pues esta representa el perfil por defecto que Firefox crea al momento de la instalación (copiamos esta carpeta a una nueva dirección) .
CREANDO UN NUEVO PERFIL :
- Nos aseguramos de cerrar todas las ventanas de Firefox ( para ello Abrimos el administrador de tareas) , vamos a la pestaña Procesos y buscamos aquellos procesos que digan firefox.exe los seleccionamos y pulsamos terminar proceso .
- Ahora debemos abrir el editor de perfiles , para lo cual hay varias opciones según el sistema operativo en que nos encontremos :
1. Para XP : Menú → Inicio → Ejecutar → firefox.exe ––profilemanager (son dos “-” antes de profilemanager)
2. Para Windows Vista y Windows 7 : En la barra de búsqueda del menú inicio escribimos firefox.exe -–profilemanager
3. Para cualquier distro de Linux : Abrimos el terminal → firefox –-profilemanager
- Nos saldrá la siguiente ventana :
- Es aquí donde crearemos un perfil ; para ellos hacemos clic en crear perfil y nos saldrá una ventana en la cual le damos Siguiente .
- A continuación colocaremos el nombre de nuestro perfil , elegimos la ubicación de nuestra carpeta ( La que elegimos en el paso anterior) y le damos clic en finalizar :
- Hecho esto ya tenemos nuestra perfil creado :
- Ahora solo nos queda seleccionar el perfil “default” y eliminarlo.

II.- PARA IEXPLORER

Para Internet Explorer es aún mas sencillo, primero vamos a crear una carpeta llamada favoritos en la unidad que queramos.
Ahora nos ubicamos en la carpeta por defecto → Clic derecho → Ubicación → Mover y seleccionamos la carpeta que habíamos creado anteriormente :
Y listo eso es todo .. ahora tenemos nuestros favoritos en una unidad diferente.

No es recomendable usar unidades externas (como USB) como unidades para guardar os favoritos , temas , etc. , se debe elegir como unidad a un disco duro interno.

Como Programar Java – Deitel & Deitel

2009-11-15T03:45:00.000-08:00

Bueno aquí les dejo los links para que puedan descargar el libro de Como Programar Java de Deitel & Deitel ; estos están divididos en 3 partes las cuales lo pueden descargar de mi SkyDrive haciendo clic en el siguiente ícono :

El libro contiene los siguientes capítulos :

CAP 00 : PREFACIO
CAP 01 : INTRODUCCIÓN A LAS COMPUTADORAS
CAP 02 : INTRODUCCIÓN A LAS APLICACIONES EN JAVA
CAP 03 : INTRODUCCIÓN A LOS APPLETS
CAP 04 : INSTRUCCIONES DE CONTROL - PARTE 01
CAP 05 : INSTRUCCIONES DE CONTROL - PARTE 02
CAP 06 : MÉTODOS
CAP 07 : ARREGLOS
CAP 08 : PROGRAMACION BASADA EN OBJETOS
CAP 09 : POO
CAP 10 : POLIMORFISMO
CAP 11 : CADENAS Y CARACTERES
CAP 12 : GRAFICOS Y JAVA 2D
CAP 13 : GUI - PARTE 01
CAP 14 : GUI - PARTE 02
CAP 15 : MANEJO DE EXCEPCIONES
CAP 16 : SUBPROCESAMIENTO MULTIPLE
CAP 17 : ARCHIVOS Y FLUJOS
CAP 18 : REDES
CAP 19 : IMAGENES Y SONIDOS EN LOS APPLETS
CAP 20 : ESTRUCTURA DE DATOS
CAP 21 : PAQUETES
CAP 22 : COLEECCIONES
CAP 23 : CONECTIVIDAD A BASES DE DATOS
CAP 24 : SERVLETS
CAP 25 : JSP
CAP 26 : PARTE FINAL

ACTUALIZACIÓN : Gracias a un mensaje que me llegó a mi correo de Génesis Cabrera , pues me indicó que existe en internet la 7ma Edición y esta disponible en : taringa en donde la podrán descargar . Lo interesante de esto es que las páginas son a full color no escaneadas , es decir la calidad de la imagen es muy buena …jejeje lo único malo =’( es que está en ingles .

Instalación de JFreeChart

2009-11-13T00:54:00.001-08:00

El Proyecto JFreeChart que vio la luz en el año 2000 es una librería de código abierto (Open Source) para Java, que permite crear diagramas de forma práctica y sencilla. Con JFreeChart podremos hacer diferentes tipos de gráficos que van desde los tipos comunes tales como gráficos circulares , gráficos de barras , áreas , gráficos de línea , histogramas , diagramas de Gantt y más específicos y menos frecuentemente utilizados como tipos Candlestick , Viento y Wafer Map . Para mas información sobre esto revisar la documentación Javadoc de las clases JFreeChart y ChartFactory.

I.- REQUISITOS

El paquete JFreeChart , el cual podremos descargar desde http://sourceforge.net/projects/jfreechart/ aunque el sitio oficial de JFreeChart es http://www.jfree.org/jfreechart/
El paquete JCommon, se descarga de http://sourceforge.net/projects/jfreechart/files/3.%20JCommon/
La documentación del JFreeChart (opcional) .

Es necesario descargar descargar el paquete JFreeChart ; opcionalmente se recomienda descargar también el paquete JCommon. Aunque una versión parcial del mismo ya viene incluido dentro de JFreeChart.

II- CONFIGURACIÓN DE EL JFREECHART Y EL JCOMMON

A continuación iniciaremos los pasos para poder configurar JFreeChart en la IDE NetBeans :

Una vez que descargamos el paquete JFreeChart y el paquete JCommon lo descomprimimos en un directorio de la PC .
Ahora abriremos el NetBeans para configurar las librerías de JFreeChart y JCommon , por lo tanto en NetBeans nos vamos al menú Tools y Seleccionamos Libraries :
Hacemos clic en New Library y escribimos “JCommon-1.0.16” como nombre de la librería luego iremos a la pestaña Classpath → Add Jar/Folder y luego buscamos la dirección del JCommon descargado anteriormente y seleccionamos el archivo JCommon-1.0.16.jar :
Hacemos lo mismo con el jar que descargamos del JfreeChart , OJo que el jar que seleccionamos en este caso es el de la carpeta lib .
Hecho esto ya tenemos configurado las librerías de JFreechart y JCommon en el NetBeans ; hora ya podremos generar un gráfico .

OBSERVACIÓN : Hay que tener en cuenta que solo hemos agregado los JAR mas no hemos generado la documentación de los archivos que hemos colocado en las librerías, una forma es mediante el archivo ant que ofrece apache pero no lo coloco porque aún estoy revisándolo, cuando me corra actualizaré el blog o si alguien sabe como hacerlo(generar el javadoc) le agradecería me apoye con la info.

III.- CREANDO UN GRÁFICO EN NETBEANS USANDO JFREECHART

Creamos un nuevo proyecto , para ello vamos al menú File → New Projct → Java Application y dejamos el Create Main Class activado para que nos pueda generar la clase main (esto no es indispensable pues se puede colocar la generación de los gráficos en una clase aparte – solo que para efectos del ejemplo lo vamos a hacer así – )
Ahora vamos a agregar las librerías que hemos agregado anteriormente a este nuevo proyecto , para ello vamos a la pestaña Projects → En el nodo Libraries → Clic derecho add Library y seleccionamos las librerías JFreeChart y jCommon .

Y ahora en la clase Main colocaremos lo siguiente :

package jfreechart;

import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartFrame;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;

public class Main
{
    public static void main(String[] args) 
    {
        //Crear un dataset
        DefaultPieDataset data = new DefaultPieDataset();
        data.setValue("Categría 1",43.2);
        data.setValue("Categría 2",27.9);
        data.setValue("Categría 3",79.5);
        //Creamos un Chart
        JFreeChart chart = ChartFactory.createPieChart(
                           "Ejemplo de JFreeChart", //Títrulo del gráfico
                           data,
                           true,//Leyenda
                           true,//ToolTips
                           true);
        //Creamos una especie de frame y mostramos el JFreeChart en él
        //Este constructor nos pide el título del Chart y el chart creado
        ChartFrame frame=new ChartFrame("Primer Chart para javax0711",chart);
        frame.pack();
        frame.setVisible(true);
    }
}

Compilamos , ejecutamos la aplicación y listo ya tenemos nuestro primer gráfico generado

Macros en Excel

2009-11-09T20:26:00.001-08:00

Bueno ahora vamos a tomar uno de los tantos cursos publicados en aulaclic.com el cual se recomienda porque y aquí podrás encontrar excelente material .

Cuando trabajamos con un libro personalizado, es decir, que nos hemos definido con una serie de características específicas como puedan ser el tipo de letra, el color de ciertas celdas, los formatos de los cálculos y características similares, perdemos mucho tiempo en formatear todo el libro si disponemos de muchas hojas.

Con las macros lo que se pretende es automatizar varias tareas y fusionarlas en una sola, añadiendo por ejemplo un botón en nuestro libro que al pulsar sobre él realice todas esas tareas.

La forma más fácil e intuitiva de crear macros es crearlas mediante el grabador de macros del que dispone Excel.

Este grabador de macros te permite grabar las acciones deseadas que posteriormente las traduce a instrucciones en VBA, las cuales podemos modificar posteriormente si tenemos conocimientos de programación.

Para grabar una macro debemos acceder a la pestaña Vista y despliega el submenú Macros y dentro de este submenu seleccionar la opción Grabar macro...

Además de esta opción en el menú podemos encontrar las siguientes opciones:

Ver Macros... - Donde accedemos a un listado de las macros creadas en ese libro.

Usar referencias relativas - Con esta opcion utilizaremos referencias reativas para que las macros se graben con acciones relativas a la celda inicial seleccionada.

Al seleccionar la opción Grabar macro..., lo primero que vemos es el cuadro de diálogo Grabar macro donde podemos dar un nombre a la macro (no está permitido insertar espacios en blanco en el nombre de la macro).

Podemos asignarle un Método abreviado: mediante la combinación de las tecla CTRL + "una tecla del teclado". El problema está en encontrar una combinación que no utilice ya Excel.

En Guardar macro en: podemos seleccionar guardar la macro en el libro activo, en el libro de macros personal o en otro libro.

En Descripción: podemos describir cuál es el cometido de la macro o cualquier otro dato que creamos conveniente.

Para comenzar la grabación de la macro pulsamos el botón Aceptar y a continuación, si nos fijamos en la barra de estado, encontraremos este botón en la barra de estado donde tenemos la opción de detener la grabación.

A partir de entonces debemos realizar las acciones que queramos grabar, es conveniente no seleccionar ninguna celda a partir de la grabación, ya que si seleccionamos alguna celda posteriormente, cuando ejecutemos la macro, la selección nos puede ocasionar problemas de celdas fuera de rango.

Una vez concluidas las acciones que queremos grabar, presionamos sobre el botón Detener de la barra de estado, o accediendo al menú de Macros y haciendo clic en .

Activar el menú de Ubuntu con la tecla de Windows

2009-11-09T03:14:00.001-08:00

Quizás a la mayoría de gente como yo que recién nos estamos iniciando en el software libre ( es nuestra primera vez ]:) jejeje ) , nos cuesta mucho adaptarnos , ya que si en Windows queríamos ir al menu inicio pues solo era cuestión de presionar una tecla y ya estábamos en el menú; en Ubuntu esto no esta configurado por defecto , entonces habría que configurarlo de la siguiente manera :

Vamos a Sistemas → Preferencias → Combinaciones de teclas ().
Una vez allí buscamos la acción : Mostrar el menú del panel ; le hacemos clic y a continuación presionamos la tecla de Windows ; y esta automáticamente se asignará.Nos quedará algo así :

La Clase String

2009-11-08T05:47:00.001-08:00

La clase String representa una cadena de caracteres. Todos los literales de la cadena tales como “abc” son implementados como instancias de ésta clase.

La clase String incluye métodos que permiten examinar los caracteres individuales de una cadena para compararlos, ubicarlos extraerlos como sub cadenas y para crear copias de una cadena convirtiendo todos sus caracteres a mayúsculas o minúsculas.

Java provee un soporte especial para la concatenación (unión) de cadenas con el operador (+). y para convertir otros objetos a cadenas.La concatenación de cadenas es implementada a través de la clase StringBuffer y su método append(). Las conversiones son implementadas a través del método toString() definido en la clase Object la cual es heredada por todas las clases en Java.

I.- PARA TENER EN CUENTA :

La clase String pertenece al paquete java.lang.
Existen diferentes formas para crear objetos String como las siguientes :
- String str =”abc”;
- char str[] = {‘a’,’b’,’c’}; //arreglo de caracteres
- String str = new String (“abc”) ; //objeto con valor inicial “abc”
El lenguaje java proporciona el operador “+” para concatenar (unir) objetos String.
Un objeto String representa una cadena de caracteres no modificable;por lo tanto, una operación como convertir a mayúsculas o minúsculas no modificará el objeto original sino que devolverá un nuevo objeto con la cadena resultante de esa operación el cual deberá ser guardado en otro objeto string.

II.- JERARQUÍA DE CLASES

III.- MÉTODOS MAS IMPORTANTES

String (String valor) .- Se usa cuando se desea crear una cadena de caracteres :
- String cadena = “Hola”
- String cadena = new String (“Hola”); //Constructor de la clase String
cadena.concat(string txt) .- Devuelve como resultado un nuevo objeto String resultado de concatenar dos cadena :

String cadena = “Hola”         
String result= cadena.concat(" Mundo");//El resultado será Hola mundo

cadena.compareTo(String otra cadena) .- Compara lexicográficamente la cadena con otra cadena , esta comparación es caracter por caracter teniendo en cuenta que las mayúsculas son mayores que las minúsculas – esto es de acuerdo al código ASCII o UNICODE – según esto devuelve :
- < 0 : si cadena < otra cadena
- = 0 : si cadena = otra cadena
- > 0 : si cadena > otra cadena
- JUAN > juan
- Juan > Carlos
- JUAN > JUAn
- abcde > abcdefg
cadena.toIgnoreCase(String otra cadena) .- Hace lo mismo que compareTo pero con la única diferencia que no se hace diferencia entre mayúsculas y minúsculas ; es decir : JUAN = juan
cadena.length() .- Devuelve la longitud o número de caracteres de la cadena :

String cad="Hola Mundo";
int cant = cad.length();// El valor de cant será 10
cadena.toLowerCase() .- Convierte a minúsculas las letras mayúsculas de la cadena

cadena.toUpperCase().- Convierte en mayúsculas las letras minúsculas de la cadena.

String cad1="Esto Es Una Prueba";
String cad2=cad1.toUpperCase();//cad2 será igual a : ESTO ES UNA PRUEBA.

cadena.trim () .- Elimina los espacios en blanco que puedan haber al principio o al final de la cadena.
```
String cad1="     Esto Es Una Prueba   ";
String cad2=cad1.toLowerCase();//cad2=Esto Es Una Prueba.
```

IV.- MÉTODOS

CONSTRUCTORES
*Constructor*		*Descripción*
String( )		Crea un nuevo objeto String vacío sin caracteres.
String (byte[ ] bytes)		Crea un nuevo objeto String inicializado con los caracteres equivalentes a cada número guardado en el arreglo de bytes.
String (char[ ] value)		Crea un nuevo objeto String inicializado con los caracteres contenidos en el arreglo dado como parámetro.
String (String cadena)		Crea un nuevo objeto String inicializado con el valor dado como parámetro.
MÉTODOS
*Tipo de retorno*	*Método*	*Descripción*
char	charAt(int index)	Retorna el carácter correspondiente al índice dado como parámetro.
int	compareTo(String otraCadena)	Retorna como entero el resultado de la comparación entre la cadena que lo llama con otraCadena. Si el parámetro devuelto es "0" significa que las dos cadenas son iguales; realizándose la comparación carácter con carácter diferenciándose las mayúsculas con las minúsculas.
int	compareToIgnoreCase(String otraCadena)	Retorna como entero el resultado de la comparación de la cadena que lo llama con otraCadena. Si éste entero es 0 significa que ambas cadenas son iguales; siendo la comparación carácter con carácter pero ignorando la diferencias entre mayúsculas y minúsculas.
String	concat(String otraCadena)	Retorna el resultado de la concatenación de la cadena con otraCadena dada como parámetro.
boolean	equals(Object otroObjeto )	Retorna true si la cadena que lo llama es igual al objeto enviado como parámetro.
boolean	equalsignoreCase(String otraCadena)	Retorna true si la cadena que lo llama es igual a la cadena dad como parámetro ignorando las diferencias entre mayúsculas y minúsculas.
int	indexOf (String cad)	Retorna la posición de la primera ocurrencia encontrada de la cadena dada como parámetro dentro de la cadena que llama al método.
int	indexOf (String cad, int ini)	Retorna la posición de la primera ocurrencia encontrada de la cadena dada como parámetro pero comenzando la búsqueda desde la posición ini dada como parámetro.
int	lastIndexOf (String cad)	Retorna la posición de la ultima ocurrencia de la cadena dada como parámetro.
int	lastIndexOf (String cad,int ini)	Retorna la posición de la última ocurrencia de la cadena dada como parámetro buscando en retroceso a partir de la posición dada como parámetro.
int	length ( )	Retorna el número de caracteres que contiene la cadena.
String	replace (char car1,char car2)	Retorna una nueva cadena como resultado de reemplazar todas las ocurrencias del carácter "car1" por el carácter "car2" dados como parámetros.
String	replaceAll (String cad1,String cad2)	Retorna una nueva cadena como resultado de reemplazar todas las concurrencias de la sub cadena cad1 por la sub cadena cad2 dada como parámetro.
boolean	startsWith (String cad)	Retorna true si la cadena que llama al método empieza con la subcadena cad dada como parámetro.
String	subString(int posIni)	Retorna una subcadena cuyo primer carácter empieza en la posición posIni dada como parámetro.
String	subString(int posIni,int posFin)	Retorna una subcadena cuyo primer carácter empieza en la posición posIni y termina con el carácter de la posición posFin.
String	toLowerCase( )	Retorna una nueva cadena como resultado de convertir todos los caracteres a minúsculas.
String	toUpperCase ( )	Retorna una nueva cadena como resultado de convertir todos los caracteres a mayúsculas.
String	trim ( )	Retorna una nueva cadena como resultado de omitir los espacios en blanco al inicio y al final de la cadena.

V.- EJEMPLOS

Diseñe una aplicación que permita manipular los caracteres de una subcadena a través de los métodos vistos.

Creamos un nuevo proyecto al cual colocaremos en un paquete; en este nuevo paquete vamos a agregar un JFrame al cual le daremos el tipo de distribución GridLayout con 2 columnas ; hecho esto en la primera columna colocamos un JPanel (jPanel1) y le damos una distribución de BorderLayout ( en este panel colocamos en el NORTE una caja de texto , en el CENTRO un ScrollPane y encima un txtArea …por último en el SUR colocamos una etiqueta) ; en la segunda columna colocamos otro JPanel (JPanel2) con distribución GridLayout on 2 columnas y 7 filas y simplemente arrastramos botones hacia este panel y veremos que se irán ordenando como se ve en la imagen anterior. Se les recuerda que visiten esta entrada para tener mas información sobre los tipos de distribución y esta entrada para ver como crear un proyecto con NetBeans. Bien , hecho todo esto la vista de objetos se verá de esta forma (Observar la forma de como se esta distribuido)

Ahora vamos a programar cada botón , para esto solo basta con darle doble clic y enseguida NetBeans nos llevará al método correspondiente :

Vamos a programar el botón longitud el cual nos dirá la cantidad de caracteres de la cadena que ingresaremos en el textArea ; para poder obtener el valor escrito en la caja de texto usaremos el método getText y para escribir el resultado en el área de texto usaremos el método setText.

private void btnLongitudActionPerformed(java.awt.event.ActionEvent evt) {                                            
// lee el mensaje
String cadena=txtMensaje.getText();

// obtiene la longitud
int longi = cadena.length();

// imprime longitud
txtSalida.setText("El texto ingresado tiene: "+longi+" caracteres.");
}

Regresamos al diseñador y le hacemos doble clic al botón Separar Palabras y ingresamos el siguiente código :

private void btnSeparaPalabrasActionPerformed(java.awt.event.ActionEvent evt) {                 
// lee el mensaje
String cadena=txtMensaje.getText();
// obtiene la longitud
int longi = cadena.length();
// limpia area
txtSalida.setText("");
// inicializa contador de palabras
int contpala=0;
// separa palabras por el espacio en blanco
do {
// no considera espacios al inicio ni al final
cadena=cadena.trim();
// ubica posicion del primer caracter blanco
int pos=cadena.indexOf(' ');
// obtiene palabra encontrada
String palabra="";
if (pos>0)
palabra=cadena.substring(0,pos+1);
else
palabra=cadena;
// imprime palabra encontrada
txtSalida.append(palabra+"\n");
// ignora palabra encontrada
cadena=cadena.substring(palabra.length());
// actualiza contador de palabras
contpala++;
} while(cadena.length()>0);
// imprime contador de palabras
txtSalida.append("\n"+contpala+" palabras encontradas.");
}

Hacemos lo mismo con el botón de mayúsculas

private void btnMayusculasActionPerformed(java.awt.event.ActionEvent evt) {                                              
// TODO add your handling code here:
// lee el mensaje
String cadena=txtMensaje.getText();
// lo convierte a mayúsculas
cadena = cadena.toUpperCase();
// imprime nueva cadena en mayusculas
txtSalida.setText("Texto convertido a mayúsculas:\n"+cadena);
}

Y con el botón de minúsculas :

private void btnMinusculasActionPerformed(java.awt.event.ActionEvent evt) {                         
// lee el mensaje
String cadena=txtMensaje.getText();
// lo convierte a minúsculas
cadena = cadena.toLowerCase();
// imprime nueva cadena en minusculas
txtSalida.setText("Texto convertido a minúsculas:\n"+cadena);
}

Lo propio con el botón de caracteres y los demás botones ( que por motivo de tiempo y espacio no se van a colocar pero lo pueden descargar pulsando el botón descargar )

Por ultimo ejecutamos con F6

Como cambiar el ícono a un JFrame

2009-11-06T20:24:00.000-08:00

los pasos son los seguientes:

1)El ícono debe ser una imagen de extensión PNG. Esto se hace más fácil, ya que conseguir una figura y convertirlo en formato .ico es muy complicado. Los PNG nos ayudan bastante.

2)La imagen que será el ícono debe estar dentro del paquete de fuentes, como si fuera una clase más. Si estuviera dentro de un paquete, sería mucho mejor.

3)En el código del JFrame que vamos a poner el ícono, sobreescribimos el método getIconImage() conteniendo el siguiente código: (notar cómo se está llamando a la imagen .png)

public Image getIconImage() {
Image retValue = Toolkit.getDefaultToolkit().
getImage(ClassLoader.getSystemResource("resources/icono.png"));

return retValue;
}

4)En la vista de diseño del JFrame, lo seleccionamos y vamos sus propiedades, buscamos la propiedad "iconImagen" y hacemos clic en el botón de puntos suspensivos. Se mostrará una ventana de diálogo como esta:

De la lista desplegable, seleccionamos "Valor de componente existente". Esto hará que cambie la ventana a la siguiente forma:

Seleccionamos la opción "Propiedad" y hacemos clic en el botón de puntos suspendidos. Aparecerá una ventana de diálogo más pequeña, y seleccionamos la propiedad "iconImage" que aparece ahí.

le damos Clic en Aceptar, y se verá así:

y nuevamente clic en "Aceptar" para cerrar la ventana de selección de imagen.

Ahora, veremos que las propiedades del JFrame ya tiene un nuevo valor

Ejecutamos la aplicación con el JFrame y veremos nuestro JFrame con un ícono diferente.

Crear un Índice en Word 2007

2009-11-04T05:59:00.001-08:00

Entre las novedades que nos trajo Microsoft Office 2007, mas específicamente Word 2007 está la creación de índices , las cuales a diferencia de Word 2003 que se tenía que hacer manualmente esta permite crearla instantáneamente para ello lo único que debemos tener es nuestro documento con sus respectivos títulos :

Partimos desde el punto que tenemos ya nuestro documento con los títulos y subtítulos hechos :

Seleccionamos primero los títulos y nos iremos a la pestaña de Referencias → Agregar texto y elegimos el nivel 1 para los títulos , nivel 2 para los subtítulos ,etc ( es decir el nivel que deseamos que aparezca la palabra seleccionada en el índice ); repetimos todo esto hasta que hallamos terminado con todos los títulos y subtítulos que queramos que aparezca en el índice.

Ahora agregamos una hoja en blanco al inicio y nos vamos a referencia → Tabla de contenidos y seleccionamos el estilo de nuestro índice :

Hecho esto nuestra tabla de contenidos estará lista :

Cada vez que coloquemos un título en el cuerpo del documento, lo seleccionamos y marcamos el nivel correspondiente. Luego nos dirigimos al índice , lo seleccionamos y vamos a Referencia → Actualizar tabla → Actualizar toda la tabla para que aparezcan los nuevos títulos creados en nuestro documento.

Sistema de ficheros

2009-11-04T04:30:00.001-08:00

En GNU / Linux cualquier elemento es tratado como un fichero , desde nuestros archivos personales hasta los dispositivos de hardware como la impresora, el mouse, los dispositivos de almacenamiento, etc. A Esto se le conoce como Sistema de ficheros ; los sistemas nativos de Linux son ext2 o ext3 (Ubuntu se instala sobre ext3), aunque GNU/Linux es capaz de trabajar con distintos tipos (incluyendo FAT Y NTFS).

♦ Esta es el árbol de archivos en Windows XP :

♦ Este es el árbol de ficheros en Linux :

A continuación algunos de los ficheros básicos para comprender la lógica del sistema son :

/bin : Contiene los ejecutables (binarios) esenciales para el sistema. Si observamos su contenido encontraremos los comandos más básicos.
/boot : Aquí están los archivos usados por el sistema durante el arranque, incluida la imagen del núcleo.
/dev : Almacena los controladores (device drivers o device files) para el acceso a los dispositivos físicos del disco como el mouse , las tarjetas, el scanner, etc.
/var : Contiene información variable, tanto la generada por el propio sistema como por los usuarios.
/lib : Contiene librerías usadas por diferentes aplicaciones evitando que cada programa incluya las suyas propias; asi se evita la redundancia.
/etc : Directorio usado para almacenar todos los archivos de configuración del sistema.
/home : Contiene el árbol de directorios propios de cada usuario del sistema. Se encontrará un subdirectorio para cada usuario para salvaguardar la confidencialidad de los datos de cada usuario. Es recomendable instalarlo en una partición diferente para salvaguardar los datos en caso de ocurrir una reinstalación del sistema.
/sbin : Aquí se encuentran los comandos esenciales de administración del sistema, normalmente reservados para el administrador.
/usr : Aquí se almacenan las aplicaciones y recursos disponibles para todos los usuarios del sistema.
/tmp : Es el directorio temporal usado generalmente por las aplicaciones para almacenar algunos ficheros en tiempo de ejecución.
/media : Aquí descienden os ficheros dónde se montarán automáticamente las unidades extraíbles , como el cdrom , usb .

♦ /media/cdrom0 : Para la primera unidad de cdrom.

♦ /media/usbdisk : Para la memoria usb.

♦ /media/floppy : Para el disquete.

Visualizar los iconos en el escritorio de Ubuntu.

2009-11-04T04:23:00.001-08:00

Una vez que terminamos de instalar Ubuntu en nuestra pc; en la pantalla principal aparece esto :

Y quizás nos vemos en la necesidad de tener los iconos que deben aparecer por defecto ; estos hay que activarlos de la siguiente forma :

Primero presionamos : alt+F2 para ejecutar una aplicación ; nos saldrá esta pantalla y en ella escribimos gconf-editor.

Y hecho esto iremos al editor de configuraciones; seleccionamos : apps -> nautilius -> desktop ; una vez en ella ubicamos el valor home_icon_name para habilitarlo activamos la opción home_icon_visible.

Y bueno hecho esto ya tenemos los iconos mas importantes en nuestro escritorio como son : La carpeta personal , el equipo , la papelera, etc.

Activar el teclado numérico en Ubuntu

2009-11-04T04:12:00.001-08:00

Bueno para los que venimos de Windows a veces es muy molesto que Ubuntu no venga con esta función predeterminada , pero tranquilos aquí les traigo una solución sencilla que funciona tanto en Ubuntu 7.10 hasta la última versión.

Vamos a instalar numlock...así que abrimos el terminal (Aplicaciones → accesorios → terminal) y escribimos :

sudo aptitude install numlockx

Una vez hecho esto, nos pedirá nuestra contraseña de usuario y tendremos que esperar unos minutos mientras se instala numlockx.
Nuevamente vamos al terminal y escribimos :

sudo gedit /etc/gdm/Init/Default

Hecho esto se nos abrirá una ventana; nos vamos al final del archivo y colocamos antes del exit 0 el siguiente código :

if [ -x /usr/bin/numlockx ]; then

/usr/bin/numlockx on
fi

Hecho esto reiniciamos y veremos que cuando iniciamos sesión nuestro bloque numérico esta activado.

La Clase JInternal Frame

2009-11-01T17:13:00.001-08:00

Por herencia la clase JInternalFrame y sus clases descendientes (subclases directas) pueden utilizar los datos y/o métodos de la superclase JComponent de la librería swing y de las superclases container , Component y Object de la librería awt .

Esta clase permite tener objetos livianos que proporcione muchas de las características de un frame, incluyendo el desplazamiento, cierre, inserción de íconos, redimensionamiento, título y soporte para un menú bar.

El contentPane es manejado por una instancia de la clase JRootPane, la cual maneja una distribución de objetos y opcionalmente un menú bar para el frame interno.

Se recomienda el uso de un JDesktopPane para colocar los frames internos .

I.- JERARQUÍA DE CLASES

II.- MÉTODOS

CONSTRUCTORES
*Constructor*		*Descripción*
JInternalFrame ()		Crea un frame interno no redimensionable, no cerrable, no maximizable, no iconificable y sin título.
JInternalFrame (String título)		Crea un frame interno no redimensionable, no cerrable, no maximizable, no iconificable y con el título indicado como parámetro.
JInternalFrame (String título ,boolean resizable)		Crea un frame interno no cerrable, no maximizable, no iconificable pero con título y redimensionable.
JInternalFrame (String título ,boolean resizable ,boolean closable )		Crea un frame interno no maximizable, no iconificable pero con título, redimensionable y cerrable según los parámetros indicados.
JInternalFrame (String título ,boolean resizable ,boolean closable ,boolean maximizable )		Crea un frame interno no iconificable pero con título, redimensionable, cerrable y maximizable según los parámetros indicados.
JInternalFrame (String título ,boolean resizable ,boolean closable ,boolean maximizable ,boolean iconificable)		Crea un frame interno con título, redimensionable ,cerrable, maximizable e iconificable.
MÉTODOS
*Tipo de retorno*	*Método*	*Descripción*
void	dispose( )	Hace el frame interno invisible, no seleccionable y cerrado.
Container	getContentPane( )	Retorna el content Pane
int	getDefaultCloseOperation( )	Retorna el valor de la operación que ocurre cuando el usuario cierra el frame.
Component	getFocusOwner( )	Si el JInternalFrame es activo, retorna el elemento enfocado.
Icon	getFrameIcon( )	Retorna el icon mostrado en la línea de título del frame interno.
JMenuBar	getJMenuBar( )	Retorna el JMenuBar del frame interno , o nulo si no tiene.
Component	getMostRecentFocusOwner()	Retorna el elemento del frame interno que recibió el enfoque cuando el frame estuvo seleccionado.
String	getTitle( )	Retorna el título.
boolean	isClosable( )	Retorna true si el frame interno es cerrable, de lo contrario retorna falso.
boolean	isClosed( )	Retorna true si el frame interno está cerrado , de lo contrario retorna false.
boolean	isIcon( )	Retorna true si el frame interno tiene ícono , de lo contrario retorna false.
boolean	isMaximizable( )	Obtiene el valor de la propiedad maximizable.
boolean	isMaximum( )	Retorna true si el frame interno está maximizado de lo contrario retorna false.
boolean	isResizable( )	Retorna true si el frame interno es redimensionable de lo contrario retorna false.
boolean	isSelected( )	Retorna true si el frame interno está seleccionado de lo contrario retorna false.
void	remove(Component comp)	remueve el componente dado como parámetro de su contenedor.
void	reshape(int x, int y, int ancho,int alto)	Mueve y redimensiona al frame interno según el valor de los parámetros dados.
void	setClosable(boolean b)	Hace cerrable al frame interno si el valor del parámetro es true.
void	setClosed(boolean b)	Cierra el frame interno si el valor del parámetro dado es true.
void	setDefaultCloseOperation(int operation)	Define la operación que debe suceder por defecto cuando el usuario cierra el frame interno. El valor por defecto es HIDE_ON_CLOSE. Otros posibles valores son DO_NOTHING_ON_CLOSE y DISPOSE_ON_CLOSE
void	setFrameIcon(Icon icono)	Establece el icono en el frame interno.
void	setJmenuBar(JMenuBar menu)	Establece la barra de menú del frame interno con el menú dado como parámetro.
void	setLayout(LayoutManager manager)	Establece una distribución diferente a la establecida por defecto.
void	setMaximizable(boolean b)	Establece la propiedad maximizable a través del valor dado como parámetro.
void	setMaximum(boolean b)	Maximiza el frame interno.
void	setResizable(boolean b)	Establece la propiedad resized a través del valor dado como parámetro.
void	setSelected(boolean selected)	Selecciona o deselecciona el frame interno, según el valor del parámetro.
void	setTitle(String título)	Establece el título del frame interno.
void	show( )	Muestra el frame interno.
void	toBack( )	Envía el frame interno hacia adelante.
void	toFront( )	Envía el frame interno hacia adelante.

III.- EJEMPLOS

Diseñe una aplicación que permita, a través de un botón colocar frame internos dentro del frame principal. Por cada frame que se crea debe asignarse un número correlativo. En la parte inferior colocar otro botón para cerrar todos los frames que fueron cerrados.

Creamos un nuevo proyecto al cual le agregamos un paquete y a este paquete le agregamos un JFrame Form de nombre Principal (Para ver como crear un proyecto con NetBeans visitar esta entrada).

A este frame le daremos la propiedad de BorderLayout , para ello clic en el frame → SetLayout → BorderLayout ( si deseas saber mas sobre los layout visita este enlace ) ; una vez hecho esto colocaremos un JScrollPane en el centro ( para ello en la parte izquierda del NetBeans buscamos el JScroolPane y lo arrastramos al centro del frame ) y encima de el JScrollPane colocamos el JDesktopPane ; luego colocamos dos botones uno en el norte y otro en el sur ; así debe quedar el proyecto :

OBSERVACIÓN : El JDesktopPane es imprescindible en un frame que va a contener JInterlFrame . El ScrollPane contiene al JDesktop porque el contenido de éste puede sobrepasar su dimensión y en ese caso deben aparecer las barras de desplazamiento.

Una vez creada la interfaz, vamos a crear la lógica del programa : vamos a la pestaña Source para ir al código fuente y declaramos dos variables ( un contador y una posición inicial – lacual va a ser la posición en la cual aparecerá el primer JInternal Frame)
```
public class Principal extends javax.swing.JFrame {
private int contador=1;
private int posicion=0;

public Principal() {
initComponents();
setSize(400,400);}
```

Regresamos al diseño y hacemos doble clic en el botón Crear para programar la acción (nos llevará al método private void btnCreaActionPerformed(java.awt.event.ActionEvent evt) en la cual colocaremos lo siguiente :

private void btnCreaActionPerformed(java.awt.event.ActionEvent evt) {                                        
// TODO add your handling code here:
creaInternalFrame();
} 
public void creaInternalFrame(){
JInternalFrame f = new JInternalFrame("InternalFrame "+contador,
true, // cambia tamaño
true, // se cierra
true, // maximizable
true // minimizable
);
f.setLocation(posicion*50 + 10, posicion*50+10);
desktop.setPreferredSize(new Dimension(400+(posicion*50), 400+(posicion*50)));
f.setSize(200,150);
f.setBackground(new Color(200,255,255));// color de fondo
desktop.add(f); // coloca en el desktop
f.setVisible(true); // lo hace visible en primer plano
contador++;
posicion++;}

Ahora regresamos al diseño para darle la lógica al botón cerrar :

private void btnCierraActionPerformed(java.awt.event.ActionEvent evt) {                                          
// TODO add your handling code here:
desktop.removeAll();
desktop.repaint();
contador=1;
posicion=0;}

Hecho esto obtendremos lo siguinente :

Si desean descargar el ejemplo visiten mi sitio en Skydrive (donde podrán encontrar mas ejemplos – En el menú de arriba encontrarán el enlace - ) o simplemente denle clic al boton descargar :

Creando ejecutable para Java

2009-11-01T04:44:00.001-08:00

En esta entrada se tratará de crear un archivo .exe para nuestros proyectos de Java, pues como bien sabemos Java solo genera código intermedio (bytecode) , es decir archivos con la extensión .class y con el NetBeans solo podemos crear archivos .jar .

Pues bien existe una forma ( no es la única ) para poder generar archivos .exe y es mediante la herramienta libre JSmooth .

I.- CARACTERÍSTICAS DEL JSMOOTH

Es libre.

Se puede generar un ejecutable que contenga a la aplicación o que utilice un jar separado.
Se pueden añadir mensajes al usuario para que instale correctamente la aplicación.
Es posible incorporar el JRE (para que la aplicación lo use en un directorio especifico) para que el usuario no tenga que instalarlo.

II.- REQUISITOS

Tener una aplicación a la cual se ha creado el .jar
JSmooth , se puede descargar aquí ( la instalación es sencilla )

III.- CREACIÓN DEL .EXE

Eligiendo el esqueleto del proyecto .- Pues bien esta primera parte depende mucho de la aplicación para la cual queremos crear el ejecutable. En nuestro caso usaremos una aplicación con ventanas así que elegiremos la opción Windowed Wrapper. JSmooth nos ofrece dos posibilidades : para aplicaciones de consola ( línea de comandos) y aplicaciones de ventanas :

Aquí hay que tener en cuenta algunas consideraciones :
- Message : Es el mensaje que se le va a mostrar al usuario cuando la máquina virtual(JRE) no se encuentre .
- URL : Indica la URL desde donde el usuario puede bajar la JRE
- Launck java app in the exe process : Sirve para lanzar la aplicación Java en otro proceso distinto.
- Debug console : Si lo marcamos, se mostrará una línea de comandos de Windows con el detalle de todo lo que pasa por detrás. (Esto es útil para saber como funciona el JSmooth).
Configurando el ejecutable .- Es aquí donde le diremos a JSmooth que nos cree un ejecutable , se indica el lugar en donde se creará el ejecutable y el icono del ejecutable (en Executable Binry tendremos que digitar la ruta en donde se creará el ejecutable)
Configurando la aplicación .- En esta parte primero elegimos el jar de la aplicación ; hecho esto vamos a Main class y buscamos la clase main del proyecto ( es importante seguir el orden para que les pueda aparecer la lista de clases de su proyecto en el Main class) ; en mi caso yo tengo solo una clase que será el JFrame llamado principal y dentro de el estará mi clase main , si se tiene el método main en una clase aparte pues se deberá elegir esa clase :
Configurando la maquina virtual .- Aquí configuramos algunos datos de la máquina virtual , como son :

Minimum JVM versión : Indica la versión mínima de la maquina virtual que tendrá que instalar el usuario si desea correr la aplicación , 1.5 es lo recomendable .
Maximun JVM versión : Indica la versión máxima con la que se debe contar ; pero dejarlo en blanco es lo mejor.
JVM Bundle : Esta parte es genial ya que nosotros podemos agregar al ejecutable la maquina virtual para que el usuario no tenga que estar instalándola ; solo debemos indicar el lugar en donde se encuentra el JRE en nuestra PC y JSmooth lo buscará y agregará a nuestro proyecto .
JVM Search Sequence : Si no hemos activado el JVM Bundle esta opción nos permite indicar a JSmooth el orden de busqueda de la máquina virtual-

Generando el ejecutable .- Primero guardamos el proyecto y luego iremos a Proyect → Compile para poder generar el ejecutable ; les debe salir algo como esto :

Clase JFrame

2009-10-31T20:57:00.001-07:00

Por herencia la clase JFrame y sus clases descendientes (subclases directas ) pueden utilizar los datos y/o métodos de la superclase Frame, Window , Container , Component y Object de la librería awt.

La clase JFrame es ligeramente incompatible con la clase Frame. Como todo otro contenedor de alto nivel de la librería Swing, un JFrame contiene un JRootPane como su único elemento. El contentPane proporcionado por el rootPane debería , como una regla , contener todos los componentes que no sean menú mostrados por el JFrame.

A diferencia del Frame , un JFrame tiene alguna noción de como responder cuando el usuario intenta cerrar la ventana. El comportamiento por defecto es simplemente ocultar el JFrame cuando el usuario cierra la ventana. Para cambiar el comportamiento por defecto se debe invocar al método setDefaultCloseOperation() .

I.- JERARQUÍA DE CLASES

II.- MÉTODOS

ATRIBUTOS
static int	EXIT_ON_CLOSE	La salida por defecto al cerrar una ventana.
CONSTRUCTORES
	JFrame()	Crea un nuevo frame que es inicialmente visible
	JFrame(String título)	Crea un nuevo frame con el título indicado como parámetro
MÉTODOS
Tipo de retorno	Método	Descripción
Container	getContentPane()	Retorna el objeto contentPane.
int	getDefaultCloseOperation()	Retorna la operación que ocurre cuando el usuario hace la operación de cerrar la ventana del frame
JMenuBar	getJMenuBar()	Retorna el menúBar establecido en el frame
void	remove(Component comp)	Remueve el componente indicado como parámetro de éste contenedor
void	setContentPane(Container contentPane)	Establece la propiedad del contentPane
void	setDefaultCloseOperation(int operation)	Establece la operación que sucederá por defecto cuando el usuario cierra la ventana
void	setJMenuBar(JMenuBar menu)	Establece la barra de menú para el frame
void	setLayout(LayoutManager layout)	Por defecto, la distribución de los paneles de éste componente no debe cambiarse; en su lugar, debería ser cambiada la distribución de su contentPane que generalmente es un panel.

III.- OTROS MÉTODOS

Para Colocar el nombre en la ventana del JFrame :
```
this.setTitle("Título del frame");
```

Para maximizar la ventana de JFrame

this.setExtendedState(this.MAXIMIZED_BOTH);

Para desactivar el botón de cierre del JFrame

this.setDefaultCloseOperation(0);

this.setDefaultCloseOperation(this.DO_NOTHING_ON_CLOSE);

Para hacer visible al frame
```
this.setVisible(true);
```

OBSERVACIÓN : Todos estos métodos se deben invocar en el constructor del JFrame; es decir :

public Principal() 
{
panAcces = new panAcceso();
admin = new Administrador();
listadoAlu = new ListaAlumnos();
initComponents();
fecha = new Fecha();
//Maximizar la ventana del JFrame
this.setExtendedState(this.MAXIMIZED_BOTH);
//Evita que se cierrre el frame con el boton salir esquivale a this.setDefaultCloseOperation(0);
this.setDefaultCloseOperation(this.DO_NOTHING_ON_CLOSE);
this.setTitle("SISTEMA INTEGRAL DE NOTAS - SIN");
lblFecha.setText("" + fecha.iniciarComponentes()); 
try
{
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
catch (Exception e)
{
e.printStackTrace();
}        
}

IV.- EJEMPLOS

Diseñe una aplicación con dos frames, uno de bienvenida y otro de despedida activados a través de botones como se muestra a continuación :

Solucionar error 18456 al conectar a SQL Server 2005

2009-10-07T07:33:00.001-07:00

Después de terminada la instalación de SQL Developer 2005 tuve un problema con el Windows Vista Ultimate (esto no sucede con el XP) en el cual no se podía iniciar la sesión saliendo el siguiente error :

Lo cual ocurre porque el usuario no tiene permisos de administrador para iniciar sesión, una forma fácil de solucionarlo es entrando como administrador ; pero hacerlo siempre así como que resulta incomodo :

Por suerte encontré la forma de solucionarlo :

• Iniciamos como administrador (o con el usuario sa) y le damos conectar :

• Vamos Seguridad → Inicio de sesión y creamos un nuevo usuario :

• Colocamos un nombre de sesión del tipo : NOMBRE DE PC\NOMBRE DE USUARIO

• Nos vamos a la opción de funciones del servidor y marcamos la opción de sysadmin

• Por último le damos en aceptar y veremos que el usuario ha sido agregado; hecho esto ya podemos conectarnos al SQL Server 2005 sin mayor problema.

Cargar base de datos Pubs y Northwind en SQL2005

2009-10-07T06:39:00.001-07:00

Muchas veces cuando instalamos el SQL Server 2005 no nos instala las bases de datos pubs y northwind por defecto; para esto nosotros lo podemos instalar para lo cual necesitaremos la base de datos pubs y northwind que se puede descargar aquí y lo instalamos.

Las bases de datos que acabamos se encuentran en : C:\SQL Server 2000 Sample Databases

Ahora abrimos el SQL Server Management Studio

Y le damos clic en conectar

El siguiente paso es adjuntar las base de datos pubs y northwind :

Le damos clic en agregar

Pulsamos Aceptar

Tendremos que esperar a que se ejecute al consulta y luego observaremos que la base de datos se ha cargado y podemos tener acceso a sus tablas:

Si al adjuntar la base de datos ocurre el siguiente error ; entonces el SQL Server Management 2005 se debe ejecutar como administrador:

Insertar y obtener imágenes en un fichero JAR con NetBeans

2009-04-12T07:37:00.001-07:00

En una aplicación cliente de escritorio realizada con Java Swing nos va a ser muy útil poder obtener las diferentes imágenes e iconos de la aplicación accediendo a ficheros JAR pertenecientes a nuestra aplicación.

Su utilidad radica en que al tener localizadas las imágenes en nuestros ficheros JAR no tenemos que localizarlas directamente en nuestro disco duro. Si este fuera el caso el día que quisiéremos migrar por ejemplo nuestra aplicación de Windows a Linux tendríamos que modificar todo el código referente a la localización de las imágenes porque estas están en un path tipo C:\... que Linux no va a entender.

Para ver como insertamos y obtenemos una imagen en un fichero JAR con NetBeans vamos a ver el siguiente ejemplo en el cual queremos añadir algunas imágenes a la siguiente aplicación :

1.- Primero de todo vamos a crear una nueva carpeta llamada imágenes seleccionando con el botón derecho la carpeta Source Packages → New → Other

2.- En la ventana continua seleccionamos Other → Folder

3.- Ahora le damos el nombre a nuestra carpeta (en este caso Imagenes ) y la ubicamos en la carpeta src y por último seleccionamos Finish :

4.- Ahora observamos como se ha creado nuestra carpeta en el proyecto :

5.- Ahora seleccionamos el componente el botón al cual colocaremos la imagen y hacemos clic sobre el botón correspondiente a la propiedad icon

6.- En el cuadro de diálogo seleccionamos la opción External Image y hacemos clic sobre el botón que está a la derecha del campo de texto File or URL: para buscar e incorporar la imagen que se encuentra en en nuestra PC.Hecho esto hacemos clic sobre el botón

7.- En el cuadro de diálogo elegimos el fichero que habíamos seleccionado con anterioridad y hacemos clic sobre el botón

8.- Por último seleccionamos la carpeta que habíamos creado y seleccionamos

9.- Por último damos clic en

10.- Por último creamos el archivo JAR y listo nuestras imagenes dejan de depender de la ubicación en nuestro dsco duro .

Para utilizar las imágenes desde el código podemos usar la siguiente sentencia :

….

import javax.swing.ImageIcon;
….

….
NOMBRE DEL BOTON.setIcon(new ImageIcon(getClass().getResource("/imagenes/NOMBRE DE TU IMAGEN.gif")));
...

Ejecutar la calculadora de Windows desde Java

2009-04-12T02:29:00.001-07:00

Quizás alguna vez deseamos que en nuestros proyectos halla la posibilidad de ejecutar algunos comandos de Windows , entre ellos la calculadora , el block de notas , etc.

Bueno pues aquí les traigo un código que llama a la calculadora , es sencillo lo único que hace es llamar a la clase Runtime y la clase Process ; voy a construir una aplicación …pero esto se puede colocar en el main y listo :

1.- Antes que nada así se vería mi aplicación :

2.- Ahora hago doble clic en los botones para programar los eventos :

Vemos que al hacer el doble clic de inmediato me envía al método que se ejecutará cuando se haga doble clic en el botón :

3.- Ingresamos el siguiente código ; hay que observar que calc es el comando de windows para la calculadora, si se desea ejecutar el block de notas es notepad ,etc.

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
    try        
    {
        Runtime rt = Runtime.getRuntime();           
        Process p = rt.exec("calc");            
        p.waitFor();        
    }        
    catch ( IOException ioe )       
    {            
        ioe.printStackTrace();
    }         
    catch ( InterruptedException ie )
    {            
        ie.printStackTrace();     
    }
}

4.- De seguro al haber colocado el código anterior NetBeans mostrará una advertencia como esta :

Esto se debe a que no hemos importado el paquete de excepciones , entonces resolvemos esto importándolo :

import java.io.IOException;

Y ahora simplemente ejecutaremos con F6 (y si tenemos una clase main con ALT + F6 )

__________________________________________________________

Generar un archivo JAR ejecutable

2009-04-11T04:45:00.001-07:00

Muchas veces necesitamos crear un archivo que podamos ejecutar , esto es mas cuando empezamos a trabajar con interface gráfica y en fin necesitamos crear un ejecutable. El propio NetBeans posee una sencilla forma de como crear ejecutables con nuestros proyectos para esto hay que tener en cuenta lo siguiente :

1.- Al momento de crear nuestro proyecto debemos haber desmarcado las casillas de Create Main Class y set as Main Project :

2.- Ahora nos ubicamos en nuestro proyecto , en mi caso será este proyecto :

3.- Y nos vamos a Build → Clean and Build Main Project

4.- NetBeans nos debe confirmar que ya se construyo el archivo jar de nuestra aplicación con un mensaje de BUILD SUCCESSFUL el cual nos indica que la construcción ha sido exitosa . Es en este momento que en la carpeta de nuestro proyecto se ha creado una nueva carpeta llamada dist en la cual esta nuestro archivo jar :

Ahora cada vez que deseamos ejecutar nuestro proyecto sin abrir el netbeans solo bastará con hacer doble clic en el archivo JAR y listo.

También se puede agregar nuestro archivo JAR a nuevos proyectos que desarrollemos .

__________________________________________________________

Agregar un archivo JAR a nuestro proyecto

2009-04-10T05:01:00.001-07:00

Bueno en algunas ocasiones tendremos la necesidad de reusar proyectos que hallamos desarrollado con anterioridad (véase generar un archivo JAR con NetBeans) o usar algún proyecto realizado por una persona externa.

1.- Antes que nada debemos de tener un proyecto ya creado , en mi caso yo tengo un JCalendar.JAR :

2.- Como segundo paso abrimos o creamos nuestro proyecto en el cual vamos a usar el jar anterior; en mi caso yo ya tengo creado un proyecto como este :

3.- En el proyecto que tenemos vamos a agregar el JAR del calendario :

Damos clic derecho a cualquier parte de la paleta del Netbeans (Le damos clic a Palette Maneger) :

Lo que podemos hacer es crear una nueva categoría para tener ordenados todos los JAR que coloquemos en el futuro (clic en Palette → New Category) :

Ahora vamos a cargar el JAR que se ha mencionado anteriormente : para eso vamos a add from JAR , y buscamos el archivo JAR.

A continuación seleccionaremos todos los archivos que se muestran :

Y seleccionamos la categoría que hemos creado :

A continuación veremos que se carga en la Paleta de el NetBeans :

Ahora ya disponemos de archivos que podemos cargar a nuestros proyectos …… la manera de usar ??? es simple lo usamos como si fuesen etiquetas, combo Box , etc es decir solo arrastrar y soltar en el Panel

Hay que tener en cuenta que no todos los archivos JAR se van a usar gráficamente , tenemos por ejemplo el IText que sirve para generar documentos en PDF que se agrega a la paleta y se usa en código .

Vector con menú

2009-03-02T04:29:00.001-08:00

Este es un pequeño programa que nos permite acceder a un vector por medio de un menú , se desarrollan las diferentes operaciones básicas de vectores, el paso de parámetros por medio de las funciones , el uso de punteros , la llamada de funciones dentro de funciones y bueno todo lo que se conoce como programación estructurada.

1) Siempre es bueno hacer una glosa de nuestro programa , es una buena práctica de programación.

/*--------------------------------------------------------
 -> NOMBRE DEL PROGRAMA :    VECTORES CON FUNCIONES
 -> DESCRIPCIÒN         :    clrscr() : limpia la pantalla
                             getchar(): Espera un enter para avanzar
 -> AUTOR               :    SALAZAR REQUE MIGUEL
 -> CODIGO              :    FISI - 06200036
 -> FECHA               :    03 - 05 - 07
--------------------------------------------------------*/

2) Importamos las librerías y definimos el tamaño máximo de el vector

conio.c : Nos permite el uso de las funciones getchar() , gotoxy() y clrscr() .


#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#define MAX 100

3) Declaramos nuestras funciones, en este caso se ve el paso por parámetros.


void Menu(int *op);
void LeerVector(int X[MAX],int *dim);
void MostrarVector(int X[MAX],int dim);
void CalcularPromedio(int X[MAX], int dim,int *Suma, float *prom);
void SuperanPromedio(int X[MAX], int dim,float prom);
void BuscarDato(int X[MAX],int dim);
void EliminarXPos(int X[MAX],int *dim);
void EliminarXValor(int X[MAX], int *dim);
void OrdenaVector(int X[MAX],int dim);
void InsertaVector(int X[MAX], int *dim);
void raya();

4) Creamos nuestra función principal, en la cual creamos nuestro menú :


int main()
{
      int A[MAX],B[MAX],N,op,Sum,opc1;
      char opcion;
      float prom;
      do{
         Menu(&op);
         switch(op)
         {
               case 1   :     LeerVector(A,&N);
                              printf("\n\n\t-->Presione[ENTER]para regresar al men%c\n",163);
                              getchar();getchar();break;
                         
               case 2   :     MostrarVector(A,N);
                              printf("\n\n\t-->Presione[ENTER]para regresar al men%c\n",163);
                              getchar();getchar();break;
          
               case 3   :     CalcularPromedio(A,N,&Sum,&prom);
                              cout<Presione[ENTER]para regresar al men%c\n",163);
                              getchar();getchar();break;
          
               case 5   :     printf("\n\n\n");
                              printf("\t%cEl Vector ordenado es :\n\n\n",175);
                              OrdenaVector(A,N);
                              getchar();getchar();break;
                         
               case 6   :     do{
                                 do{
                                    clrscr();
                                    printf("\n\n\n");
                                    printf("\t    Menu de eliminar elementos :\n");
                                    printf("\t    ==== == ======== ========= =\n\n");
                                    printf("\t[1] Eliminar por posicion\n\n");
                                    printf("\t[2] Eliminar por Valor\n\n");
                                    printf("\t[3] Regresar al menu\n");
                                    printf("\n\n\t-->Que desea hacer ? :");
                                    scanf("%d",&opc1);
                                 }while(opc1<1opc1>3);
                                 switch(opc1)
                                 {
                                    case 1 :  EliminarXPos(A,&N);getchar();getchar();break;
                                    case 2 :  EliminarXValor(A,&N);getchar();getchar();break;
                                 }
                              }while(opc1!=3);
                              getchar();break;
                         
               case 7   :     InsertaVector(A,&N);
                              getchar();getchar();break;
          
         }
      }while(op!=8);
      printf("\n\n\t-->");
      system("PAUSE");
      return 0;
}

5) La función LeerVector() , lo que hace es recibir un vector de tipo entero y un puntero de dimensión . En este caso se mezcla el uso de las funciones “printf” y “cout” que hacen lo mismo (en la actualidad el último compilador de devc++ solo usa el cin y el cout como funciones de lectura y escritura).

En el primer bucle do{…}while() lo que se hace es solicitar al usuario un tamaño para el vector , con las restricciones que ese valor debe ser mayor que “0” y menor que el tamaño máximo del vector .

El buclo for (…) lo que hace es llenar el vector : el scanf(…) lee el dato ingresado por el teclado y lo guarda en el A[i] ; el gotoxy coloca el cursor en las posiciones (x,y) : en este caso el valor x es constante mientras que el valor y varia de acuerdo a i .

3) Desarrollamos nuestra función mostrarVector(), a la cual se le pasa como parámetros el vector y la dimensión antes eidas con la función LeerVector(). La función raya() es solo una función desarrollada en la parte inferior y solo sirve para dar un formato a la salida.

4) La función calcular promedio recibe como parámetros al vector de enteros , la dimensión y los punteros de suma y promedio , los cuales se actualizan en las últimas líneas.

5) Lo más importante de esta función es ver el uso de parámetros , el valor prom calculado con la función anterior es pasado como un valor real a esta función.

6) La función buscar dato , comparar un dato ingresado por el usuario con los elementos de la función , en el for si se encuentra el dato se guarda la posición en donde esta el dato. Para hacerlo mas elegante se puede cambiar la bandera j por un valor booleano que se inicialice en false y cuando encuentre el dato lo vuelva true, y en este caso ya no necesitaríamos el for sino sería mas conveniente usar la estructura while().

7) La función ordenar vector lo que hace es implementar el método de burbuja (que no es el más eficiente) pero sirve para el ejemplo. (obs : en primer for lo que hace es copiar todo mi vector a un vector temporal , ya que si uso el vector X lo que va a pasar es que cuando salga de mi función el vector va a estar ordenado y lo que se pretende es que solamente se ordene cuando entre en esta función)

8) Hay dos formas de implementar la función eliminar : eliminar por posición y eliminar un valor dado del vector.

El eliminar por posición , lo primero que hace es solicitar una posición válida al usuario ; luego copia el valor de la posición i+1 en la posición i , para luego actualziar el valor de la dimensión.

Esta función hace lo mismo que la función anterior a diferencia que primero busca el valor y luego hace los movimientos.

9) La función insertar vector lo que hace es mandar al vector de enteros y al puntero a la dimensión , a estas alturas se observará que cada vez que quiero actualizar la dimensión del vector se ingresa como un puntero mientras que cada vez que quiero usar ese valor se ingresa como un valor normal . Es también necesario observar que mientras en la función se ingresa como *dim en la declaración de funciones se ingresa como &dim.

10) Y por último desarrollamos nuestro menú.

Bueno eso es todo por el momento , he tratado de explicar función por función lo que se hace , si deseas obtener el código solo haz clic en descargar.

Descargar

Unir dos imágenes con Gimp

2009-03-02T03:28:00.001-08:00

Hola de nuevo , quizás muchas veces haz intentado unir dos imágenes y se te hacía muy complicado ; bueno aquí descubrí una forma muy fácil obtener esto (y sin usar photoshop) . Antes que nada tienes que tener las imágenes a unir en mi caso serán estas imágenes :

Suponiendo que la imagen de la derecha no tenga un fondo trasparente , eso lo arreglamos con la siguiente entrada ; una vez que tenemos la imagen trasparente , seguimos lo siguiente :

• Abrimos nuestra imagen de fondo con gimp :

• Una vez abierto , obtenemos algo como esto :

• El siguiente paso es añadir nuestra segunda imagen y esto lo logramos haciendo clic derecho en la imagen de fondo → Archivo → Abrir como capas :

• Y buscaremos la imagen que vamos a insertar . En muchos casos quizás la imagen a insertar es mas grande que el fondo (como fue el caso del ejemplo)

• Esto lo solucionamos con las herramientas de gimp :

• Y aquí esta nuestro resultado :

Base de datos - Fundamentos

2009-02-03T13:30:00.001-08:00

Navegando por youtube, encontré un curso que si bien no es completo , nos da una introducción a la base de datos.En total son 6 capítulos y bueno solo espero que les sirva.

Base de datos 01 - Fundamentos

Base de datos 02 – Fundamentos

Base de datos 03 – El lenguaje SQL

Base de datos 04 – Fundamentos gestión de base de datos

Base de datos 05 – Crear un a tabla e insertar datos

Base de datos 06 – Extraer datos de las tablas

Como crear un proyecto con Netbeans

2008-12-25T16:16:00.000-08:00

En la siguiente entrada vamos a explicar como iniciar en java a través de la IDE Netbeans desde cero; primero entramos a la IDE y tendremos un espacio de trabajo como el siguiente :

Para empezar a crear un proyecto debemos hacer clic en el botón amarillo o bien en el menú : File → New Project :
En cualquiera de las dos opciones nos llevará a la siguiente ventana en la cual si deseamos crear una aplicación de escritorio elegiremos Java → Java Aplication:
A continuación nos saldrá la siguiente ventana en la cual tendremos que especificar algunos datos sobre el proyecto :
Finalmente tenemos el siguiente espacio de trabajo en la cual podremos ingresar nuestras paquetes o clases :

Colocar un fondo transparente a una imagen

2008-12-17T01:21:00.001-08:00

Muchas veces necesitamos imágenes con fondo transparente para nuestros proyectos y lo que normalmente encontramos son imágenes con fondo blanco; esta es una alternativa al Photoshop ...

Antes que nada tenemos que bajarnos el software libre GIMP en la siguiente dirección , la cual nos direccionará a la siguiente página:

Hacemos doble clic en la barra amarilla y comenzará la descarga del archivo. Si hay algún inconveniente o alguna duda con la dirección proporcionada arriba, se puede visitar la página web http://www.gimp.org.es/ ; y simplemente buscamos la sección de descargas; la instalación es rápida.

Una vez instalado GIMP nos disponemos a obtener nuestra imagen, para el caso de este blog va a ser la siguiente (aunque por lo general tienen fondo blanco,pero esto funciona para todo):

Abrimos la imagen con GIMP ; y tendremos nuestra imagen en el área de trabajo :

Hacemos clic derecho a la imagen y seleccionamos Capa → Transparencia → Añadir Canal Alfa.

Vamos a la barra de herramientas y seleccionamos Seleccionar→ Por Color :

Hecho esto nos sale un puntero tipo mano, lo único que tenemos que hacer es seleccionar el fondo de color negro con el puntero y tendremos una imagen como la que sigue (observamos que se ha delimitado el contorno de la figura):

Como último paso seleccionamos Editar → Cortar

Guardamos el trabajo : Archivo → Guardar como (abrimos Seleccionar tipo de archivo ) y elegimos el formato a guardar (es recomendable guardarlo en PNG o GIF , si se guarda en JPG va a regresar a lo mismo) y en las ventanas que aparecen solo tenemos que darles en Exportar y Guardar.

Y al fin tendremos nuestra imagen con fondo transparente :

Herramientas CASE

2008-11-16T04:18:00.001-08:00

“ Un sistema complejo toma forma cuando alguien tiene la visión de cómo la tecnología puede mejorar las cosas. Los desarrolladores tienen que entender completamente la idea y mantenerla en mente mientras se crea el sistema que le dé forma, esto sumado al buen entendimiento entre las personas que generan la idea con el desarrollador, garantizan el éxito de proyectos ”

1.- ¿QUÉ ES UML?

UML es un lenguaje visual para especificar, construir y documentar sistemas, actualmente es una de las herramientas más usadas en el desarrollo de sistemas, esto se debe a que permite a los creadores de sistemas generar diseños que capturen sus ideas en forma convencional y fácil de comprender para comunicarlas a otras persona.

Entre las principales características se mencionan:

Es independiente de implementaciones, plataformas y lenguajes.
Los modelos son utilizados en todas las ingenierías.

Una clase en un diagrama de UML está compuesta por tres secciones:

Los modificadores de acceso se denotan de la siguiente manera:

Los miembros públicos se denotan con el signo “+”.
Los miembros privados se denotan con el signo “-”.

El UML es utilizado para el desarrollo de componentes de software en diversos campos y fue aceptado como un estándar por el OMG (Object Management Group - Grupo de administración de objetos) en noviembre de 1997.

2.- ¿QUE ES CASE?

CASE es una filosofía que se orienta a la mejor comprensión de los modelos de una empresa, sus actividades y el desarrollo de los sistemas de información. Esta filosofía involucra además el uso de programas que permiten:

Construir modelos que describen una empresa.
Describir el medio en el que se realizan actividades.
Llevar a cabo una planificación.
Facilitar la creación de prototipos y el desarrollo conjunto de aplicaciones.
Aumentar la portabilidad de los programas.

Se puede decir que en general una herramienta CASE tiene por objetivo los siguiente:

Automatizar
- El desarrollo de software.
- La documentación.
- La generación del código.
- El chequeo de errores.
- La gestión del proyecto.
Permitir
- La reutilización del software.
- La portabilidad del software.
- La estandarización de la documentación.

3.- COMPONENTES DE UNA HERRAMIENTA CASE

De una forma esquemática podemos decir que una herramienta CASE se compone de los siguientes elementos:

Repositorio (diccionario), donde se almacenan los elementos definidos o creados por la herramienta, y cuya gestión se realiza mediante el apoyo de un Sistema de Gestión de Base de Datos (SGBD) o de un sistema de gestión de ficheros.
Meta modelo (no siempre visible), que constituye el marco para la definición de las técnicas y metodologías soportadas por la herramienta.
Carga o descarga de datos, son facilidades que permiten cargar el repertorio de la herramienta CASE con datos provenientes de otros sistemas, o bien generar a partir de la propia herramienta esquemas de base de datos, programas, etc. que pueden, a su vez, alimentar otros sistemas. Este elemento proporciona así un medio de comunicación con otras herramientas.
Comprobación de errores, facilidades que permiten llevar a cabo un análisis de la exactitud, integridad y consistencia de los esquemas generados por la herramienta.
Interfaz de usuario, que constará de editores de texto y herramientas de diseño gráfico que permitan, mediante la utilización de un sistema de ventanas, iconos y menús, con la ayuda del ratón, definir los diagramas, matrices, etc. que incluyen las distintas metodologías.

4.- CLASIFICACIÓN DE LAS HERRAMIENTAS CASE

Según su amplitud :

TOOLKIT: Es una colección de herramientas integradas que permiten automatizar un conjunto de tareas de algunas de las fases del ciclo de vida del sistema informático: Planificación estratégica, Análisis, Diseño, Generación de programas.

WORKBENCH: Son conjuntos integrados de herramientas que dan soporte a la automatización del proceso completo de desarrollo del sistema informático. Permiten cubrir el ciclo de vida completo. El producto final aportado por ellas es un sistema en código ejecutable y su documentación.

Según las fases del ciclo de vida:

UPPER CASE: Planificación estratégica, Requerimientos de Desarrollo Funcional de Planes Corporativos.

MIDDLE CASE: Análisis y Diseño.

LOWER CASE: Generación de código, test e implantación

5.- PRINCIPALES HERRAMIENTAS CASE

Clases de distribución de objetos (Layouts)

2008-11-15T03:53:00.001-08:00

Los layout managers ayudan a adaptar los diversos Componentes que se desean incorporar a un Panel, frame o Applet, es decir, especifican la apariencia que tendrán los Componentes a la hora de colocarlos sobre un Contenedor controlando el tamaño y posición del componente. Java dispone de varios controladores entre los cuales tenemos a los siguientes:

La clase FlowLayout : Los componentes añadidos a un JPanel con FlowLayout se acomodan uno a otro en forma de lista horizontalmente de izquierda a derecha (por defecto) o de derecha a izquierda de acuerdo a los parámetros que se pasen por el constructor.
La clase GridLayout : Es un administrador de distribución que distribuye a los objetos en forma de tablas (filas x columnas) . Aquí el contenedor es dividido en rectángulos de igual tamaño y coloca un objeto en cada rectángulo :
La clase BorderLayout : Un administrador border layout arregla y dimensiona sus componentes en 5 regiones : norte,sur,este,oeste y centro las cuales son identificadas por sus respectivas constantes : NORTH,SOUTH,EAST,WEST Y CENTER.
La clase Box Layout : Este administrador nos sirve para colocar a los objetos de forma alineada ya sea verticalmente o horizontalmente según lo que se le pase por parámetros :
La clase FreeLayout : Es la que esta configurada por defecto y consiste en que la colocación de los componentes en un contenedor sea a libertad del programador :

Ejemplo : Diseñe una aplicación utilizando en la que se utilice las diferentes clases layout :

Creamos un proyecto con el netbeans (ver como crear un proyecto en netbeans) : Clic en File → New Project , una vez creado se debe ver así :
Ahora vamos a agregar una paquete llamado Layout, para ello clic derecho en Source Package → New → Java Package y el damos el nombre de Layouts.
Agregamos al paquete que hemos creado un JFrame Form, para ello hacemos clic en el paquete creado : new → JFrame Form al que le llamaremos Principal :
Si todo esta bien obtendremos la siguiente imagen :
Ahora vamos a trabajar sobre el JFrame al cual le damos una distribución de border layout (esto para que el panel que colocaremos después abarque todo el JFrame pues BorderLayout coloca por defecto al primer elemento en el centro) :
Ahora arrastramos un Panel que se encuentra en la parte izquierda y también le damos una distribución de BorderLayout :
Con el panel en distribución layout , solo nos queda agregar mas paneles en cada dirección que nos ofrece el BorderLayout :
Para poder visualizar mejor cada panel vamos a modificar la opción de borde de cada panel , para lo cual seleccionamos el panel en el diseño o también podemos seleccionar los objetos en el inspector (el área que se encuentra en la parte inferior izquierda de la pantalla) y seleccionamos la propiedad border en la paleta de propiedades (situada en la parte inferior derecha) – esto lo hacemos por cada panel - :
Ahora vamos a darle un espacio entre cada panel para eso usaremos la opción de espaciado, para lo cual hacemos clic a la propiedad BorderLayout que hemos establecido antes y automáticamente en la paleta de propiedades aparecen las siguientes opciones para la cual le daremos un valor de 10 a cada espaciado :

Hecho esto automáticamente veremos los resultados en el diseñador :

Ahora a cada panel le vamos a dar un tipo de los layout que hemos visto y le vamos a agregar algunos botones :

OBSERVACIÓN : Muchas veces al colocar un administrador de objetos a un panel el panel desaparece de el diseñador de objetos , para lo cual podemos acceder a él desde la paleta del Inspector de objetos :

En el siguiente ejemplo vemos que el panel ha desaparecido de el diseñador :
Si deseamos agregar botones arrastrándolo al diseñador va a ser un poco complicado así que podemos usar la paleta del inspector de objetos para agregar los componentes que deseemos :

Ejemplos :

Ejemplo de la clase FlowLayout………………………………….
Ejemplo de la clase GridLayout…………………………………..
Ejemplo de la clase BorderLayout……………………………….
Ejemplo de la clase FreeLayout………………………………….
Ejemplo de la clase BoxLayout……………..…………………….
Ejemplo del tutorial ………………………………..……………….

Crear un JPanel degradado

2008-11-14T05:22:00.001-08:00

Muchas veces al crear un JPanel nuestro panel tiene el siguiente aspecto :

Ahora si bien nosotros podemos cambiar el color del JPanel con :

this.setBackground(Color.BLACK);

previamente de haber importado el : import java.awt.Color;

El resultado sería este :

Cosa que no esta nada mal; pero se puede lograr tener paneles de la siguiente forma:

Para esto solo basta con agregar unas líneas de código a nuestro JPanel ; que quedaría de la siguiente forma :

import java.awt.Color; 

import java.awt.GradientPaint; 

import java.awt.Graphics; 

import java.awt.Graphics2D; 

import java.awt.Rectangle;

/*

* @author: Salazar Reque Miguel 

*/ 



public class NuevoJPanel extends javax.swing.JPanel{ 

	private Color color1 = new Color(255,255,255); 

	private Color color2 = new Color(0,0,0);



	protected void paintComponent(Graphics g){ 

		Graphics2D g2 = (Graphics2D) g.create(); 

           Rectangle clip = g2.getClipBounds(); 

		float x=getWidth(); 

           float y=getHeight(); 

		g2.setPaint(new GradientPaint(0.0f, 0.0f,   color1.darker(), 

		getHeight(), color2.darker())); 

		g2.fillRect(clip.x, clip.y, clip.width, clip.height); 



	}

//Métodos set y get que nos permiten modificar los colores



	public Color getColor1() {return color1;} 

	public void setColor1(Color color1) {this.color1 = 	color1;} 

	public Color getColor2() {return color2;} 

	public void setColor2(Color color2){this.color2 = color2;}

}

Sección JAVA

2008-11-07T06:26:00.000-08:00

CAP 01 : INTRODUCCIÓN PROGRAMACIÓN ORIENTADA A OBJETOS

CAP 02 : SENTENCIAS DE CONTROL

CAP 03 : ARREGLOS UNIDIMENSIONALES Y MULTIDIMENSIONALES

CAP 04 : CLASES

CAP 05 : RELACIONES ENTRE CLASES

CAP 06 : LA CLASE BASE

CAP 07 : LA CLASE STRING

CAP 08 : POLIMORFISMO

CAP 09 : INTERFACES Y CLASES INTERNAS

CAP 10 : MANEJO DE EXCEPCIONES

CAP 11 : CLASES GENÉRICAS

CAP 12 : PERSISTENCIA

CAP 13 : CLASES AWT

CAP 14 : CLASES SWING

CAP 15 : ESTRUCTURAS DINÁMICAS

CAP 16 : MISCELANEA

CAP 17 : CONECTIVIDAD

CAP 18 : NETBEANS

Sección VARIOS

2008-11-07T03:17:00.000-08:00

I.- GIMP

Sección LINUX

2008-11-07T02:44:00.000-08:00

I.- ESCRITORIO

Visualizar los íconos en el escritorio de Ubuntu.

II.- OTROS

Sección OFFICE

2008-11-07T02:00:00.000-08:00

I.- MICROSOFT OFFICE WORD

Crear un índice en Word 2007.

2008-11-02T20:32:00.000-08:00

¡¡¡¡ ESTA SECCIÓN ESTA EN CONSTRUCCIÓN !!!!!

A medida que vaya escribiendo entradas se irán habilitando las secciones ; por ahora se esta en un proceso de reestructuración .. Gracias por la comprensión

BIENVENIDOS A JAVAX0711 !!!!!

2008-11-02T02:10:00.000-08:00

Hola a todos , el objetivo del este blog es proporcionar los conocimientos que he poco a poco he adquirido en este paso por la universidad.

A diferencia del titulo este blog no esta dedicado solo a lo que es la programación en Java ; la idea es tener un archivo que poco a poco irá creciendo, solo les pido paciencia porque no cuento con mucho tiempo ...pero la idea esta propuesta y si alguien desea que se colaborar con alguna entrada pues bienvenido sea.

Así les doy la bienvenida a JAVAX0711.A continuación les presento las secciones de las que cuenta el proyecto, las cuales serán desarrolladas conforme vaya adquiriendo mas conocimientos :

CLIC EN LAS IMAGENES PARA IR A CADA SECCIÓN

(POR IMPLEMETAR)

Bienvenidos!!!

2008-11-01T20:23:00.000-07:00