El dilema de “¿qué vino primero el huevo o la gallina?” ha atormentado las mentes de la humanidad a lo largo de la historia, jugando con su cabeza y haciéndolos cuestionar su existencia misma (WTF?).

“Esta expresión llena de ambigüedad condujo a filósofos antiguos cuestionar el cómo se originó la vida y el universo.” dice WikiPedia. Y después dicen que uno pierde el tiempo con los videojuegos…

Incluso relata de diversos personajes importantes, que no teniendo nada mejor que hacer, decidieron buscar respuesta a esta pregunta:

Aristóteles (384-322 AC) concluyó que ambos habían existido siempre. (¡Ja!)

Plutarco (46-126 DC) hizo una comparación del dilema con la creación del mundo. (Mmmh…)

Macrobio (395–423 AD), destacó la trascendencia de la cuestión. (Yo quiero un poco de lo que él estaba tomando)

Stephen Hawking y Christopher Langan, concluyeron que fue primero el huevo que la gallina. Langan presentó un detallado estudio del problema en 2001. (Así me gusta!)

package main;

 

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

 

public class Main {

 

	public static void main(String[] args) {

		System.out.println("¿Qué vino primero el huevo o la gallina?");

		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

		try {

			String respuesta = bf.readLine();

			if(respuesta.equals("Huevo") || respuesta.equals("huevo")){

				Huevo();

			}else if(respuesta.equals("Gallina") || respuesta.equals("gallina")){

				Gallina();

			}

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

 

	public static void Huevo(){

		System.out.print("el Huevo vino primero, pero lo dejó ");

		Gallina();

	}

	public static void Gallina(){

		System.out.print("la Gallina vino primero, pero salió de ");

		Huevo();

	}

}

Etiquetas: delirios, java, huevo, gallina, filosofando

Apple ha lanzado una actualización de Java para sus sistemas operativos Mac OS X 10.4 Tiger y 10.5 Leopard.

En la segunda actualización para Leopard se mejora la seguridad, el desempeño y la compatibilidad con Java SE 6, J2SE 5.0 y J2SE 1.4.2. Tiene un peso de 134.5 MB y requiere Mac OS X 10.5.4 o posterior.

Además lanzó el Java Release 7 para Mac OS X Tiger que de igual manejra mejora la confiabilidad,y compatibiidad para Java 2 y Java 1.4. Esta actualización -de 80 MB- eleva Java 2 Standard Edition a la versión 1.5.0-16 y Java 1.4 a la versión 1.4.2-18.

Enlace: Java para Leopard y Tiger

Comparte esta anotación

Etiquetas: actualizaciones, noticias, software, java

Me avisan desde la empresa Ohlala Mobile


del lanzamiento de mobiLauncher un servicio que tiene una pinta fantástica ya que permite que los creadores de aplicaciones web puedan crear versiones para teléfonos móviles Java y Blackberry (también sería posible hacerlo para el iPhone si no fuera por las restricciones que pone Apple para que las aplicaciones aparezcan en el App Store)

mobiLauncher permite la creación de las aplicaciones para instalar en el móvil, la creación de un acceso directo o icono para situar en la pantalla de nuestro móvil, la instalación de la aplicación mediante SMS directo, SMS Premium, códigos QR, opciones de promoción web mediante banners o widgets y estadísticas de descarga, número de visitantes y países de origen.

Así por ejemplo en la web de mobiLauncher podemos encontrar las versiones para móviles que han creado de sitios como Tuenti, Facebook y Youtube. Según se vayan creando aplicaciones, estas irán a parar el directorio que se convertirá en un interesante recopilatorio de aplicaciones para móviles. El servicio de creación de aplicaciones es gratuito, mostrando publicidad al inicio. El servicio premium sin publicidad tiene un precio de 169 euros al año.

Etiquetas: aplicaciones web, moviles, webdoscero, appstore, blackberry

Aqui les dejo un pack de juegos bluetooth para el movil , son buenisimos, espero que los disfruten

Juegos Incluidos En El Pack


·3D Constructo Combat.


·3D Epos.


·3D Marble Madness.


·4 x 4 Extreme Rally 2006.


·Arctic Wars.


·Avenging Angel.


·Bomberman Reloaded.


·BT Biplanes.


·Crash Arena 3D.


·Durak.


·Euro Football.


·fatal force.


·Favorite Checkers.


·Fishlabs Burning Tires N80 Os9.1 3D.


·Freddie Flintoff.


·Gem Blast.


·Ghost Story.


·Guess who.


·Islands Missile Invasion.


·Micro Counter Strike 3D v1.3.0.6 320×240 + keygen.


·Micro Counter Strike v1.1 bt 176×220 + keygen.


·MobiChess 240×320.


·Opposite Lock 3D.


·Pandora BRICKS.


·Panzer General.


·Petanca.


·Phantom Spider 3D.


·rally3d_en_fr_de_hu-HU_pl-PL_ro-RO.


·RALLY Pro Contest.


·Roland Garros 2007.


·Scorched_City_by_Racer_Team_v1.08_S60… 9.


·Soccer 3D.


·Super Bomberman.


·Super Stack Attack.


·Team Orlen Dakar 2007.


·Worms 2008 176×208.


·Worms 2008 240×320.


·Worms 2008 352×416.

Pack juegos bluetooth

Etiquetas: juegos moviles, fre movilgames, juegos bluetooth, juegos java, juegos movil

Etiquetas: marcas, acrobat, apple, aston martin, cadillac

En este post veremos como crear un sistema que extiende su funcionalidad por medio de plugins. Para ello haremos uso de la clase java.util.ServiceLoader incluida en Java 6.0

Basicamente para que nuestro sistema admita plugins debemos realizar una serie de pasos básicos:

1. Definir la forma en que los plugins serán agregados a nuestra aplicación



2. Crear una interface que los plugins deberán implementar



3. Crear una forma de encontrar y cargar los plugins en tiempo de ejecución



4. Crear los plugins



5. Probar que todo funcione según lo previsto

Veremos con un pequeño ejemplo para entender como llevar a cabo cada uno de estos pasos, donde los plugins de nuestra aplicación simplemente devolveran un mensaje (un String) que la aplicación principal mostrará por pantalla.

0- Creando el proyecto de ejemplo

Crearemos el proyecto principal de ejemplo de nuestra aplicación. Por ahora solo crearemos un proyecto con la calse que contiene el método main.

package ar.lefunes;



public class Main {

    public static void main(String[] args) {

    }

}

Proyecto Principal

1- Definir la forma en que los plugins serán agregados a nuestra aplicación

En este paso debemos dejar en claro como queremos que funcione nuestra aplicacion a la hora de cargar y utilizar los plugins. Aqui no programaremos nada, pero es importante identificar exactamente lo que queremos conseguir.

En el caso de nuestro ejemplo, lo que haremos es crear un directorio “plugins” en el directorio local de nuestra aplicación donde agregaremos los plugins (sus .jar), por lo tanto el sistema debe ser capaz de encontrarlos, cargarlos y utilizarlos desde esa ubicación.

2- Crear una interface que los plugins deberán implementar

Definimos una interface que todo plugins que quiera ser incorporado al sistema deberá implementar.

Crearemos un proyecto independiente del principal que contendrá unicamente la interface. Este será incluido tanto en los proyectos de cada plugin como asi también en el proyecto principal.

package ar.lefunes.plugins;



public interface IPluginMensaje {

    String getMensaje();

}

Proyecto de la Interface

Incluimos a este proyecto dentro del proyecto principal:

Incluyendo el proy. de la interface en el proy. principal

3- Crear una forma de encontrar y cargar los plugins en tiempo de ejecución

Para cargar los plugins utilizaremos java.util.ServiceLoader, la cual busca en el classpath todas las implementaciones declaradas de una interface determinada.

Por lo tanto, para que un plugin exponga una implementación de la interface (en nuestro ejemplo IPluginMensaje) se deben cumplir dos condiciones:

• El .jar del plugin debe estar incluido en el classpath para que ServiceLoader lo revise.



• El plugin debe indicarle a ServiceLoader que dentro de él existe una implementación de la interface y donde puede encontrarla.

Para cumplir la primera consideración deberemos buscar todos los .jars que se encuentre dentro del directorio “plugins”, incorporandolos luego al classpath mediante la clase ModificadorClassPath que vimos en un post anterior.

Para que se cumpla la segunda condición ServiceLoader tiene que encontrar un archivo dentro del plugin en la dirección “META-INF/services/” con el nombre calificado de la interface (ar.lefunes.plugins.IPluginMensaje). Dentro del archivo se lista (linea por linea) el nombre calificado de cada una de las clases dentro del plugin que implementan la interface. En el proximo punto veremos como crear este archivo.

Agregamos entonces la clase ar.lefunes.classpath.ModificadorClassPath a nuestro proyecto principal, y creaamos una clase nueva llamada CargadorPlugins:

Clase Cargadora de Plugins

Código comentado de la clase CargadorPlugins:

package ar.lefunes.plugins;



import ar.lefunes.classpath.ModificadorClassPath;

import java.io.File;

import java.io.FilenameFilter;

import java.net.MalformedURLException;

import java.util.Iterator;

import java.util.ServiceLoader;

import java.util.Vector;



public class CargadorPlugins {



    private static final String EXTENSION_JAR = ".jar";

    private static final String DIRECTORIO_PLUGINS = "plugins/";



    /**

     * carga los plugins encontrados al classpath

     * @return true si se cargaron los plugins,

     *         false en caso de existir algun error

     */

    public static boolean cargarPlugins() {

        boolean cargados = true;

        try {

            //obtiene el listado de archivos .jar dentro del directorio

            File[] jars = buscarPlugins();



            if (jars.length > 0) {

                ModificadorClassPath cp = new ModificadorClassPath();



                //a cada jar lo incluye al classpath

                for (File jar : jars) {

                    try {

                        cp.addArchivo(jar);

                    } catch (MalformedURLException ex) {

                        System.err.println("URL incorrecta: " +

                                ex.getMessage());

                    }

                }

            }

        } catch (Exception ex) {

            cargados = false;

            System.err.println(ex.getMessage());

        }

        return cargados;

    }



    /**

     * Busca todos los jars de en el directorio de plugins

     * @return jars del directorio de plugins

     */

    private static File[] buscarPlugins() {

        //crea lista vacia de archivos

        Vector< File > vUrls = new Vector< File >();



        //si existe el directorio "plugins" continua

        File directorioPlugins = new File(DIRECTORIO_PLUGINS);

        if (directorioPlugins.exists() && directorioPlugins.isDirectory()) {



            //obtiene todos los archivos con la extension .jar

            File[] jars = directorioPlugins.listFiles(new FilenameFilter() {



                @Override

                public boolean accept(File dir, String name) {

                    return name.endsWith(EXTENSION_JAR);

                }

            });



            //los agrega a la lista de archivos

            for (File jar : jars) {

                vUrls.add(jar);

            }

        }



        //retorna todos los archivos encontrados

        return vUrls.toArray(new File[0]);

    }



    /**

     * Obtiene todos los plugins IPluginMensaje encontrados en el classpath

     * @return lista de plugins encontrados e instanciados

     */

    public static IPluginMensaje[] getPlugins() {



        //cargamos todas las implementaciones de IPluginMensaje

        //encontradas en el classpath

        ServiceLoader< IPluginMensaje > sl =

                ServiceLoader.load(IPluginMensaje.class);

        sl.reload();



        //crea una lista vacia de plugins IPluginMensaje

        Vector< IPluginMensaje > vAv = new Vector< IPluginMensaje >();



        //cada plugin encontrado es agregado a la lista

        for (Iterator< IPluginMensaje  > it = sl.iterator(); it.hasNext();) {

            try {

                IPluginMensaje pl = it.next();

                vAv.add(pl);

            } catch (Exception ex) {

                System.err.println("Excepcion al obtener plugin: " +

                        ex.getMessage());

            }

        }



        //retorna los plugins encontrados y cargados

        return vAv.toArray(new IPluginMensaje[0]);

    }

}

En este punto ya podemos incorporar la funcionalidad al método main del proyecto:

package ar.lefunes;

package ar.lefunes;



import ar.lefunes.plugins.CargadorPlugins;

import ar.lefunes.plugins.IPluginMensaje;



public class Main {



    public static void main(String[] args) {

        System.out.println("-------------------------------");



        //se cargan los jars del directorio "plugins" al classpath

        boolean cargados = CargadorPlugins.cargarPlugins();



        if (cargados) {

            try {

                //obtiene una instancia de cada plugin IPluginMensaje encontrado

                IPluginMensaje[] avisadores = CargadorPlugins.getPlugins();



                if (avisadores.length > 0) {

                    for (IPluginMensaje a : avisadores) {

                        //por cada plugin muestra la clase y el mensaje que devuelve

                        System.out.println("Plugin: \t" + a.getClass().getCanonicalName());

                        System.out.println("Mensaje:\t" + a.getMensaje());

                        System.out.println();

                    }

                } else {

                    System.out.println("No se Encontraron Plugins");

                }

            } catch (Exception ex) {

                System.err.println("Excepcion: " + ex.getMessage());

                ex.printStackTrace();

            }

        } else {

            System.out.println("Plugins No Cargados");

        }



        System.out.println("-------------------------------");

    }

}

Si en este punto ejecutamos la aplicación obtendremos:

——————————-


No se Encontraron Plugins


——————————-

debido a que aún no hemos instalado ningun plugin en la misma.

4- Crear los plugins

Creamos un proyecto nuevo para nuestro primer plugin para la aplicación y agregamos la dependencia hacie el proyecto de la interface.

Proyecto del Primer Plugin

Creamos la clase PluginNumeroUno que va ha ser la implementacion de la interface:

package ar.lefunes.plugins.impl;



import ar.lefunes.plugins.IPluginMensaje;



public class PluginNumeroUno implements IPluginMensaje {

    public String getMensaje() {

        return "Este es el plugin numero uno !!!";

    }

}

De esta manera, a pesar a que funcionalmente hemos finalizado con el plugin, este no será cargado en la aplicación debido a que le falta el descriptor para la clase ServiceLoader. Para ello creamos un archivo con el nombre de la interface dentro del directorio “META-INF.services”

Agregando Descriptor de Servicio

Donde adentro del mismo colocaremos una sola linea indicando el nombre calificado de la clase que implementa la interface:

Definición del Descriptor de Servicio

5- Probar que todo funcione según lo previsto

Para probar compilamos los tres proyectos y armamos la siguiente estructura de archivos:

Estructura del Archivos del Ejemplo

Al ejecutar, el programa mostrará por la consola:

——————————-


Plugin:         ar.lefunes.plugins.impl.PluginNumeroUno


Mensaje:        Este es el plugin numero uno !!!

——————————-

con lo que podemos observar que cargo correctamente el plugin.

Más de un plugin por JAR

El paso de creación es similar al explicado para un solo plugin: Agregamos la dependencia al proyecto de la interface y creamos las clases que la  implementan:

Proyecto con Dos Plugins

La diferencia radica solamente que dentro del descriptor para ServiceLoader indicaremos las clases, una por linea:

Descriptor de los Dos Plugins

Con lo que obtendremos al incorporar el Jar a la carpeta “plugins” del proyecto principal y ejecutando este último:

——————————-


Plugin:         ar.lefunes.plugins.impl.PluginNumeroUno


Mensaje:        Este es el plugin numero uno !!!

Plugin:         ar.lefunes.plugins.multiple.PluginDos


Mensaje:        Plugin Nº 2

Plugin:         ar.lefunes.plugins.multiple.PluginTres


Mensaje:        Plugin Nº 3

——————————-

Plugin por defecto

Devido a que el propio proyecto principal se encuentra dentro del classpath (y por esto ServiceLoader lo revisará) podemos brindar un plugin que se cargará aún cuando no exista ningun jar en el directorio “plugins”.

Para ello creamos la clase que implementa el servicio y la indicamos con un descriptor dentro del proyecto:

Agregando Plugin por Defecto

Descriptor del Plugin por Defecto

Donde obtendremos en la salida al ejecutar sin ningún plugin en el directorio “plugins”:

——————————-


Plugin:         ar.lefunes.plugins.defecto.PluginDefecto


Mensaje:        PLUGIN POR DEFECTO

——————————-

Recursos

Se puede descargar el proyecto de ejemplo (aprox. 71kB) de: http://lefunes.googlecode.com/files/app_plugins.zip. En él se incluyen tanto los jars para ejecutar el ejemplo directamente como los proyectos en NetBeans 6.5 creados para este post.

Espero les sirva.


Hasta la proxima.

Más Info

• Javadoc ServiceLoader



• Using the ServiceLoader API to build a modular applications



• Java SE 6 ServiceLoader



• Modificando el classpath dinamicamente en tiempo de ejecución

Etiquetas: java, plugins, serviceloader

Están abiertas las inscripciones para la conferencia: JBoss Seam in action que publiqué hace unos días. Se trata de una completa conferencia de este framework de desarrollo empresarial: con introducción a Java EE, frameworks de uso general, y JBoss Seam particularmente.

Inscripciones solamente por la siguiente página web:


http://www.juguy.org/index.php?option=com_attend_events&task=view&id=3&Itemid=94

Fecha: 2 de octubre


Lugar: ORT Auditorio Centro, Montevideo, Uruguay.


Hora : de 18:30 a 21:30 hs.

Etiquetas: eventos, java ee, jboss, seam

Etiquetas: programacion, ccna, certificacion sun, cisco, java

Habemos algunos que, por falta de tiempo, y no por falta de gusto, no podemos vivir en esos mundos virtuales de los que hablaba Vicente la semana pasada y hay otros a los que simplemente les da flojera jugar juegos tan “complicados” y lo que quieren es matar el tiempo un rato de una forma entretenida antes de que dé la hora de irse o se termine la clase.

Para toda esa gente muchas veces el Solitario o el Buscaminas deja de ser interesante a la segunda sentada, por eso presento estos cinco sitios a los que se pueden dirigir para jugar juegos sin necesidad de bajarlos y desde la comodidad de su navegador:

1. Shockwave

Play Games - Free Online Games, Free Downloadable Games at Shockwave via kwout

Mi favorito: Rumble Town Racing

2. Yahoo! Games

Yahoo! Games via kwout

Mi favorito: El dominó

3. MSN Games

MSN Games - Free Online Games via kwout

Mi favorito: No puedo decirlo, pensar que tengo que abrir el Explorer para jugar me da coraje.

4. MiniClip

Games at Miniclip.com - Play Free Games via kwout

Mi favorito: Cualquiera de los de la categoría de “5 Minutes”. Literalmente para hecharse un rapidín.

5. King

Play Free Online games of skill at King.com via kwout

Mi favorito: Cake Mania

Si sabes de otros sitios que valgan la pena para perder el tiempo jugar un rato en línea o si tienes un juego favorito, déjanos saberlo en los comentarios.

Comparte esta anotación

Etiquetas: guias, trucos, flash, java, juegos

NetBeans está programado en Java, lo que lo hace un poco pesado. En la comunidad de NetBeans tienen un espacio dedicado a trucos y ajustes para sacar más provecho a los recursos: NetBeans Performance

Etiquetas: software

Habrán notado que desde hace unos días (¿semanas ya?) se ha reducido un poco la periodicidad de publicaciones en Picando Código. La razón principal es mi nuevo trabajo. ¡Estoy nuevamente trabajando como programador! Es una empresa en Maldonado, donde se está formando un equipo de programadores para proyectos multi disciplinarios (qué buena frase…).

Se avecina mucha responsabilidad, estudio, retos y desafíos. Estos últimos dos, los pilares de la motivación para un programador


La imagen del post no significa nada en particular


No tiene nada que ver con el hecho de estar programando en un lenguaje que me gusta


Ni usando un IDE super poderoso


Ni usando un sistema operativo GNU/Linux


Ni que estoy muy contento con mi nuevo trabajo

Mal acostumbrado con la gestión de mi tiempo, lo que más sufrió fue el blog. La falta de costumbre me llevó a verme un poco apretado los primeros días, ya que tuve que re acomodar el reloj de mi sistema al horario de oficina, dejar algo de tiempo para preparar las clases de redes, etc.

Ya después de unos días de adaptación, retomo el ritmo. Sigo preparando las clases de redes por otro lado, con un poco menos de tiempo. Pero muy contento y motivado con el nuevo trabajo. Tengo unos cuantos posts de esos con muchas vitaminas y minerales, ideales para empezar el día con todas las energías. Pero hasta que los termine quedan en “borradores”.

No me hago responsable por posts altamente influenciados por la tecnología Java de ahora en más… Culpen a otros…

Etiquetas: trabajo, java, programador

Las distintas compañías de celulares buscan desesperadamente desarrolladores independientes o empresas que se dediquen a esta actividad para desarrollar aplicaciones para sus nuevos teléfonos móviles. Ya que desean atraer clientes con aplicaciones novedosas.

La compañía taiwanesa LG habilitó un sitio en internet, LG Mobile Developer Network, donde pone a disposición información, SDKs, documentación, etc, acerca de sus móviles para incentivar a nuevas creaciones para sus teléfonos.

Por el momento buscan aplicaciones desarroladas en Java y en Flash Lite, con SDKs. Sin dudas sería todo un éxito ser elegido para desarrolar para esta compañía, quienes se dediquen a esta rama de la informática estarán muy interesados con la noticia.

Fuente: Xatakamovil

También te puede interesar

• Para simplificar la navegación llegó MobiLauncher

Etiquetas: aplicaciones, desarrollo, flash lite, java

Me he levantado, he ido al kiosco, he visto esto... Y me he vuelto a casa. Llorando. Jesús Lens enclaustrado.

PD.- Pinchen en las portadas y lean los sumarios de las revistas. ¿No es para coger el pasaporte, una mochila y salir zumbando?

Etiquetas: congo, patagonia, java, altaïr, geo, lonely planet, revistas, kiosco, viajar

Etiquetas: viajes

El anuncio fue realizado en la lista de correo de anuncios desarrollo ubuntu-devel-announce por Matthias Klose. OpenJDK es la versión de código abierto de Java (proyecto creado por Sun a partir de la liberación de las fuentes de Java en mayo del año pasado) compatible con su versión 6. Esa decisión se aplica tanto a las arquitectura x86 como a la x86_64.

Via: Phoronix

Compártelo

Etiquetas: anuncios, programas, ubuntu, anuncio, java

En este post mostraremos como conectar SQLite con java, usando para esto Netbeans; el resultado final es un JTextArea que mostrara el contenido de la base de datos creada en SQLite. El resultado es el siguiente:

Antes que nada vamos a la pagina de SQLiteJDBC y nos descargamos Driver para SQLite pero la version realizada en java (Pure Java), como podran notar hay versiones para Windows, Linux y MacOS las cuales se basan en la libreria JNI, a grandes rasgos esta libreria utiliza llamadas al sistema anfitrion; por tanto si quieres que tu aplicacion se ejecute en cualquier sistema operativo sin ningun problema entonces la version realizada en java (pure java) es la mejor opcion.

Una vez que descargamos el archivo (sqlitejdbc-v048-nested.tgz) lo descomprimimos, esto nos generara dos archivos un JAR y un README de toda la vida, el archivo que nos interesa obviamente es el JAR, pero de momento no lo muevas, solo recuerda en donde se encuentra.

Lo siguiente que haremos es crear la base de datos que mostrara nuestra aplicaciion, para ello usaremos una extencion de firefox llamada SQLite Manager, utilizamos esta misma extencion en un tutorial anterior (SQLite con C# para el Framework 2.0 de .NET), asi que el procedimiento es el mismo:

Vamos a crear un DB simple, con la tipica estructura de la lista del salon de clases:

• id_alumno
• nombre
• ap_paterno
• ap_materno

En nuestro SQLite Manager le damos en New Database y le damos por nombre alumnos (automaticamente SQLite Manager le agrega la extencion .sqlite), nos pregunta en donde queremos guardarla, de momento la guardamos en nuestro Escritorio. Una vez creada la DB, le damos al boton Create Table y en la ventana le damos un nombre a nuestra tabla (lista en nuestro caso), ademas de que definimos las columnas.

Una vez hecho esto ya debes de tener tu base de datos (alumnos.sqlite) creada con una tabla(lista). Vamos a agregarle tres valores para que estos sean los que se muestren en nuestro JTextArea, para eso vamos a la pestaña Browse > Search y le damos al boton Add New Record; recuerda agregar 3 registros (en mi caso, si quieres agrega mas).

Cerramos el SQLite Manager y hasta este momento contamos con una base de datos en SQLite y la libreria (Driver) que nos permitira conectarnos a ella. Es momento entonces de abrir nuestro Netbeans, en mi caso es la version 6.1

Creamos un nuevo proyecto (File > New Project...) y seleccionamos una Java Aplication

Le ponemos un nombre "interesante" y revisamos que la opcion "Create Main Class" no este seleccionada. Por ultimo le damos finalizar

Con esto tendremos creado nuestro proyecto, el siguiente paso es agregar la libreria para SQLite, en nuestr caso es un .JAR, para esto en la carpeta Libraries que aparece en la seccion Projects damos un click-derecho y seleccionamos la opcion Add JAR/Folder nos aparecera una ventana que nos permitira seleccionar el archivo .JAR que previamente habiamos descargado.

Una vez hecho lo anterior en nuestra carpeta Libraries aparecera nuestro archivo .JAR

Lo siguiente es crear la interfaz grafica de nuestr aplicacion, para ello damos click-derecho sobre el arbol de nuestro proyecto y seleccionamos ( New > JFrame Form...)

En la siguiente ventana le damos un nombre "interesante" y en el campo "Package" le ponemos "my.nombreinteresante" (obviamente es el nombre que le hayas puesto)

Esto nos creara el Frame que contendra nuestra aplicacion, ahora rapidamente en el menu "Palette" que nos acaba de aparecer, seleccionamos un elemento "Panel" lo arrastramos sobre nuestro JFrame y lo acomodamos para que ocupe todo el espacio, posteriormente seleccionamos un elemento TextArea el cual mostrara los datos de nuestra base de datos y lo arrastramos dentro del elemento "Panel", finalmente debe de quedarte algo asi:

Ahora pasaremos a lo interesante, pasaremos al codigo, para ellos le damos click al boton que dice Source y pasaremos al codigo de la aplicacion.

Como puedes ver hay codigo que Netbeans crea automaticamente, este codigo es el necesario para mostrar la aplicacion que hasta este momento hemos venido creando, esa porcion de codigo como te repito la crea Netbeans y de momento no nos meteremos con ella. Pero si es necesario agregar codigo para que nuestra hermosa aplicacion se conecte con la base de datos, por tanto pasemos a eso. Importamos los paquetes necesarios para nuestra aplicación:

Una vez hecho esto buscamos el comienzo de nuestro probrama, o mejor dicho en donde comienza la clase que define a nuestro programa, una vez encontrada definimos variables que hagan referencia al controlador de base de datos y a la base de datos que usaremos. Ademas de variables para la conexion y para las instrucciones SQL.

Ahora pasemos al "contructor" de nuestra aplicacion, en donde pondremos toda la funcionalidad, como se puede apreciar comienza con una llamada a la funcion initComponents(); la cual se encarga de crear y acomodar los elementos de nuestra interfaz grafica, la funcionalidad la agregaremos despues de esta llamada. El codigo es el siguiente:

Con esto, nuestra aplicación esta concluida, ahora solo nos queda agregar la base de datos creada a la carpeta del proyecto, debe de quedarte algo asi:

Finalmente presionamos F6 y veemos como corre radiante. Oviamente este ejemplo puede mejorarse y mucho, seria deseable que en lugar de usar un JTextArea se usara una JTable, pero esto sera en otro post. Recuerden dudas, comentarios, errores, sugerencias, etc. en los comentarios

Link: SQLiteJDBC | Pure Java

Etiquetas: java, programacion, sqlite, base datos

Desde el boletín de noticias del JUGUY:

Fecha: 2 de octubre


Lugar: ORT Auditorio Centro - Montevideo, Uruguay.


Hora: de 18:30 a 21:30 hs.


Acceso libre, sin inscripción previa

Datos de la charla


JBoss Seam está siendo promocionado como el framework de referencia en torno a los desarrollos Java EE de alta productividad.


Particularmente este framework integra distintas tecnologías de JBoss que simplifican la integración, diseño e implementación de distintos proyectos empresariales.


Esta charla pretende introducir el framework JBoss Seam, analizando la arquitectura y ventajas de su propuesta.


Se terminará la presentación con el análsis completo de un ejemplo que plantee una solución de referencia

Temario:

• Introducción a Java EE



• Introducción a frameworks de uso general en Java EE



• Introducción a JBoss Seam



• Caso práctico con Seam
  
  
  
  
  
  • Requerimientos
  
  
  
  • Arquitectura general
  
  
  
  • Gráficas con JBoss Seam
  
  
  
  • Reportes
  
  
  
  
  
  



• Conclusiones

Expositores:

Ing. Martín Cabrera


Ingeniero en Computación, Universidad de la República, Uruguay


Sun Certified Web Components Developer for Java EE 5.0


Sun Certified Java Programmer for Java SE 1.4


Miembro fundador del Grupo de Usuarios Java del Uruguay


Director y CEO en Moove-IT SRL


Se desempeña además, como consultor y docente en Java EE

Lic. Ariel Ludueña





Licenciado en Sistemas, Universidad Católica, Uruguay


Miembro del Grupo de Usuarios Java del Uruguay


Director y Gerente de investigación y desarrollo en Moove-IT SRL


Se desempeña además, como consultor y docente en Java EE

Etiquetas: eventos, java, jboss

Etiquetas: blogger, blog, utilidades, lenguajes, java

Los usuarios de Mac OS X 10.4 Tiger y 10.5 Leopard, ya pueden descargar las actualizaciones lanzadas por Apple en donde se mejora el funcionamiento de Java. Para los usuarios de Mac OS X 10.5.4 o posterior existe una actualización de 134,5 MB con la que se mejora la seguridad, compatibilidad y desempeño de Java SE 6, J2SE 5.0, y J2SE 1.4.2.

Para los usuarios de Mac OS X 10.4 Tiger, ha sido lanzada una actualización de 80 MB, en la que se incluye Java Release 7 para Mac OS X 10.4 Tiger, que mejora de igual manera la confiabilidad y compatibilidad para Java 2 y Java 1.4. Como siempre, se recomienda instalar las actualizaciones, ya que solucionan muchos problemas de seguridad y compatibilidad.

Enlace: Leopard / Tiger | Vía: AppleWeblog

Comparte esta anotación

Etiquetas: actualizacion, apple, java

TwitArcs es otra herramienta que utiliza el servicio Twitter para incorporar una nueva posibilidad y mejorar la experiencia de su uso. TwitArcs pretende, de manera muy gráfica, visualizar las relaciones entre los tweets (entradas intercambiadas entre el usuario y los seguidores) de un usuario.

Para emplear el servicio basta con introducir un identificador de Twitter precedido del símbolo @. En esta herramienta no es necesario introducir la clave de la cuenta de usuario. TwitArcs analiza los últimos 100 tweets del usuario y los muestra ordenados cronológicamente, en forma de listado, sobre un fondo negro. A la izquierda del listado, mediante arcos de color rojo, se unen los mensajes mandados por un mismo usuario. A la derecha, empleando arcos de color azul, se selecciona un término relevante y se enlaza en los mensajes donde se repita.

Al pasar el ratón por encima de cualquiera de los términos relevantes, los arcos que vinculan al mismo término (en azul), aparecerán de color distinto resaltando el término y qué usuarios lo han utilizado en sus mensajes. Si pasas el ratón por encima del listado, el mensaje aparecerá sobreimpreso en la pantalla para que sea completamente legible.

Para poder disfrutar de TwitArcs es necesario tener instalada la consola de Java.

Enlace: TwitArcs

Comparte esta anotación

Etiquetas: java, microblogging, twitter

Sin duda me va a venir muy bien este nuevo software que he encontrado mientras visitaba UbuntuLife, JMeld.

Para poder comparar dos ficheros y ver sus diferencias puedes utilizar Meld, programa de idéntico uso a JMeld aunque este último es multiplataforma (usa java), asi que si quieres ejecutarlo necesitas tener el JRE (Java Runtime) instalado en tu maquina y lo inicias con:

$ java -jar JMeld-2.0.jar

Etiquetas: software, archivos duplicados, comparativas, gnu, linux