El Blog De Baro

[Baro Tarea] Como hacer una calculadora básica en Java con diálogos (JOptionPane)

2019-09-25T12:08:00.000-07:00

Hola y buen día a todos mis lectores, después de años de no escribir aquí les traigo algo para ayudarles en sus tareas escolares ¿No pusiste atención a tu profe cuando explicó cómo hacer una calculadora con Java? ¿Te dejó de tarea hacer una calculadora y no sabes ni usar la que está en tu mochila? ¡Entonces estás en el lugar indicado! Abajo te dejo el código con dos métodos diferentes:

Calculadora sencilla con JOptionPane (3 Diálogos)

Una calculadora hecha lo más sencilla posible, con unas 50 líneas de código, si has manejado if, String, Float y JOptionPane, entenderás a la perfección el código, y si no, más abajo explíco el código a detalle.

¿Sencillo, verdad?

Algunas cosas que debes saber: El método calcularValores acepta dos parámetros Float y por lo tanto la lógica dicta que debería devolver un resultado del mismo tipo, pero como ya sabrás, no es complicado que acepte y devuelva Integer, Double o Long simplemente reemplazando Float por la clase de tu preferencia. Si ya probaste el código, también habrás notado, que al llamar a JOptionPane la ejecución del programa se detiene hasta que el diálogo haya cumplido su trabajo (Ésa es la razón por la que no ves todos los diálogos apilados), ya sea que presionaste Aceptar, presionaste a la tecla Enter o cerraste el diálogo presionando la X. Ahora que ya sabes todo lo importante y el profe te pregunte sobre el código ya tendrás algo que decir.

Calculadora compleja con JOptionPane (1 Diálogo)

¿Quieres dejar en vergüenza a todos tus amigos? Mientras ellos quizá muestren 3 horribles e ineficientes diálogos, tú te sentirás como Hackerman con tu código de un solo diálogo ¿La desventaja? Puede que tu profe no crea que tú lo hayas hecho, te lo dejo a tu criterio. A continuación el código.

Algunas cosas que debes saber: El código en ambos ejemplos obviamente necesitan algo de optimización, pero es algo que dejaré a cada quién y además deja espacio para adaptarlo a sus necesidades. Como ya viste, por razones de no confundir a nadie no cambié nada en el método calcularValores, todo el código para hacer la operación en un solo diálogo se encuentra en mostrarCalculadora1Dialogo lo que hace operacion.indexOf("+") es indicarnos con un entero en qué posición de la cadena operacion se encuentra el String que pasamos como parámetro '+' y en caso de devolver -1 nos indica que no encontró el String que le pasamos, ahora si te parece puedes leer nuevamente el código y seguramente entenderás todo, y si no, siempre podemos experimentar a poner lo que devuelve indexOf en la consola con System.out.println.

Hasta aquí llega mi entrada, espero de verdad que le sirva a muchos estudiantes perdidos o que no quieren hacer su tarea de programación, si gustan pueden comentar abajo qué otras tareas sería bueno publicar para ayudarlos o cuales recuerdan que les costó trabajo realizar, la mejor idea gana medio kilo de tortillas, hasta la próxima shabos.

BaroTip - Como crear dialogo que se cierra con tiempo

2014-09-16T19:13:00.000-07:00

Hola y buen día a todos mis lectores, un buen tiempo ha pasado desde mi última entrada, pero aquí les traigo un pequeño código que me pidió un lector hace ya mucho tiempo, pero que nunca salió de mi cabeza (Ésta noche podré dormir en paz) la verdad es algo de lo más sencillo, pero me daba flojera hacerlo :P jaja, aquí les va:

Lo que haremos será utilizar la clase JDialog y Timer, como ya se habrán imaginado, JDialog representa al dialogo que mostraremos y Timer será nuestro contador, por falta de un equipo de cómputo decente donde estoy ahora mismo, no puedo probar que el código funcione correctamente, así que tendrán que hacerlo por mí, soy un mal educado, nunca aprendí a compilar y ejecutar código Java desde la línea de comandos :P puro IDE, así que aquí les va el código:

Sencillo, ¿no? Siéntanse libres de expresar aquí sus dudas, comentar mejoras o fallas, repito, no tengo un IDE donde probarlo por hoy, los detalles los arreglo conforme los encuentre, espero que haya sido de ayuda, un placer escribir para ustedes, saludos :D.

Entradas Relacionadas:

Como leer la captura del usuario con un dialogo en Java (JOptionPane)

2014-07-04T19:20:00.000-07:00

Hola y buen día a todos mis lectores, largo tiempo de no escribir por aquí por cuestiones de trabajo, sé que me extrañaban, jaja, así que les traigo éste nuevo tema, y le dedico ésta entrada a Jeanette que espero que no se esté durmiendo, jaja :P, comencemos.

Ejemplo de dialogo de captura.

Ya vimos en una entrada anterior cómo mostrar mensajes al usuario con distintos cuadros de dialogo, así que ahora viene la contra parte, pedirle datos al usuario, lo que es realmente importante en cualquier programa del mundo real, ya que cualquier software requiere siempre de la entrada del usuario, a continuación unos ejemplos utilizando la siempre útil clase JOptionPane (Clic para ver documentación).

Ejemplo #1: Obtener y mostrar cualquier texto ingresado por el usuario.

Y el resultado de nuestro código es:

Dialogo de captura #1: Donde capturas cualquier texto.

Dialogo de mensaje #1: Donde se muestra lo que capturaste.

Ejemplo #2: Obtener y mostrar cualquier texto ingresado por el usuario.

¿Qué diferencia encuentras aquí? Hice un ligero cambio en el código, usando un método JOptionPane.showInputDialog diferente, que permite agregar, además del título de captura, una sugerencia de la misma, haciendo la vida del usuario un poco más sencilla como se aprecia en las imágenes ;).

Dialogo de captura #1: Donde capturas cualquier texto con una sugerencia al mostrarse el dialogo.

Dialogo de captura #2: Donde se ve modificada la sugerencia del dialogo.

Dialogo de mensaje #1: Donde se muestra lo que capturaste.

Algunas cosas que debes saber sobre JOptionPane
Cuando llamamos a un dialogo por medio de cualquiera de los métodos de JOptionPane, como lo son showMessageDialog o showInputDialog debemos tener en cuenta que se 'bloqueará' la ejecución de nuestro programa hasta que el dialogo se cierre, ¿te preguntabas por qué aparecían un dialogo tras otro en orden y no todos a la vez? Ahí tienes la respuesta. Otra cosa muy importante, es que si en el dialogo de captura se presiona el botón "Cancel", en el código de nuestro ejemplo (y en cualquiera) nos devolverá null en la variable donde almacenamos la entrada, compruébalo tú mismo ;). Y ahora, podemos aprovechar las características de JOptionPane para pedir datos en orden al usuario, hagamos algo un poquito más complejo (y útil) con los diálogos.

Ejemplo #3: Sumar 2 números por medio de diálogos.

Salida del programa:

Dialogo de captura #1: Donde capturas el primer número para la suma.

Dialogo de captura #2: Donde capturas el segundo número para la suma.

Dialogo de mensaje #1: Donde se muestra el resultado de la suma.

Dialogo de mensaje #2: Lo que verás si capturas un texto.

¡Funciona! Cuando se usa como debe ser, claro, pero si lo miras y pruebas con atención, el código tiene muchas cosas que se pueden mejorar, ¿qué cambios le harías tú? Como siempre, siéntete libre de mejorar y experimentar con el código a tu gusto, ya que es la mejor forma de aprender y a mí me da flojera escribir tanto código :P.

Espero hayan disfrutado leyendo mi primer entrada del año tanto como lo hice yo al escribirla, como siempre saben que cualquier duda, critica, comentario o sugerencia es bien aceptada en la parte donde pone "Comentarios", no olviden dar 'like' a la página de Facebook para que estén al tanto del blog, ya le daré más atención, se los prometo, saludos ;).

Entradas relacionadas:

Cómo utilizar el dialogo de pregunta en Java (JOptionPane)

2013-10-08T11:14:00.001-07:00

Hola y buen día a todos mis lectores, hoy me han dado ganas de escribir sobre un tema sencillo para algunos aquí, pero que igualmente puede resultar útil para muchos otros, los diálogos de pregunta, ésos pequeños diálogos que normalmente utilizamos para confirmar una acción del usuario, un ejemplo: En Windows, cuando estamos en la palera de reciclaje, al vaciarla siempre nos pregunta: “¿Estás seguro de eliminar estos elementos de forma permanente?” (Algo así) El caso es que ése es un dialogo de pregunta, a continuación veremos cómo utilizarlos en Java, pero antes, una imagen de lo que haremos:

Ahora que tenemos un buen concepto de lo que es un dialogo de pregunta, veremos cómo hacer uno propio siguiendo el código de ejemplo a continuación, que sepan que no es la única (Y tal vez ni la mejor) forma de utilizar el dialogo, si tienen mejores formas de uso son muy bien recibidas en los comentarios, las publicaré en esta entrada para mejorarla (Obviamente dando el crédito a quién sugiera ésa forma de uso), pero por ahora, lo importante es que vean una de las muchas formas de utilizar el dialogo esperando que les sea de ayuda. Ahora sí, ahí les va el código:

Como podemos ver, el código es realmente corto, se alarga al doble por que lo lleno de comentarios :P. Tal vez a algunos les parezcan demasiados comentarios, pero mejor que sobren a que falten ya que a veces son importantes para aclarar ciertas dudas.

Si corremos el código de arriba, veremos que al dar clic al botón "Aceptar" nos mostrará un dialogo como el siguiente:

Eso muestra muy bien la manera en que trabaja un dialogo de pregunta y cómo podemos utilizarlo.

Como ahora me parece que ésta entrada es muy corta, les ofrezco otro ejemplo muy bueno de uso, cambiando unas cuántas líneas del código anterior podemos tener un dialogo muy distinto y para otro propósito, aquí les va:

Y el resultado es el siguiente:

¿Qué les parece? Unos cuántos cambios al código y tenemos algo muy distinto, y si lo notaron, no hay ni necesidad de darle código al botón "Cancelar" si le damos clic a ése botón ahora nos daremos cuenta que el dialogo se cierra por default, todo por la magia de JOptionPane. Como siempre, los invito a investigar y experimentar por su cuenta, les recomiendo hacer una copia del código original para no perderlo y así experimentar con la otra copia con toda seguridad de que si se equivocan, pueden volver al código anterior.

Como siempre mis queridos lectores, es un placer escribir para ustedes, si les gusta lo que hago suscríbanse en la parte de arriba, pueden unirse a la página de Facebook, o recibir las noticias del blog en su E-mail escribiéndolo dónde pone "Noticias del Blog a tu E-Mail". Cualquier duda, aclaración, sugerencia o critica constructiva es bienvenida en los comentarios, saludos.

Entradas relacionadas:

Cómo utilizar JInternalFrame

2013-08-15T14:38:00.000-07:00

Hola y buen día a todos mis lectores. Después de mucho tiempo sin publicar nada por aquí, he tenido la mejor de las motivaciones para hacerlo, dedico ésta entrada a la fan #1 del blog, jaja :P, mi chica linda: Mery, quien ha estado conmigo desde hace años y espero que eso siga así por mucho tiempo más, es la persona más especial que he tenido la suerte de conocer, como le digo siempre, es una en un millón :) y quería que todos lo supieran, ¡La adoro!. Ahora sí, jaja, el tema de hoy: Cómo utilizar JInternalFrame, comencemos...

Les dejo a continuación una imagen de 2 JInternalFrames con distintos componentes en ellos:

El contenido de “Ventana Interna #1” no lo veremos en el ejemplo que daré aquí, es una creación propia y solo la puse para ilustrar la ventana interna con algo más complejo, además de que sería mucho código.

¿Qué es un JInternalFrame y para qué nos puede servir?
Un JInternalFrame, es una ventana interna, algo diferente de un JFrame ya que va dentro de un panel especial que por lo general es un JDesktopPane y no puede salir de él. A un JInternalFrame podemos darle cualquier uso, los mismos que a cualquier JFrame, podría ser útil por ejemplo, si estamos desarrollando algún tipo de procesador de texto, para abrir varios documentos a la vez o formularios, etc. Veremos a continuación sus constructores y un ejemplo de uso.

Constructores de JInternalFrame:

JInternalFrame()
Crea un JInternalFrame no-reizable, no-closable, no-maximizable, no-iconifiable y sin título.

JInternalFrame(String titulo)
Crea un JInternalFrame no-reizable, no-closable, no-maximizable, no-iconifiable y con el título especificado.

JInternalFrame(String titulo, boolean resizable)
Crea un JInternalFrame no-closable, no-maximizable, no-iconifiable con el título y ‘resizability’ especificado.

JInternalFrame(String titulo, boolean resizable, boolean closable)
Crea un JInternalFrame no-maximizable, no-iconifiable con el título, ‘resizability’ y ‘closability’ especificado.

JInternalFrame(String titulo, boolean resizable, boolean closable, boolean maximizable)
Crea un JInternalFrame no-iconifiable con el título, ‘resizability’, ‘closability’ y ‘maximizability’ especificado.

JInternalFrame(String titulo, boolean resizable, boolean closable, boolean maximizable, boolean iconifiable)
Crea un JInternalFrame con el título, ‘resizability’, ‘closability’, ‘maximizability’ y ‘iconifiability’ especificado.

Nota: Dejo los argumentos en inglés porque cuando buscas el método no vas a buscar por ‘setCerrable’ o algo así.

Ejemplo de uso

A continuación veremos un ejemplo sencillo de uso del JInternalFrame, simplemente mostraremos un par de ventanas internas y les agregaremos algunos componentes para ver qué tal se ven.

Para el ejemplo yo utilicé 2 clases dentro de un mismo fichero, esto con la idea de no complicarnos tanto, aquí les va:

Y ahora veremos al correr el código dos ventanas internas, pero podemos crear tantas como queramos, aquí algunas imágenes del resultado:

Al correr el código veremos las ventanas así.

Cambio de tamaño de la ventana #2.

Minimizamos la ventana #2.

Maximizamos la ventana #1 (Nótese que ha dejado de verse la #2).

Minimizamos ambas ventanas.

Si quieren aprender más sobre cómo utilizar JInternalFrame, les dejo aquí la documentación oficial.

Bien, esto ha sido todo por hoy, espero les haya sido útil, ya saben, dudas, comentarios, críticas constructivas o lo que quieran en los comentarios, un gusto escribir para ustedes. Mery, si lograste llegar hasta el final del artículo sin dormirte, te mando un beso :* jaja y si no también :).

Entradas Relacionadas:

Cómo mostrar un dialogo de mensaje en Java

Cómo crear una GUI en Java

Cómo crear una GUI en Java - Parte 2

Cómo usar Look And Feel en Java

Cómo mostrar un dialogo de mensaje en Java (JOptionPane)

2013-04-23T11:28:00.001-07:00

Hola y buen día a todos mis lectores, hoy veremos de nuevo un tema para principiantes en lenguaje Java, y el tema (como dice ahí arriba) es “Cómo mostrar un dialogo de mensaje en Java” para logra tal cosa usaremos la clase JOptionPane. Aquí abajo hay una imagen que muestra lo que haremos más adelante, comencemos…

Dentro de la programación, la comunicación con el usuario es una de las cosas más importantes (y a mi parecer la más importante, ya que es el fin de cualquier programa), anteriormente ya habíamos hablado de eso en otro de mis artículos, pero hoy nos centraremos específicamente en cómo mostrar diferentes tipos de mensajes, ya sea un simple aviso, un mensaje de error, de advertencia, pregunta, etc.

Mostrando un mensaje simple en la pantalla
Si lo que queremos es mostrar un mensaje de una línea fácil y rápido, aquí les va la solución:

Y lo que tenemos es:

Sencillo, ¿verdad? Como vieron, esto va dentro de algún método ya sea el main o cualquier otro, un constructor, lo que sea. Ahora, veamos algo un poco mejor, ¿y qué es mejor que un mensaje de una línea? Pues un mensaje de 2 líneas :D (o las que queramos).

Para mostrar un dialogo de varias líneas, necesitamos un salto de línea, para esto, llamaremos a una propiedad del sistema, esto será tal como dar \n en C++ y en Java es también válido, pero esta no es la forma más extensible de hacerlo ¿Por qué? Pues recordemos que Java es multiplataforma, puede que no en todos los sistemas operativos tomen esto como un salto de línea, en algunos es algo como \n\r o dependiendo, así que para no complicarnos, lo haremos de la siguiente manera:

Mostrando un mensaje de varias líneas:

Y el resultado es:

Ahora, esos son mensajes sencillos, muy útiles claro, pero JOptionPane (la clase que estamos usando) tiene aún muchos trucos bajo la manga, podemos hacer muchos tipos de diálogos de manera sencilla, como por ejemplo:

Dialogo de confirmación (Hace una pregunta de confirmación como Sí, No, Cancelar).
Dialogo de entrada (Solicita alguna entrada al usuario).
Dialogo de mensaje (Le comunica al usuario algo que ha pasado).
Dialogo de opción (Es la unificación de los otros tres).

Éstos diálogos pueden mostrarse también en un JInternalFrame, con su respectivo método showInternalXXX() pero ése no es el tema de hoy, lo veremos luego.

Ahora, hemos utilizado ya el dialogo de mensaje más simple con el método showMessageDialog(Component comp, Object msj) de JOptionPane mostramos mensajes de una y varias líneas, pero, si quieren hacer algo un poco más complejo con estos diálogos aquí les van los otros 2 métodos de JOptionPane para mostrar diálogos de mensaje:

showMessageDialog(Component comp, Object mensaje, String titulo, int tipoMensaje)
showMessageDialog(Component comp, Object mensaje, String titulo, int tipoMensaje, Icon icon)

El primer método, pide el “componente padre” (Component), en caso de que llamemos al dialogo desde un JFrame o un JPanel, podemos ponerlo como argumento, luego nos pide el mensaje (Object), ya hemos visto como se utiliza para mostrar una línea o varias, después pide el título (String) donde ponemos el título del dialogo a nuestro gusto (por si alguno todavía no se daban cuenta para qué era :P) luego el tipo de mensaje (int), esto es lo interesante, aquí podemos poner una de las constantes que ofrece JOptionPane para cambiar el icono que aparece a la izquierda del dialogo, las constantes son: PLAIN_MESSAGE, INFORMATION_MESSAGE, QUESTION_MESSAGE, ERROR_MESSAGE y WARNING_MESSAGE, a continuación la imagen del icono que vamos a cambiar:

Y ahora un ejemplo de uso en la clase con la que hemos estado trabajando:

Al correr este código veremos 5 mensajes de dialogo (se muestra el siguiente dando click al botón “Aceptar”) con diferente icono, como se muestra en la siguiente imagen (Sin el bonito fondo verde ni el texto obviamente :P)

El segundo método que enlistamos pide lo mismo que el primero pero además podemos poner un ícono a nuestro gusto en el último argumento (Icon), en lugar de uno de los que ya vienen por parte de JOptionPane.

Me gustaría extenderme más en el uso de JOptionPane para ver los demás diálogos, como el de pregunta (muy útil) o los de entrada, pero me saldría un poco del tema de los mensajes así que si quieren saber más sobre estos diálogos les dejo la documentación de JOptionPane aquí para que experimenten por su cuenta, o esperen mi siguiente entrada, encantado de escribir para ustedes ;), saludos.

Entradas Relacionadas:
Cómo crear una GUI en Java
Cómo crear una GUI en Java - Parte 2
Aprender Java Creando un juego

Cómo crear una clase Java en Eclipse IDE

2013-03-12T21:49:00.000-07:00

Hola y buen día a todos mis lectores, hoy, volvemos al génesis de la programación en Java, que son las clases, para muchos de ustedes, crear una clase en Java con Eclipse IDE, es algo de lo más simple, pero hoy me voy a centrar en los principiantes, todos lo hemos sido alguna vez :P, así que aquí vamos…

Como siempre, primero veremos algunas definiciones, para tener todo bien claro sobre las clases en Java antes de crear una, veremos también algunos ejemplos, ahí van:

¿Qué es una clase en Java?

Aquí les traigo una buena definición:

Desde un punto de vista simplista, una clase es un conjunto de valores (atributos) junto con las funciones y procedimientos que operan sobre los mismos (métodos), todo ello tratado como una entidad. Estas clases constituyen los bloques principales en los cuales se encuentra contenido el código.
En un fichero fuente puede declararse una o más clases:
class Clase1 {…}class Clase2 {…}…class ClaseN {…}
El cuerpo de las clases comienza con una llave abierta ({) y termina con una llave cerrada (}).
Declaración de clase {
Cuerpo de clase
}
La declaración de una clase define un tipo de dato referencial.
Dentro del cuerpo de la clase se declaran los atributos de la clase y los métodos.

Bueno, creo que con eso tenemos una idea bastante clara de lo que es una clase en Java, ahora, veremos cómo crear una en Eclipse IDE. Pero antes hay algo que casi olvidaba, hay que tener antes nuestro respectivo proyecto y paquete donde pondremos nuestra clase dentro, eso es algo sencillo, lo explicaré también a continuación, ahí vamos:

Para crear un proyecto abrimos Eclipse IDE, y nos vamos a File -> New -> Java Proyect Tal como se muestra a continuación:

Ahora veremos una ventana que nos pide el nombre de proyecto como se muestra en la imagen de abajo, simplemente le damos un nombre a nuestro gusto y luego click en Finish:

Así de fácil, tenemos un proyecto, ahora lo que sigue es crear un paquete/paquetes que contenga las clases que hagamos, podemos hacer tantos como queramos y por lo general, el nombre del mismo se relaciona con lo que hacen las clases dentro de él, he aquí algunos ejemplos: “compras”, “ventas”, “ventas.interfaz”, “compras.interfaz”, “compras.interfaz.acciones”, etc.

Para crear un paquete dentro de nuestro proyecto simplemente damos click al nombre de nuestro proyecto y posteriormente click al ícono del paquete (encerrado en rojo) como se muestra en la siguiente imagen:

Veremos una ventana que nos pide el nombre del paquete, de nuevo, podemos darle el nombre que queramos, siempre y cuando tomemos en cuenta ciertos criterios, como no iniciar el nombre con mayúscula, no iniciarlo con puntuaciones, etc. De todas formas la ventana donde creamos el paquete nos avisa si hicimos algo mal, al finalizar damos click en el botón Finish aquí se les muestro la ventana:

Y listo, veremos que en nuestro proyecto aparece un ícono de paquete blanco, indicando con ese color que está vacío, pero se cambia a café al crear una clase dentro de él, que es justo lo que veremos a continuación (ahora sí).

Primero que nada, para crear una clase, tenemos que darle una ubicación, eso es, un paquete, entonces, seleccionamos el paquete creado y entonces damos click en el ícono verde con la C blanca de clase como se encierra en rojo en la imagen a continuación:

Lo que veremos a continuación es la ventana para la creación de clase, aquí, podemos dar un nombre a nuestra clase (recordando iniciar el nombre con mayúscula, no usar espacios, etc) y darle modificadores, súper clase, interfaces, métodos como el constructor, el famoso main(), nos da también una opción para heredar los métodos abstractos y por último, generar comentarios, pero todo queda a nuestro criterio/necesidades, marcaré la casilla de main() y le daré los modificadores public y final para mostrarles como queda, pero primero vean la ventana de creación de clase:

Y ahora, les va el código fuente que genera esta ventana con los métodos y modificadores que elegí:

Y listo, acabamos de crear una clase en la cual somos libres de poner todos nuestros métodos, atributos, etc.

Eso es todo por esta entrada, espero haya sido de su agrado, cualquier duda, petición, crítica constructiva, felicitación o agradecimiento por pasar horas creando la entrada, investigando, editando las imágenes y cuidando cada detalle para ustedes (¡malditos, nunca lo hacen!) :P jaja, lo pueden poner en la parte de abajo, no olviden suscribirse y dar Like a la página de Facebook :D ¡Saludos!

Como usar Look And Feel en Java

2013-01-26T20:43:00.000-08:00

Hola y buen día a todos mis lectores, después de un laaargo tiempo de ausencia, he vuelto y aunque esté “Con el agua al cuello” de trabajo, tengo ganas de escribir acerca de cómo trabajar con Look And Feel en Java, así que comienzo:

Primero que nada, hay que saber lo que es Look and Feel (Aspecto y Comportamiento) en Java, a falta de una buena definición en Internet, lo explicaré solo a mi manera: El Look and Feel, se refiere a una forma en concreto de cómo se ven y comportan los componentes SWING en Java (Cualquier JComponent), ya sean botones (JButton), tablas (JTable), combos (JComboBox, dejaré dar los otros nombres a tu cerebro :P), checkbox, labels, botones de radio, etc. Los Look And Feel (L&F en adelante para abreviar) disponibles pueden depender de qué sistema operativo tengas. Esta es una forma muy rápida y fácil para darle un aspecto completamente nuevo a tu GUI sin tener que cambiar el código (excepto claro, la parte donde se selecciona y aplica un L&F). Ahora, las preguntas más frecuentes serán tratadas a continuación (si hay más favor de comentarlas):

¿Cómo saber de cuales L&F dispongo?
¿Cómo y dónde aplicar un L&F a mi programa SWING?
¿Es posible dar a elegir un L&F al usuario final?

Bueno, son todas las que se me ocurren ahí van las respuestas:

¿Cómo saber de cuales L&F dispongo?

Ahí va el código que muestra un dialogo con una lista de L&Fs disponibles:

Salida (Puede variar por cada equipo):

Importante: Esto solamente muestra los nombres en un dialogo, no aplica ningún L&F a nuestra interfaz.

¿Cómo y dónde aplicar un L&F a mi programa SWING? - ¿Es posible dar a elegir un L&F al usuario final?

Responderé las 2 preguntas aquí mismo: En teoría puede aplicarse en cualquier parte con el código adecuado, aquí les va una muestra más o menos decente de cómo hago yo para aplicarlo, y luego dar a elegir cualquier otro L&F disponible al usuario (pondré varios componentes para que noten la diferencia entre un L&F y otro):
Un poco largo, pero hace lo que debe de manera correcta, aquí les va una imagen con cada cambio que hago en el L&F:

¿Grandes diferencias no? Y todo posible cambiando solamente el Look and Feel, las diferencias se notan aún más si abrimos por ejemplo, el JFileChooser, hagan la prueba ;).

Para más información pueden visitar: http://docs.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html

Eso es todo por hoy queridos lectores, espero hayan disfrutado este artículo porque probablemente me cueste mis empleos… :P no, mentira. Ya saben, cualquier duda, sugerencia, petición, crítica constructiva, favor de ponerla en los comentarios, no olviden suscribirse ya sea por RSS, Atom o por correo electrónico y si gustan, marcar alguna casilla de la sección “Mi opinión” para saber qué tal lo hago, hasta luego :D.

Artículos relacionados:

Cómo crear una GUI en Java

Cómo crear una GUI en Java - Parte 2

Como crear una GUI en Java - Parte 2

2012-12-07T12:58:00.000-08:00

Hola y buen día a todos mis lectores, como les prometí en la entrada pasada, hoy seguiremos tratando con el tema de la creación de GUI’s en Java, aquí les va…

En la entrada anterior, vimos varios ejemplos de cómo se pueden crear GUI’s (Graphical User Interface), en el último ejemplo, encontramos (a mi parecer) la mejor forma de hacerlo, aquí está el código:

Una muy buena forma de hacerlo, pero tiene algunas desventajas (yo puse 2, si encuentran más desventajas favor de señalarlas) que vamos a tratar más adelante, son las siguientes:

Hay que escribir algo más de código, lo que resulta tedioso.
Si no ponemos los métodos en el orden correcto dentro de iniciarGUI(), nos puede generar excepciones.

¿Y cómo resolver estos problemas?, bueno, es muy simple, todo empieza con la creación de lo que en Java se llama interface (interfaz en español). Pero antes que nada, ¿qué es una interfaz en Java?, ahí les va la definición:

Una interfaz en Java es una colección de métodos abstractos y propiedades. En ellas se especifica qué se debe hacer pero no su implementación. Serán las clases que implementen estas interfaces las que describan la lógica del comportamiento de los métodos.
La principal diferencia entre interface y abstract es que un interface proporciona un mecanismo de encapsulación de los protocolos de los métodos sin forzar al usuario a utilizar la herencia.

Gracias Wikipedia por la definición, ahora, vamos a ver el código de nuestra interfaz para facilitar la creación de GUI’s, en mí caso se llama GUIBásica:

Sencillo, ¿no?, bueno, esto puede ayudar con eso de no tener que escribir el código (los métodos), ya que si al momento de crear nuestra clase agregamos esta interfaz a la lista de las que vamos a implementar, ¡Se escribirán solos! :D. Lo único que debes escribir ahora, es el método iniciarGUI(), no olvides poner los métodos en el orden correcto.

Ahora, si quieres facilitarte la vida aún más, sigue leyendo y veremos otras formas de facilitar la creación de GUI’s…

Pasando de la interfaz a la superclase
Tener nuestros métodos para la creación de GUI’s en una interfaz es bastante bueno, facilita las cosas, yo utilicé esta forma de crear GUI’s mucho tiempo, pero luego me di cuenta de algo, ¡Puede mejorar! ¿Y cómo? Con una superclase, ahora, no solo tendremos los métodos ya escritos, si no que tendremos también un JPanel, JFrame o JDialog (Que son los principales contenedores) listo para trabajar, ahí les va mi código:

La clase PanelBásico:

La clase VentanaBásica:
La clase DialogoBásico:
Pueden parecer clases bastante sencillas, pero entre más simple mejor, la idea es que queden lo más general posible, ahora, van unos ejemplos de uso (relacionados) seguimos con el ejemplo de la ventana con la etiqueta, el campo de texto y el botón:

Ejemplo #1:

Ejemplo #2:
Y la salida es:

Dos clases para crear una simple ventana, algo laborioso, pero, para quienes hemos batallado por algún tiempo tratando de encontrar una buena forma de crear GUI’s complejas, creo que esta es una gran opción, siéntanse libres de modificar estos ejemplos a su gusto y conveniencia.

Bueno, es todo por hoy, espero que hayan disfrutado leyendo el artículo tanto como yo disfruté al escribirlo, no olviden suscribirse al blog, dejar sus comentarios y su opinión en la sección “Mi opinión” (Justo abajo) nos vemos en la siguiente entrada :D.

Entradas Relacionadas:
Como crear una GUI en Java

Como crear una GUI en Java

2012-11-29T15:32:00.001-08:00

Buen día a todos mis lectores, después de casi un mes de ausencia he vuelto para ayudarles en uno de mis temas favoritos en cuánto a Java: La creación de GUI´s, aquí les va…

Primero que nada, hay que definir qué significa GUI: Se refiere a la abreviación para Graphical User Interface (Interfaz Gráfica de Usuario), lo que se traduce en ventanas, botones, campos de texto, etiquetas descriptivas, etc. La creación de GUI´s en Java, como en cualquier otro lenguaje de programación es algo fundamental en el diseño de cualquier aplicación, ya que es la parte con la que el usuario final interactúa, y por lógica, este tema ha evolucionado con el tiempo, porque, ¿quién ve ahora una interfaz de línea de comandos?

En estos tiempos, ¿Con qué programa crees que quiera trabajar el usuario común?, ¿El de línea de comandos, o el que tiene la bonita GUI? Obviamente la mayoría elegiría la GUI ya que es mucho más comprensible y fácil de usar.

Ahora, hay varias formas de diseñar una GUI, a veces depende de la complejidad que tenga la GUI la forma en que lo hacemos, aquí les van 3 ejemplos para una misma situación: Digamos que quiero una ventana, que tenga una etiqueta, un campo de texto y un botón, aquí va el primer ejemplo:

Algo desordenado, ¿no creen?, quizá para algunos no lo sea, pero pregúntense lo siguiente: ¿Qué pasará cuando tengan que desarrollar una interfaz mucho más compleja? No se trata solo de diseñar la ventana y agregar los componentes, se trata de añadirles oyentes de teclado, de mouse, que realicen acciones en base a eso, posiblemente cambiando fuentes, poniendo tooltips, soporte para tecnologías asistivas, etc.

Aquí va el siguiente ejemplo:

Un poco mejor, ¿no?, aunque algunos dirán, “¿Porqué es mejor si solo generamos más código?” La respuesta es que, ahora, tenemos control sobre la ventana y los componentes fuera del constructor, como se ve en el nuevo método que agregamos en este ejemplo, si hubiéramos intentado escribir un método así en el primer ejemplo, nos habría marcado error, hagan la prueba ;).

Ahora, estas formas de diseñar GUI’s es 100% válida, muchas veces como programadores decimos: “Ahhh, es una aplicación que jamás volveré a usar, por lo tanto no vale la pena esforzarme tanto en el estilo del código” Pero aquí les va algo de mi propia experiencia: Muchas veces, en otros proyectos digamos, de pronto acabamos necesitando extender ese pequeño e insignificante programa a fin de que sea parte de un proyecto de software mucho mayor, ¿y qué pasa? ¡El código es un desastre!, por lo tanto, a mi parecer, queda una solución: Que siempre que diseñemos GUI’s lo hagamos de una misma manera sin importar lo grande o chico que sea lo que pensamos hacer. Les mostraré un ejemplo de cómo lo hago yo, es algo simple y son libres de proponer uno mejor o cambiar un poco mi forma de hacerlo en sus propios códigos:

Es un código algo más extenso que el primero pero trae varios beneficios, van algunos a continuación:
• El código está mucho más organizado.
• Si necesitamos cambiar algo al código es mucho más fácil ya que siempre sabremos dónde está todo.
• Evitamos errores como por ejemplo, agregar un componente a otro antes de instanciarlo.

Un pequeño problema con esta forma de diseñar GUI’s, es que siempre tendremos que escribir los mismos métodos, lo que resulta algo cansado y puede que olvidemos algún método o el orden en el que están, lo que podría generar errores, ¿Puedes pensar en una forma de resolver esto? Si no es así, de todas formas daremos atención a este problema en la siguiente entrada que ya estoy cansado de escribir :P, veremos también esta forma de diseñar GUI’s más a detalle, como el porqué organizar los método de esa forma. Es todo por hoy, no olviden comentar, dar su opinión en las casillas de abajo, suscribirse y todo eso, saludos.

Entradas Relacionadas:
Como crear una GUI en Java - Parte 2

Introducción a Java NIO - Parte 2 (Final)

2012-10-31T15:55:00.000-07:00

Hola y buen día a todos mis lectores :D, hoy, en lugar de “jugar” a la política o a diseñar sistemas, me decidí por terminar este tutorial sobre el API NIO (o NIO.2), aquí les va…

Flujos de carpetas (Directory streams). Los FileVisitors son bastante
personalizables, pero cuando todo lo que necesitas mirar es cierto archivo en una sola
carpeta, una solución más simple existe en la forma de los flujos de carpetas. En una
palabra, un flujo es simplemente un objeto iterable que corre sobre un conjunto de
rutas que concuerdan con cierto filtro. Es además una interface AutoCloseable para
usar en sentencias try-with-resources, porque los flujos de carpetas necesitan ser
cerrados.

A continuación se muestra cómo podemos ver todas las entradas en la raíz del JAR anterior.

Y a continuación se muestra cómo podemos pasar un filtro glob a una lista sólo los archivos de clase Java.

Búsquedas más elaboradas pueden ser implementadas pasando un objeto DirectoryStream.Filter como un flujo predicado. Por ejemplo, podemos reusar el objeto glob matcher que usamos antes para listar todas las clases Java, como se muestra a continuación:

Como en el caso de los visitantes de archivos, la predicción (predicate) no necesita estar basada en buscar un PathMatcher. Podrías, por ejemplo, mirar el tamaño de archivo o los atributos de archivo para formar consultas como “cualquier archivo ejecutable sobre 1024kilo-octetos de tamaño.”

Copiando un árbol de archivo completo en un archivo zip. Podemos fácilmente combinar un árbol de archivo andante, las operaciones de clase Files, y un sistema de archivo ad hoc para copiar todo el árbol de archivo de carpeta actual en un archivo zip codificado UTF-8, como se muestra a continuación:

Si en lugar de copiar archivos en un archivo zip, tuviéramos un sistema de archivos FTP para copiar archivos a un servidor remoto FTP, el código de arriba no debería cambiar mucho, excepto por la creación del sistema de archivo. El método Files.createDirectories() cubre la creación de todos los directorios que necesiten existir con el fin de llevar a que la carpeta sea creada.

Manipulando metadatos

Una de las características más interesantes del API NIO.2 es la habilidad de manipular
metadatos a nivel del sistema de archivos. Anteriormente, información como el dueño del
archivo, grupo y permisos de acceso no estaban disponibles en el estándar Java runtime
sin recurrir a ejecución de procesos externos o integración de código nativo, ambos de los
cuales agregan so propio conjunto de problemas. Mientras tal información ha dejado de estar
escondida, el código necesita adaptarse a las capacidades del entorno de ejecución,
porque los sistemas operativos y los sistemas de archivos varían grandemente.

El paquete java.nio.file.attribute provee soporte para accesar a tales metadatos, en su
mayoría usando una jerarquía de file attribute views. Cada vista representa un conjunto de
metadatos que pueden ser manipulados dependiendo de lo que provee el sistema de archivos
subyacente.

La interfaz BasicFileAttributeView define los atributos que son comunes para los
sistemas de archivos existentes, como el tamaño del archivo, fecha de última
modificación, y fecha de creación. Instancias de DosFileAttributeView define atributos de
los sistemas de archivos tipo DOS, como si un archivo está oculto, un archivo de sistema o
un archivo. En el mismo espíritu, PosixFileAttributeView define atributos para los
sistemas POSIX, mientras AclFileAttributeView permite accesar a las listas de control de
accesos (ACLs) en los sistemas de archivo que los soportan.

El Javadoc para el paquete java.nio.file.attribute a fondo describe estas vistas. Vamos
a ver algunos patrones de uso común.

Atributos de archivo. Los atributos de archivos más comunes son accesibles
directamente desde los métodos de clase Files: size(), isDirectory(), isRegularFile(),
isSymbolicLink(), isHidden(), getLastModifiedTime() y más.

Para accesar o modificar un solo atributo, puedes usar los métodos getAttribute() y
setAttribute(). Ellos toman un solo String que representa el atributo, prefijado con un
identificador de la vista de atributo de archivo. Cada interface de la vista de atributo de
archivo define tales Strings y el return type del atributo en el Javadoc correspondiente.

Podemos consultar los permisos POSIX para un archivo como se muestra a continuación:

Lo que resultaría en una salida similar a la siguiente:

Además, podemos accesar a atributos específicos usando el método readAttributes() en cualquier subclase de BasicFileAttributes, como se muestra a continuación:

Vale la pena que Files.readAttributes(Path, BasicFileAttributes, LinkOption[]) realice operaciones masivas de lectura. Esta capacidad es útil al rendimiento cuando múltiples atributos son leídos simultáneamente.

Los permisos de archivo POSIX pueden ser directamente accesados como se muestra a continuación:

Casos más generales pueden ser manejados primero accesando a una vista de atributo de archivo. Por ejemplo, para obtener el dueño de archivo POSIX de un archivo, puedes usar el código a continuación:

Los permisos de archivo POSIX son comúnmente expresados en la forma de una String como rwxr-xr-x, lo cual significa que el usuario puede leer, escribir y ejecutar, mientras que los miembros del grupo y otros pueden solo leer y ejecutar. Podemos mostrar tales permisos y cambiarlos, como se muestra a continuación:

Lo que produce una salida similar a ésta:

Old permissions: rw-r--r--

New permissions: rwxr-xr-x

La clase FileStore. Cada ruta tiene un objeto file store asociado que esencialmente
representa donde es guardado el correspondiente archivo: volumen, partición y demás. La
clase FileStore es útil para consultar si el archivo almacenado soporta una dada vista
de atributo de archivo. Es además útil para accesar a las estadísticas de uso de disco.

El código a continuación nos permite realizar unas cuantas consultas que producen
salida similar a lo siguiente en Mac OS X:

Código:

Salida:

/dev/disk0s2

hfs

169030116 / 244277768

true

false

Atentos a los cambios

Algunas aplicaciones necesitan estar atentas a los cambios del sistema de archivos.
Por ejemplo, un servidor de aplicación quizá esté atento a que los ficheros de aplicación sean
dejados en cierta carpeta y entonces automáticamente desplegarlos. Similarmente, los
entornos de desarrollo integrado (IDEs) pueden buscar archivos de proyecto para que
sean agregados, eliminados y modificados por aplicaciones de terceros. Otro ejemplo
incluye algunos patrones de integración de aplicaciones donde las aplicaciones intercambian
datos a través de depósitos de archivo.

Estar atento a los cambios en el sistema de archivo puede ser implementado fácilmente
mirando periódicamente a las entradas de una carpeta y determinando qué archivos han
sido agregados, eliminados o cambiados basados en su fecha de última modificación. De
todas formas, mecanismos más eficientes existen a nivel de sistema operativo, como inotify
para Linux.

NIO.2 Provee una API útil que toma ventaja de las facilidades del sistema operativo, cuando
están disponibles claro, y cae de nuevo a votación periódica de otra manera. WatchService provee
un servicio que puede ser notificado sobre cambios en un dado objeto Path. Puedes
especificar qué tipos de eventos deberían ser mirados, saber las adiciones, modificaciones,
eliminaciones o desbordamiento (falla del sistema de notificaciones o reporte de todos los
eventos). Por ejemplo, el fragmento de código a continuación busca por cambios en /tmp e
imprime todos los eventos:

Un WatchService es obtenido del sistema de archivo de la ruta a ser monitorizada. De
nuevo, este es un objeto AutoCloseable, y es una buena idea usarlo con una
sentencia try-with-resources para asegurar que eventualmente se cerrará. El servicio
de vigilancia es entonces registrado a una ruta, y los eventos se vuelven disponibles desde
una cola.

Un WatchKey es usado en conjunto con registro y es devuelto al momento de registo. Un
WatchKey es además obtenido cuando buscamos eventos usando ya sea el método de
servicio de vigilancia poll() o take(). En el ejemplo de código anterior (el de arriba),
optamos por usar take() porque podemos permitirnos esperar a que un nuevo evento
esté disponible. Una llave de vigilancia (watch key) mantiene el estado, así que podemos
consultar para determinar dónde es aún válido y para obtener los últimos eventos de
vigilancia.

Una vez que una llave ha sido usada, necesita ser reseteada si se va a usar de nuevo. El
método reset() devuelve un valor Boolean que será false si la llave ya no es válida, por
ejemplo, cuando una carpeta vigilada desaparece. Puedes además llamar al método cancel()
para cancelar el registro del servicio de vigilancia.

Finalmente, la llave tiene información sobre el evento. Por ejemplo, podría sostener
información del tipo de evento (más probable desde StandardWatchEventKinds) y un
objeto de contexto que es una instancia de Path, el cual corresponde al tipo de eventos
que el servicio está buscando (ENTRY_CREATE, ENTRY_MODIFY y ENTRY_DELETE).

Conclusión

Este artículo introdujo la nueva API del sistema de archivo liberado en Java SE 7 como parte
del paquete llamado NIO.2. Estos paquetes hacen fácil tratar con operaciones de archivo ya
sean comunes o avanzadas, como lo es un eficiente monitor de cambios en una carpeta o
mover archivos a un archivo comprimido en zip mientras se preservan los metadatos.
Y último pero no menos importante, se integran bien con las clases existentes java.io
y java.nio, y pueden ser extendidas para tratar uniformemente con nuevos tipos de
proveedores de sistemas de archivos. Para más ejemplos vea el código de muestra NIO.2
en la distribución del JDK7 (bajo simple/nio/file).

Y bien, este es el final del tutorial sobre Java NIO (ahora sí voy a disfrutar de mi frappé :P),
espero les haya sido de utilidad, no olviden suscribirse (e-mail, RSS, Atom), comentar, hacer
peticiones, plantear sus dudas o críticas constructivas en la parte de abajo, ahhh y votar también,
saludos :D.

Entradas Relacionadas:

Introducción a Java NIO

2012-10-24T13:45:00.000-07:00

Hola y buen día a todos mis lectores, hoy, les tengo un artículo (o más bien un tutorial) de 2 partes muy interesante de la revista Java, como ya habrán leído en el título, se trata del nuevo sistema de archivos :D NIO.2, espero les guste, aquí les va...

Java SE 7 provee nuevas adiciones a los paquetes NIO—las llamadas NIO.2 APIs de JSR 203—muchas de las cuales se concentran en las APIs del sistema de archivos y canales asincrónicos.

En el pasado, la mayoría de las operaciones del sistema de archivos en Java eran realizadas usando las clases del paquete java.io que proveen una abstracción de características dependientes del sistema.

Estas clases eran débiles, por ejemplo, en tratar con permisos de archivo y manejando links simbólicos. Muchas librerías eran desarrolladas para superar estas debilidades, pero tienen el gasto adicional de contar ya sea con librerías nativas o invocaciones a procesos externos. Otras librerías eran además desarrolladas para tratar mejor con operaciones comunes del sistema de archivos (como copiar, mover y exploración) o para proveer sistemas de archivos virtuales (como archivos comprimidos, FTP y HTTP).

En este artículo, vamos a concentrarnos en las adiciones de NIO relacionadas al sistema de archivos: operaciones, manipulación de metadatos, y cambiar el monitoreo. Como veremos, las APIs NIO.2 proveen elegantes adiciones al set de herramientas de Java.

Primeros pasos

Las adiciones a NIO.2 están contenidas en su mayoría en los paquetes java.nio.file. Vamos a empezar con Path (ruta en español), una interface clave de las nuevas APIs.

Paths y archivos. La interface Path es una abstracción de un archivo o directorio dentro de un dado sistema de archivo. Instancias de Path pueden ser obtenidas usando la clase Path, que comprende dos métodos get(): uno que toma una URI y uno que toma un número variable de elementos Path. Un ejemplo sería obtener una referencia Path al archivo /etc/hosts, como se muestra a continuación:
Una referencia Path ofrece métodos para comparar rutas, resolver rutas contra otras rutas, y demás. La clase Files es comúnmente usada para realizar operaciones comunes en las rutas, incluyendo lo siguiente:

Crear archivos, carpetas, y links simbólicos
Copiar, mover y borrar
Consultando atributos
Iterar sobre un árbol del sistema de archivos
Obtener flujos de lectura y escritura y canales
Realizar operaciones de escritura y lectura directamente.

Listar cada método en Path y Files sería aburrido, así que en su lugar vamos a mirar algunos
ejemplos.

Operaciones simples. Vamos a crear un directorio temporal y copiar un archivo en él.

A continuación (en el código de abajo) copiamos el archivo asm a un archivo asm-copy.jar bajo una carpeta temporal como /var/folders/cj/h0x5ghcd1tz5s7shyj8txxf00000gn/T/nio2134767717145250358. Respectivos parámetros CopyOptions o no pueden ser provistos más probablemente de la enumeración StandardCopyOption:
En el código de arriba pedimos preservar los atributos del sistema de archivos, como el dueño del archivo, grupo y permisos. Otras opciones incluyen la habilidad realizar un movimiento atómico y reemplazar los archivos existentes. Hay además una enumeración LinkOption para prevenir la operación de copia de los siguientes links simbólicos.
Hablando de links simbólicos, si un link simbólico al archivo de librería original Java (JAR) ASM no existe, podemos crear uno y consultar el tamaño del JAR, como se muestra a continuación:
Lecturas y escrituras rápidas. Leer y escribir contenidos de archivo tradicionalmente ha requerido mucho código. La clase Files provee métodos ayudantes rápidos para lectura y escritura de los contenidos de un archivo como operaciones de “un tiro”. Ellas operan ya sea en Strings o en arreglos de bytes “crudos”.

A continuación se muestra cómo podemos leer los contenidos de un archivo:

Integración con flujos existentes y APIs NIO. Las APIs NIO.2 no están destinadas a vivir en una isla desierta, así que proveen medios para integración con existentes flujos y APIs NIO.

Los flujos (Streams) estilo I/O java.io y los búfers pueden ser obtenidos usando la clase Files
y sus métodos newInputStream(), newOutputStream(), newBufferedReader() y
newBufferedWriter().

Los canales NIO pueden ser obtenidos usando el método newByteChannel().

Curiosamente, hay una versión del método copy() que puede ser usada cuando el “blanco” es una instancia de java.io.OutputStream. Un ejemplo de uso sería arrojar el contenido de un archivo al flujo de salida estándar:

Tratando con los sistemas de archivos

Como el nombre lo sugiere, la clase FileSystem representa una abstracción de un sistema de
archivos.

Provee muchos servicios útiles, incluyendo la habilidad para accesar a archivos, carpetas,
usuarios, grupos, o notificaciones de cambio del sistema de archivos.

Obteniendo y usando una referencia al sistema de archivos. FileSystem es una
clase abstracta.
Instancias pueden ser obtenidas usado el correspondiente objeto de fábrica FileSystems.
FileSystems contiene un método getDefault() que regresa el sistema de archivos por default,
que es, el sistema de archivos desde el cual la Máquina Virtual de Java fue invocada.

Podemos obtener una referencia a este sistema de archivos por default así: No todos los sistemas de archivos comparten las mismas propiedades. Mientras los sistemas operativos derivativos de UNIX comparten una raíz de sistema de archivos unificada (/), Microsoft Windows tiene una raíz por partición y disco (C:\, D:\ y demás). Podemos revisar cuántas raíces tiene un dado sistema de archivos invocando el método getRootDirectories(), el cual regresa un Iterable<Path>, como se muestra a continuación:
Una instancia de FileSystem puede ser además usada para devolver instancias de Path. Los métodos en Path incluyen manipulación de métodos para comparar rutas, extraer sub-rutas, computar rutas relativas entre rutas y demás.

Obteniendo instancias de Path desde un objeto FileSystem se hace invocando al método getPath(), que toma un número variable de argumentos String. Cada String representa una parte de la ruta como se muestra a continuación:

Podemos comparar estas rutas así:
compareTo() devuelve los valores usuales -1, 0 y 1 para “menor que”, “igual a” y “más que” respectivamente.

A continuación de muestra como una ruta puede ser convertida a una URI o representación de archivo:

Además podemos realizar algunas manipulaciones de ruta, como se muestra a continuación:

Escuchando a los proveedores del sistema de archivos

Hay otros métodos de fábrica en FileSystems que pueden construir instancias de FileSystem
de una URI o ruta en un sistema de archivos. Esto es especialmente útil cuando proveedores
concretos actúan como sistemas de archivo virtuales sobre archivos zip, conexiones HTTP o
FTP, o unidades de red SMB.

Usando esta capacidad, puedes uniformemente manejar sistemas de archivos “reales” y
virtuales.

Es posible consultar el proveedor del sistema de archivos disponible usando la clase
FileSystemProvider, una interfaz de proveedor de servicio (SPI) que es parte del paquete
java.nio.spi.

El código mostrado a continuación (abajo) debe regresar tanto el archivo como los esquemas
JAR URI para muchas instalaciones de Java SE 7:
Aunque la especificación no requiera que un proveedor de esquema JAR esté disponible,
JDK 7 y OpenJDK proveen uno. Puedes tomar ventaja de la habilidad de los SPI’s para
aportar sus propios proveedores de sistema de archivos (HTTP, FTP, y demás), aunque
hacer eso está más allá de la mira de este artículo.

Vamos ahora más lejos a investigar las APIs NIO.2 abriendo un archivo zip como un archivo
de proveedor de sistema y “caminarlo”.

Caminando un proveedor de sistema de archivo

La clase java.io.File tiene métodos list() y listFiles(). Ellos pueden ser usados para instancias
de File que representan una carpeta, y regresan una lista de archivos y carpetas que son
“hijos directos” (que están dentro de la carpeta).

Un mecanismo un poco más poderoso es provisto con la clase java.nio.file.Files: visitores de
archivos y flujos de carpeta, los cuales pueden realizar filtros selectivos y combinaciones
(matching) para elementos descubiertos.

Veremos estas capacidades en el remanente de esta sección.

Abriendo un sistema de archivo zip. Vamos a abrir un JAR como sistema de archivo,
como se muestra a continuación:

La clase FileSystems provee otros métodos de fábrica newFileSystem, incluyendo uno que
toma un mapa de configuración como parámetro y usa claves específicas del proveedor. El
formato mostrado en el código anterior (arriba), el cual toma un Path y un ClassLoader, es el
formato preferido para abrir un sistema de archivo sobre un archivo.

A causa de que FileSystem implementa AutoCloseable, podemos usarlo como parte de una
sentencia try-with-resources que asegura que el método FileSystem.close() sea llamado, sin
importar si una excepción es lanzada.

Combinaciones de ruta. En este ejemplo, estamos interesados en imprimir todos los
archivos .class contenidos dentro del archivo. Podemos tomar ventaja de PathMatcher para
combinar (match) objetos Path ya sea contra una expresión regular o un archivo de sintaxis
glob usando el método match(), como se muestra a continuación:

Una expresión path matcher tiene la forma “glob:<glob-expression>” o “regexp:
<regular-expression>”.

Una expresión como “glob:/foo/*.{java,class}” combina cualquier archivo .java o .class
dentro de /foo.

Visitantes de archivos. El patrón de diseño Visitor encaja bien con la necesidad de
“caminar” un árbol de sistema archivos y tomar acciones en archivos. La interface
FileVisitor<T> define varios métodos para las siguientes circunstancias:

Un visitor que es notificado antes y después de entrar a una carpeta
Un visitor que es notificado cuando se visita un archivo
Un visitor que es notificado cuando se visita un archivo a través de una excepción

Además, los métodos de FileVisitor regresan un valor como parte de la enumeración
FileVisitResult para encargar que el “caminar” sea continuado, sea terminado, se salte los
hermanos (siblings), o salte un subtree.

Hay además una implementación por default llamada SimpleFileVisitor<T> que puede ser
sobreescrita. En nuestro caso, podemos caminar el fichero del sistema de archivos desde su
raíz e imprimir rutas de archivo .class, como se muestra a continuación:

Podemos con seguridad ignorar el parámetro attrs del método visitiFile() por el momento;
vamos a examinar como los atributos de archivos pueden ser manipulados después.

Y bueno, eso es todo por hoy, en la próxima entrada viene la segunda parte de esto, por
cierto, si notan las cajas de código algo raras o el texto, creo que es culpa de Blogger, anda
raro hoy :S, o quizá me metí demasiado en el HTML :P. Ya saben, suscríbanse ya sea por
correo o por RSS o Atom, dudas, peticiones, comentarios o criticas constructivas son bien
recibidas en la parte de abajo, saludos.

Entradas y Salidas en Java – Lo básico

2012-10-20T12:49:00.000-07:00

Hola y buen día a todos mis lectores, hoy, me dieron ganas de escribirles sobre algo que es muy importante para nosotros los programadores: Las entradas y salidas, como he dicho antes, esto es algo a lo que muchos “le temen” y más aún si han migrado de Visual Basic a Java, pero realmente es algo muy extensible y fácil de usar una vez que aprendemos, aquí les tengo una pequeña cita que me gustaría compartir…

Entradas y salidas (E/S en español, I/O en inglés, para abreviar) son fundamentales para cualquier sistema operativo o lenguaje de programación. Sólo los teoristas encuentran interesante escribir programas que no requieran entrada o produzcan salida. Al mismo tiempo, I/O – E/S (Lo llamaré I/O de ahora en adelante) difícilmente califica como uno de los temas más emocionantes en la ciencia de la computación. Es algo en el fondo, algo que usas cada día—pero para muchos desarrolladores, no es un tema con mucho “sex appeal”.
Elliote Rusty Harold.

Me gustaría extenderme sobre todo lo relacionado con I/O, comenzar desde InputStream y OutputStream (lo cubriré en otro tema), pero, ¿quién usa un FileInputStream cuando se tiene un FileReader (ver ejemplo de uso), o igual quién usa un FileOutputStream cuando se tiene un FileWriter (ver ejemplo de uso)?, por lo tanto, lo que voy a hacer es saltarme las “partes aburridas” (InputStream y OutputStream que nadie usa) y pasar a las excepciones, la consola, etc. Aquí les va:

Excepciones al utilizar I/O

Todos sabemos que al escribir código en Java tenemos que tratar muchas veces con las excepciones, ya sea que dividamos entre 0 (Lanza una excepción del tipo ArithmeticException), que tratemos de llamar a una posición en un arreglo que es mayor a su tamaño (ArrayIndexOutOfBoundsException), etc, etc. En este tema de las entradas y salidas, esto no cambia, cada que realizamos alguna operación que tome entrada o dé salida, tendrás que tratar una excepción del tipo IOException y puedes hacer esto de dos formas:

Que declares throws IOException en el método donde realizas entradas o salidas.
Que encierres la operación en un bloque try/catch.

La primera opción es mejor si quieres que quién llame el método tenga más control sobre qué hacer si algo sale mal (que se genere la excepción), la segunda es mejor si quieres que el bloque try/catch se haga cargo de todo, por ejemplo, que muestre un mensaje de error con un dialogo y que llame al método printStackTrace (seguimiento de la pila), es importante saber que no hay ninguna diferencia entre tratar una excepción de este tipo que en la que se trataría cualquier otra excepción.

Tratando con la consola

Primero que nada daré una pequeña definición de la consola: Llamamos consola (incorrectamente por cierto, pero la llamaré así por costumbre y comodidad del lector) a ese lugar donde normalmente vemos los mensajes que ponemos ya sea en System.out.print (o println), System.err.print (o println también) o de donde normalmente obtenemos la entrada de System.in. La veremos en distintas formas dependiendo del entorno de desarrollo o sistema operativo que usemos, por ejemplo si estás utilizando Eclipse, verás la consola en una pestaña normalmente en la parte inferior de la ventana de tu IDE (Integrated Development Environment, Entorno de Desarrollo Integrado en español), si usas Windows como sistema operativo, puede que veas la consola en una ventana de línea de comandos, igual es para Mac y Unix.

¿La consola como GUI?

La mayoría de nosotros (Incluido yo) utilizamos la consola al inicio de nuestro aprendizaje del lenguaje para ver lo que hacía nuestro código o simplemente comprobar al final que hacíamos bien las cosas, yo en lo personal aún la uso cuando no sé si mi error está en la interfaz (GUI) o en otra parte del código, también para probar código para el cual aún no tengo una GUI, para mí es un método muy útil para diagnosticar cual método o instrucción falla, pero algo muy importante que debemos recordar, es que ¡La consola no es una buena GUI! En estos tiempos, yo no veo casi ninguna razón (por no decir que ya no la hay en lo absoluto) para pensar en utilizar la consola como interfaz de usuario, por mínima que sea la interfaz, una cosa es usar la consola en tiempo de desarrollo para tratar de darte cuenta donde te equivocaste, y otra muy distinta es que tus programas ya dirigidos al usuario la utilicen. Algunos quizá piensen ¿No se debe usar la consola solo por cuestión de estética? Pues no es así, la consola, además de ser una interfaz de usuario muy fea y poco versátil, tiene aún más desventajas, por ejemplo:

Puede confundir al usuario (incluso hacerle pensar que el programa no funciona bien).
No puedes mostrar botones, combos, cajas de texto, etc.
No es nada fácil de usar para el usuario final.
En sistemas operativos como Mac y en algunos navegadores, la consola no admite entradas (System.in), sólo salidas (System.out y System.err).

Conociendo System.out a fondo

La mayoría llegamos a utilizar System.out incluso antes de saber lo que es una clase o un OutputStream. Específicamente, System.out es el campo estático de la clase java.lang.System. Es una instancia de java.io.PrintStream, que es una subclase de java.io.OutputStream.

System.out corresponde a stdout en Unix o C. Normalmente, la salida enviada a System.out aparece en la consola. Como regla general, la consola convierte los datos numéricos byte que envía System.out en texto ASCII o ISO Latin-1. Por lo tanto, el siguiente código escribe la cadena “Hello World!” en la consola:

Conociendo System.err a fondo

Los programadores de Unix y C reconocen stderr, que es comúnmente usado para mensajes de error. stderr es un puntero de archivo separado de stdout, pero muchas veces significa lo mismo. Generalmente tanto stderr como stdout envían datos a la consola, cualesquiera que estos sean. De todas formas, stdout y stderr pueden ser redireccionados a diferentes lugares. Por ejemplo, la salida puede ser redireccionada a un archivo mientras los mensajes de error aún aparecen en la consola.

System.err es la versión de Java de stderr. Como System.out, System.err es una instancia de java.io.Printstream, una subclase de java.io.OutputStream. System.err es comúnmente más usado dentro de la clausula catch de un bloque try/catch así:

Conociendo System.in a fondo

Sytem.in es el flujo de entrada conectado a la consola, tanto como System.out es el flujo de salida conectado a la consola. En términos Unix o C, System.in es el campo estático de la clase java.lang.System. Es una instancia de java.io.InputStream, al menos hasta donde está documentado.

Pasado lo que está documentado, System.in es en realidad un java.io.BufferedInputStream. BufferedInputStream no declara métodos nuevos, solo reescribe los que ya están declarados en java.io.InputStream. BufferedInputStream lee los datos en grandes pedazos en dentro de un búfer, entonces reparte los datos en los tamaños pedidos. Esto puede ser más eficiente que leer un carácter a la vez. De tal manera que, es completamente transparente para el programador.

La razón principal de esto es que cada byte no se presentado para ser leído mientras el usuario lo escribe en System.in. En su lugar, la entrada entra en el programa de una línea a la vez. Esto permite al usuario escribir en la consola la tecla de retroceso para corregir errores. Java no te permite poner la consola en un “modo sin procesar”, donde cada carácter se vuelve disponible tan pronto como es escrito, incluyendo caracteres como backspace (retroceso) y delete (borrar).

Bien, eso es todo por hoy, no olviden que pueden suscribirse a mis entradas por medio de su correo (en la parte superior derecha), RSS o Atom (en la parte inferior derecha), y pues ya saben, dudas, comentarios, criticas (constructivas) o peticiones son bien recibidas en la parte de abajo, saludos :D.

Entradas Relacionadas:
Escribir un archivo de texto en Java
Leer un archivo de texto en Java

Utilizando SQLITE en Java

2012-10-16T13:07:00.000-07:00

Hola y buen día a todos mis lectores, después de 8 días sin subir entradas a mi blog, hoy por fin me decidí a hacerlo. Hace casi un mes publiqué una entrada sobre cómo instalarSQLITE en Eclipse IDE, y prometí que publicaría otra sobre cómo utilizar la librería, así que aquí les va:

¿Cómo crear el archivo de la base de datos?

El archivo de la base de datos se crea automáticamente cuando realizamos una conexión a la base de datos, aunque no exista, digamos que realizo una conexión a esta ruta: Antes de llamar al método conectarA no existía un archivo llamado nueva.db pero al momento de que se realiza la conexión tal archivo “se crea solo”.

Realizando la conexión

Lo primero, y lo más importante siempre que hagamos una consulta, actualización o alguna otra cosa en la base de datos es realizar la conexión a la misma, para esto, yo recomiendo toda una clase que se encargue de obtener y devolver la conexión como se muestra a continuación: Esto puede ser suficiente para la mayoría de las aplicaciones que requieran una base de datos, pero, para los que requieran algo un poco más complejo, podemos mejorar este código para cumplir con los siguientes aspectos:

Que el usuario pueda elegir donde guardar el archivo de la base de datos.
En caso de que no elija uno, guardar el archivo en una ubicación por default.

Estos dos puntos mejorarían mucho nuestra aplicación por varias razones, la más importante es que la base de datos puede ir en una ubicación extraíble como una memoria USB o que el usuario podrá recordar donde puso la base de datos (no siempre es recomendable esto ya que podría modificarla o eliminarla, pero depende del uso que se le dará a aplicación), etc.

Pero agregar estas características a nuestro programa va a complicar un poco (mucho la verdad) el código, les mostraré como lo hice yo, obviamente quizá para ustedes no sea la mejor forma de hacerlo, siéntanse libres de mejorar el código a su gusto, pero si lo hacen procuren publicarlo en un comentario, recuerden que este es un blog para aprender del lenguaje.

Primero necesitamos otra clase, que se encargue de manejar la ruta en donde estará nuestra base de datos y para comodidad del usuario, emplearemos un selector de carpetas muy parecido al que usamos en mi entrada llamada Leer un archivo de texto en Java, el selector de carpetas se encargará de tomar la ruta que el usuario seleccione para guardar la base de datos y la guardará en un archivo de texto para no tener que hacer esto cada vez que realicemos una conexión a la base de datos, también vamos a modificar bastante la clase BaseDeDatos aquí les va el código completo: Si el código fue ejecutado de la manera correcta, verán 5 mensajes en la consola, estos son opcionales, pero también muy importantes para saber que todo se hizo de la manera correcta, al estar seguros de que todo funciona bien, pueden quitarlos si gustan, así que ahora, tenemos ya el código necesario para conectarnos a una base de datos, ya sea que el usuario seleccione la ubicación o se seleccione por default, nos costó un poco más de trabajo, pero ahora todo lo que hacemos para conectar a nuestra base de datos es llamar al método BaseDeDatos.obtenerConexión y listo, podemos hacer una consulta, actualización o cualquier otra cosa que nos permita SQLITE.

En la próxima entrada, les mostraré algo un poco más interesante: Cómo hacer consultas, eliminar tablas, obtener todos los datos de alguna, y algunas otras cosas útiles, pero por ahora, ya me cansé de teclear, así que es todo por hoy, no olviden dejar sus peticiones, dudas, comentarios o criticas en la parte de abajo, ahh y votar en la sección “Mi opinión”, también pueden suscribirse en la parte superior derecha, saludos :D.

Entradas Relacionadas:
Como instalar SQLITE en Eclipse IDE

Leer un archivo de texto en Java

2012-10-08T15:21:00.001-07:00

Hola y buen día a todos mis lectores, al revisar mis entradas hoy, me di cuenta de algo, tengo una que se trata sobre cómo escribir archivos de texto en Java, pero no tengo una sobre como leerlos, quizá para algunos esto sea muy fácil de hacer, pero puede que a otros se les dificulte un poco, así que bueno, aquí les diré como:

“Directo al grano”

Esto es para quienes simplemente quieren saber cómo hacerlo sin más explicación, yo no recomendaría simplemente copiar el código y “a lo que sigue”, siempre es bueno saber el porqué usamos tal clase o ponemos las instrucciones de cierta forma, ya saben, para el futuro, de todos modos, aquí les va el código:
Obviamente para la prueba hay que escribir y guardar algo de texto en un archivo llamado nota.txt en C:/ de lo contrario nos lanzará una excepción del tipo FileNotFoundException en el bloque try/catch (el primer catch en el bloque de arriba). La salida en consola que obtuve al correr el código fue la siguiente:

ESTÁS
EN

BLOG

BARO

¿Quiere saber más?

Para quienes les interese, en esta sección veremos paso a paso el código de arriba y le daremos algunas mejoras (se aceptan sugerencias abajo) así que aquí va la revisión y explicación del código.

Primero que nada vemos varias líneas que inician con la palabra reservada import, para quienes no saben, la palabra reservada import es para utilizar la clase o paquete escrito después del mismo, en este caso: java.io.BufferedReader, java.io.File, java.io.FileNotFoundException, etc.

Después vemos el nombre de la clase, que es LectorTexto, claro que podemos ponerle el nombre que queramos, no importa, después vemos el comentario para el método leerTexto, ahí normalmente ponemos una breve descripción de lo que hace el método, el o los parámetros y lo que regresa (si no es void).

El método leerTexto

Para empezar el método leerTexto, pide como argumento un String, en el cual pondremos la ruta del archivo que queremos leer, y lo que devuelve (como lo dice el comentario del método) es el texto dentro del archivo. Ahora, para convertir el texto pasado como argumento en un archivo que se pueda leer, lo ponemos en el constructor de File de esta forma: File archivo = new File(ruta); Y listo, la ruta que fue pasada como argumento ahora es un archivo que apunta a nuestro texto.

Pero tener un archivo apuntando a nuestra nota no es suficiente, se necesita de alguien que lo lea, en este caso utilizamos la clase FileReader la cual nos permite leer el archivo que pasemos como argumento en su constructor: FileReader fr = new FileReader(archivo); Y con esto tenemos el lector, el cual por desgracia solo nos devuelve enteros al leer el archivo, que se podrían convertir en texto, pero “¿No podría hacerlo otro?” En este caso, sí, utilizamos BufferedReader para hacer más eficiente la lectura y que se haga en líneas, lo cual nos facilita mucho las cosas, para poner un búfer a nuestro lector de archivo (FileReader) hacemos esto: BufferedReader bf = new BufferedReader(fr);

¡Perfecto! Ahora tenemos el búfer que nos ayudará mucho en la lectura del archivo, pero no es suficiente, ¿Qué pasa si el archivo contiene varias líneas? Para eso tenemos el ciclo while en nuestro código y escribimos las sentencias necesarias para hacer que el búfer haga la lectura de todas las líneas en el archivo (ver el código de arriba) y opcionalmente, devolverlas en líneas separadas gracias a la propiedad line.separator, utilizamos también la clase StringBuffer para ir agregándole el texto por cada línea que sea leída por el búfer (y que no sea null).

Al finalizar el ciclo while asignamos a nuestro atributo texto lo que hay dentro del StringBuffer, así: texto = sbf.toString();

Mejorando el lector de archivo

Nuestra pequeña y simple clase lee los archivos de texto de manera muy eficiente, pero, lo que no es tan eficiente, es la forma en que señalamos que archivo queremos leer, en especial con rutas muy largas, pero afortunadamente hay una solución, ¡Un selector de archivo! Que permitirá al usuario elegir el archivo que se quiere leer de una forma mucho más cómoda y fácil.

Agregando un selector de archivo

Agregar un selector de archivo a nuestro lector de texto será algo muy fácil, crearemos un nuevo método llamado lanzarSelector() que mostrará el selector de archivo que va a devolver la ruta del archivo que se ha seleccionado para después leer el texto dentro de él y mostrarlo ya sea en la consola o en una interfaz con JTextField, JLabel o quizá un JTextArea (ese proyecto de la interfaz te lo dejo a ti).

A continuación se muestra el nuevo código ya con el selector de archivo:

Esto facilita muchísimo las cosas, ahora el método lanzarSelector lo hace todo, lo mejor es que podemos usar este código para muchas cosas, tanto el lector de texto, como el selector de archivo. Otra cosa muy importante, es que, el lector de archivo no lee solamente archivos con extensión *.txt, puede leer cualquier archivo y mostrarlo en forma de texto, pruébalo.

Y bien, esto es todo por este artículo, espero les haya gustado, y ya saben, suscríbanse en la parte superior derecha con su email si les gustan mis entradas, dudas, peticiones, comentarios o criticas son bien recibidas en la parte de abajo, saludos a todos :D.

Entradas Relacionadas:

Escribir un archivo de texto en Java

Entradas y Salidas en Java - Lo básico

Aprender Java creando un juego (Parte 6) - Final

2012-10-04T15:33:00.002-07:00

Hola y buen día a todos mis lectores, les tengo la parte final de este gran proyecto de la tortuga en el entorno Greenfoot, si se han perdido de todas las demás partes ya publicadas aquí ¡qué esperan!, visítenlas y entérense de qué se trata este proyecto:

El juego que continuamos creando en previas entradas se acerca más y más a estar completo, pero algunas partes siguen perdidas. Hoy, te mostraré como terminar el juego y—lo más importante—como compartirlo con tus amigos. Si no nos has acompañado en este proyecto, revisa cada una de sus partes en este blog (links arriba), descarga Greenfoot y únete a la diversión.

Finalizando el juego

Actualmente, no hay forma de ganar este juego. Comes todas las rebanadas de pizza, y nada pasa. No hay trompeteo, ni un gran anuncio de “¡GANASTE!”. Igualmente, cuando las serpientes te atrapan, el juego solamente sigue corriendo en silencio. Queremos arreglar ambas situaciones. Vamos a decir que cuando logres comer 12 rebanadas de pizza, ganas. El juego se detiene, y oímos un victorioso trompeteo. De todas formas, cuando las serpientes te atrapan, pierdes. Obtenemos de igual forma un sonido, y el juego se detiene. El segundo escenario (perder) es fácil de hacer—tenemos casi todo para eso ya. Así que haremos eso primero, y entonces mirar a la funcionalidad necesaria para ganar.

Perder (Ser comido por las serpientes)

Tenemos ya un efecto de sonido para cuando la serpiente se come a la tortuga (en el método eat de la serpiente), el cual usa el método Greenfoot playSound. La primera cosa que haremos es solo cambiar el sonido a un nuevo archivo de sonido (el cual puedes descargar aquí) nombrado trombone.wav.

Entonces añade una nueva línea: una llamada al método Greenfoot stop para detener el juego en este punto. Juntos, el código se ve así:

Nota que ambos métodos son métodos estáticos de la clase Greenfoot, así que tenemos que escribir el nombre de la clase Greenfoot y un punto antes del nombre del método en la llamada al método.

Para descubrir que otros métodos ofrece la clase Greenfoot, elige Greenfoot Class Documentation del menú Help.

Otra alternativa es, usar code completion. Por ejemplo, después de escribir Greenfoot. (eso es, después del punto), presiona Ctr-Space en tu teclado, y verás una lista de todos los métodos que puedas llamar hasta ese punto, como se muestra a continuación:

Al empezar a escribir un nombre de un método va a reducir las opciones. Entonces elige cualquiera de los métodos de la lista. Implementar este fin del juego fue bastante fácil. Hacer una cosa similar para ganar es un poco más de trabajo.

Ganando (Terminando tu pizza)

Queremos que nuestra funcionalidad de ganar (trompeteo y detener el juego) ocurra cuando hayamos comido toda nuestra pizza (12 rebanadas). Escogiendo este criterio, tenemos dos problemas. Primero, actualmente tenemos solo 7 rebanadas de pizza en nuestro juego. Podemos, por supuesto, simplemente poner 12 rebanadas desde el inicio, pero eso haría el juego demasiado fácil. En su lugar, quiero hacer que aparezca una nueva rebanada cada vez que una es comida.

Y segundo, ahora necesitamos contar cuando hemos comido, de manera que sepamos cuando parar. Nosotros no sabemos aún como hacer eso.

Haremos estas dos cosas.

La pizza que aparece mágicamente

Las rebanadas de pizza que se comen en la clase Turtle—para ser específico, en el método eat de la tortuga. Así que ahí es donde comenzamos a trabajar. Para mantener el código limpio, ponemos las instrucciones para crear una nueva rebanada de pizza en un método separado y llamar a ese método desde aquí. Así que ponemos una llamada a placeNewPizza() en nuestro método eat, justo debajo de la reproducción del sonido:

El método placeNewPizza() va a poner una nueva rebanada en el mundo cada vez que otra rebanada es comida. Este método no existe—vamos a tener que escribirlo ahora.

El código completo para este método se muestra a continuación:

Veremos que el método eat() llama al método placeNewPizza() y la definición para este nuevo método. Vamos a analizar esto línea por línea.

Para poner una nueva rebanada de pizza al azar en el mundo, tenemos que lograr tres cosas:

Crear un nuevo objeto pizza.
Generar coordenadas al azar.
Poner la pizza en esas coordenadas en el mundo.

La primera línea en nuestro nuevo método pone:
Hemos visto antes que la llamada a getWorld() nos da una referencia a nuestro objeto mundo actual. Esta vez, vamos a declarar una variable local llamada myWorld (es de tipo World) y almacena el objeto mundo en sí. Esto, por su cuenta, no logra mucho todavía, a parte del hecho de que ahora podemos usar la variable myWorld para “hablar” con nuestro mundo.

En las siguientes dos líneas, vamos a generar las coordenadas al azar y almacenarlas en dos variables locales de tipo enteras (int):

Hemos visto ya antes llamadas a los métodos getRandomNumber, getWidth, y getHeight. Aquí, vamos a generar un número aleatorio entre 0 y el ancho del mundo y almacenarlo en la variable x. Entonces haremos lo mismo para y usando el alto del mundo como límite. Esto nos da coordenadas x y y al azar que concuerdan con el tamaño exacto del mundo.

La última línea hace la magia:

Aquí, ponemos el nuevo objeto pizza en el mundo. Para hacer esto, estamos usando el método del mundo addObject. Este método espera tres parámetros: el objeto a ser ubicado, la coordenada x, y la coordenada y.

Podemos escribir new Pizza() para crear un nuevo objeto de tipo Pizza, y podemos usar éste en el lugar del objeto para ser ubicado en el mundo. Entonces podemos usar nuestras variables x y y (las cuales acabamos de llenar con nuestros valores aleatorios) en el lugar de las coordenadas.

Lee el código de arriba completo (el que incluye el método eat y placeNewPizza) nuevamente y asegúrate de entenderlo. Entones inténtalo por ti mismo.

Contando la pizza

La funcionalidad hasta ahora nos da un suministro sin fin de rebanadas de pizza. La siguiente tarea que se debe hacer es contar cuando hemos comido. Hacemos esto creando un campo (también conocido como una variable instancia) nombrada slices (rebanadas) que se usarán para contar. (Aún estamos trabajando en la clase Turtle.)

Así es como se ve:

La declaración de campo consiste de la palabra clave private, seguida por el tipo y el nombre para nuestra variable, y un valor opcional de inicialización. El tipo y nombre (int slices) es el mismo que hemos visto para una variable local. La inicialización (= 0) asigna cero a la variable para empezar. Poner esta línea es importante. Las declaraciones de campo deben hacerse fuera de las definiciones de métodos, así que escribimos esta línea inmediatamente después de la cabecera de clase (antes de nuestro método act).

El campo slices puede almacenar enteros (eso es, números enteros). Actualmente almacena cero. Podemos ahora usar este campo para contar nuestras rebanadas de pizza. Cada vez que comemos algo de pizza, incrementamos este campo en 1. Cuando hayamos llegado a 12, reproducimos el trompeteo (el archivo de sonido fanfare.wav, el cual puedes descargar aquí) y detenemos el juego.

A continuación se muestra la implementación completa:

Vamos brevemente a examinar los aspectos interesantes.
Tenemos adjunta la siguiente línea: El operador ++, escrito después de una variable int, incrementa (eso es, contar hacia arriba) esta variable en 1. Así que podemos ver que estamos contando hacia arriba cada vez después de eliminar una rebanada de pizza del mundo.

A continuación, tenemos las siguientes líneas (con algunas instrucciones en el lugar de los tres puntos): Este código revisa si la variable slices es ahora igual a 12 y, si lo es, ejecuta las instrucciones entre el primer par de llaves. De otra forma (si la variable no es igual a 12), las instrucciones después de la palabra clave else son ejecutadas. Nota que necesitamos usar un símbolo de igual doble (==) para revisar si hay igualdad.

Lee el código completo de arriba con cuidado (donde está el método eat completo). Verás que este código es usado para reproducir nuestro sonido de sorber y pone una nueva rebanada de pizza mientras no se hayan comido 12 rebanadas aún. Entonces reproduce el sonido de las trompetas y termina el juego cuando hayamos comido 12 rebanadas. Intenta el código en tu propia versión del juego.

Compartiendo tu juego

Ahora que nuestro juego está “completo” en algún sentido—por su puesto, ningún juego está realmente terminado nunca—sería grandioso si pudiéramos hacer que todos nuestros amigos lo probaran. Afortunadamente, podemos.

Greenfoot tiene una función llamada “share” (compartir) que nos permite subir nuestro programa al sitio web de Greenfoot, donde otros usuarios pueden jugarlo y darte algo de retroalimentación.

Tú puedes ver todos los scenarios que otros usuarios Greenfoot han creado dirigiéndote al sitio Greenfoot y mirando alrededor.

Para subir tu propio juego, da click en el botón Share en la parte superior derecha de la ventana principal de Greenfoot. Al dar click aparece una caja de dialogo que nos permite especificar algunos detalles para subirlo como se muestra en la siguiente imagen:

Para poder subir tu juego, debes tener una cuenta en el sitio Greenfoot. (Si no la tienes, da click en el link Create account.) Puedes explorar y jugar juegos de otras personas sin registrarte, pero para subir tu propio juego, necesitas una cuenta.

Una vez que tengas una cuenta, esta caja de dialogo te deja añadir un título, una descripción, un ícono, y algunas etiquetas, y entonces puedes subir tu juego. Cuando subes un juego, puedes elegir si quieres subir el código fuente también. Si lo haces, otros pueden mirar el código fuente y posiblemente aprender de él o modificarlo por ellos mismos.

Tu proyecto tendrá una URL única en el sitio web Greenfoot. ¡Envía ésta a tus amigos para mostrarles las cosas ‘chidas’ (cool) que has hecho!

Pues bien, se terminaron las entradas sobre el proyecto de la tortuga en Greenfoot, pero quizá vengan algunos otros diferentes, espero que hayan disfrutado de estas entradas tanto como yo disfrute subiéndolas, ya saben, pueden suscribirse en la parte superior derecha con solo poner su email y les llegarán las noticias de mi blog a su bandeja de entrada, los comentarios, peticiones, dudas o criticas van abajo, saludos :D.

Traducción: El Blog De Baro.

Escrito por: Michael Kölling.

Fuente: Java Magazine.

Entradas Relacionadas:
Aprender Java creando un juego (Parte 5)
Aprender Java creando un juego (Parte 4)

Aprender Java creando un juego (Parte 5)

2012-10-02T11:11:00.000-07:00

Hola y buen día para todos mis lectores, les tengo aquí la quinta parte del proyecto de la tortuga en el entorno Greenfoot, estamos muy cerca de concluirlo, así que ¡A programar! (obviamente antes de programar hay que leer lo que sigue)…

Cuando dejamos nuestro proyecto Java en la entrada previa, obtuvimos un pequeño y divertido juego en el cual una tortuga estaba comiendo pizza mientras trataba que las serpientes no se la comieran como se muestra en la siguiente imagen:

Si no has estado escribiendo los códigos de este proyecto hasta ahora, descarga e instala Greenfoot, y entonces visita las otras entradas de este blog (Parte 1, Parte 2, Parte 3, Parte 4) y únete en esta sesión.

Mejorando las serpientes

En nuestra versión actual, el movimiento de las serpientes está controlado por estas 2 líneas de código:

El efecto es que las serpientes siempre se mueven hacia adelante, y giran en un ángulo aleatorio (20 grados a la derecha o izquierda) a cada paso. Esto trabaja bastante bien cuando una serpiente está en medio de la pantalla. De todas formas, cuando esta golpea la orilla de nuestro mundo, queda atorada ahí por un rato antes de lograr dar la vuelta y cazar a la tortuga de nuevo. Podemos mejorar esto haciendo que las serpientes siempre giren cuando lleguen a la orilla del mundo.
(Esto además me da una oportunidad para enseñarte dos cosas: Podemos usar una sentencia if para tener un poco más de practica con esto, y tendremos una oportunidad para llamar métodos desde el objeto world.)

Girando a la orilla del mundo

Si queremos hacer que la serpiente gire a la orilla del mundo, primero debemos reconocer cuando estamos en la orilla. Podemos hacer esto definiendo un nuevo método llamado atWorldEdge que se encargue de revisar esto. Este método regresa un resultado Boolean: true si estamos cerca de la orilla, y false si no es así. El formato se ve así:

Entre este método, queremos escribir algo de código que exprese algo como esto:

Si estamos cerca del borde izquierdo o derecho, devuelve true.
Si estamos cerca del borde superior o inferior, devuelve true.
De otra forma, devuelve false.

Para la primera prueba mencionada aquí, necesitamos saber nuestra coordenada x. Para la segunda prueba, necesitamos nuestra coordenada y. Podemos obtener ambas usando los métodos getX() y getY() de la clase Actor. Estos dos métodos devuelven como su resultado nuestra posición actual.

Revisar si estamos en el borde izquierdo es bastante fácil, porque sabemos que la coordenada del borde izquierdo siempre es cero. Así que podemos escribir lo siguiente:

De hecho, queremos comenzar a girar no solo cuando demos con el borde, si no que cuando estemos cerca de él. Vamos a definir “cerca” en 10 pixeles. Así, podemos escribir lo siguiente: Eso trabajará bien. Revisar si estamos en el borde derecho, de todas formas, es un poco más complicado, porque la coordenada del borde derecho de un mundo puede variar.

Una opción es mirar en el código fuente de la clase TurtleWorld para ver el tamaño actual de nuestro mundo. Si hacemos esto, podemos ver que nuestro mundo tiene un tamaño de 600 x 400 pixeles, así que la posición más a la derecha posible está en la coordenada x 599.

Agregando nuevamente, un búfer de 10 pixeles, podemos ahora extender nuestra sentencia if desde arriba para además revisar el borde derecho:

La doble barra vertical (||) es un operador or (‘o’ en español), así que podemos leer esto de la siguiente forma (en español, el código claro que va en inglés, pero lo que sigue es pseudocódigo):
Esto va a trabajar para este mundo en particular, pero solo mientras no decidamos en algún punto cambiar el tamaño de nuestro mundo. Una mejor solución sería sólo llamar a un método y preguntarle qué tan ancho es el mundo.
Podemos hacer eso cambiando nuestra sentencia if a esto:

En esta condición, getWorld() llama a un método para que devuelva el objeto world en sí. Este objeto será devuelto desde esta llamada al método. Nosotros entonces llamamos a un segundo método getWidth(), en este objeto world.

Esta técnica es mucho mejor que poner el tamaño actual del mundo en nuestra clase, porque se adaptará flexiblemente a los cambios en el tamaño de nuestro mundo.

El método completo, después de que completamos la sentencia if y además añadimos otra para revisar la coordenada y se muestra a continuación:

Sentencias if/else

Otra nueva construcción que vemos en el código anterior es un ejemplo de una sentencia if/else. Ya hemos visto antes sentencias if, consisten de una condición y un cuerpo. El cuerpo fue ejecutado solo cuando la condición era true.

Esta nueva forma de la sentencia if tiene una palabra clave adicional, else, y un segundo bloque de código adjunto (ver el código de arriba). Este segundo bloque es ejecutado cuando la condición no es true.

Completando el giro

Ahora tenemos un método que nos permite revisar donde estamos cerca del borde del mundo. Lo siguiente que debemos hacer es girar si estamos al borde. Esto es ahora bastante fácil.

Añadimos una sentencia if a nuestro método moveAndTurn(), usando atWorldEdge como condición y giramos cuando notemos que estamos en el borde.

A continuación se muestra la nueva versión del método moveAndTurn() con esta mejora.

Intenta esto en tu propio scenario. Deberías notar que las serpientes ahora giran muy efectivamente una vez que llegan al borde del mundo.

Una lección importante

La lección más importante que aprendimos de esto es: El mundo es un objeto también, y tiene métodos útiles.

Podemos investigar los métodos del mundo de dos formas: Podemos solo llamarlos o también podemos leer su documentación.

Podemos llamar a un método del mundo dando click derecho a la imagen de fondo del mundo y seleccionando un método heredado del submenú mundo como se muestra a continuación:

Deberías intentar, por ejemplo, llamando a los métodos getWidth() y numberOfObjects() para ver lo que hacen.

Para investigar los métodos del mundo, leyendo su documentación, ve a la ventana principal de Greenfoot y selecciona Greenfoot Class Documentation del menú Help. Esto abre un explorador web con la documentación para todas las seis clases API. Selecciona la clase World y podrás ver una lista de métodos disponibles y sus descripciones.

Añadiendo sonido

Otra cosa que podemos hacer para mejorar nuestro pequeño juego es añadir efectos de sonido.

Descarga los archivos slurp.wav (slurp = sorber) y au.wav y guárdalos en tu carpeta del proyecto de la tortuga, ejemplo: C:\Greenfoot\scenarios\turtle\sounds\.

La clase Greenfoot tiene un método estático playSound que toma el nombre y reproduce el sonido. Así que podemos reproducir el sonido slurp simplemente escribiendo lo siguiente:

Trata de añadir esta sentencia al código de tu tortuga, de manera que este sonido sea reproducido cuando la tortuga coma algo de pizza. A continuación se muestra el método eat() resultante: Si esto funciona, haz un cambio similar al código del actor Snake, de manera que la serpiente reproduzca el sonido au.wav cuando se coma la tortuga.

Grabando tus propios sonidos

Añadir efectos de sonido reproduciendo sonidos pregrabados es fácil, y eso añade un poco de diversión al proyecto. Pero podemos hacer esto aún mejor creando nuestros propios sonidos.

Mientras se pueden encontrar librerías de efectos de sonido gratuitas en el internet y usar los efectos descargados de ahí, por mucho la manera más fácil (y la más divertida) de añadir efectos es grabándolos tú mismo. Puedes hacer esto en cualquier computadora con un micrófono integrado.

Greenfoot tiene un grabador de sonidos integrado que hace realmente fácil hacer esto. Usando el menú principal, elige Show sound recorder desde el menú Controls. Esto traerá la interfaz del grabador de sonidos en una ventana separada como se muestra a continuación:

Este grabador de sonidos te permite grabar tu propia voz, o cualquier otro efecto de sonido, y recortarlo para eliminar sobresalientes no deseados o ruido de fondo o silencio. Puedes entonces guardar el sonido bajo el nombre de tu elección. Nota que Greenfoot siempre añadirá el sufijo .wav al nombre tu tu archivo.

Esto es importante porque se debe usar el nombre de archivo completo cuando se usa el sonido en tu código.

Por ejemplo, si se especifica “bark” como el nombre para tu sonido, Greenfoot nombrará el archivo como bark.wav, y podrás reproducirlo en el scenario usando la siguiente sentencia en tu código fuente:

Añadiendo tus propios efectos de sonido es una manera muy efectiva y muy fácil para personalizar tu scenario y hacerlo mucho más atractivo y divertido de jugar.

La clase Greenfoot

Aquí hay una lección general para llevar de esto: Vale la pena estar familiarizado con los métodos disponibles en la clase Greenfoot. Abre de nuevo la documentación de clase Greenfoot (como se describe arriba, usando la función del menú Help) y da un vistazo a los métodos disponibles en esta clase.

Tenemos ya usados algunos de ellos (para números aleatorios, control de teclado, y sonido), pero ahí hay otros que quizá encuentres útiles para hacer futuros cambios en tu propio scenario.

El API Greenfoot no es grande, y leer la documentación es tiempo bien gastado si planeas trabajar más con Greenfoot.

Tip: Maestros e instructores pueden encontrar mucho material de enseñanza en la comunidad de educadores Greenroom.

Conclusión

En este articulo, encontramos dos aspectos fundamentales de Java y la programación en Greenfoot:

El mundo en sí es un objeto Java. Tiene métodos que tú puedes llamar para interactuar con el mundo. Puedes usar la documentación del API Greenfoot para encontrar otros métodos existentes.

Greenfoot puede fácilmente grabar y reproducir sonidos. Esto hace a los scenarios de juego mucho más atractivos.

El método para reproducir un sonido está en la clase Greenfoot.

Bueno, eso es todo por hoy, ya me cansé de escribir, para la próxima entrada, la parte final de este gran proyecto, no se la pierdan, pueden suscribirse por email si quieren, en la parte superior derecha de esta página, comentarios, dudas, peticiones, criticas, abajo, con gusto doy respuesta, saludos a todos.

Traducción: El Blog De Baro.

Escrito por: Michael Kölling.

Fuente: Java Magazine.

Entradas Relacionadas:
Aprender Java creando un juego (Parte 6)
Aprender Java creando un juego (Parte 4)
Aprender Java creando un juego (Parte 3)
Aprender Java creando un juego (Parte 2)
Aprender Java creando un juego (Parte 1)

Aprender Java creando un juego (Parte 4)

2012-09-29T11:56:00.000-07:00

Buen día para todos mis lectores, después de algunos días de ausencia, aquí les tengo la cuarta parte del proyecto de la tortuga en el entorno Greenfoot, como les había dicho ya, nuestra tortuga enfrentará una situación aún más peligrosa (porque ya bastante riesgo era morir de una sobredosis de pizza), la pondremos en la mira de un depredador, para ser más precisos, una serpiente, así que aquí les va...

Hemos creado ya una tortuga controlada por teclado que camina y come pizza. En este articulo, empezaremos a hacer las cosas más interesantes introduciendo un depredador que está tras nuestra tortuga—nuestra tortuga no solo debe recolectar las rebanadas de pizza, ¡sino que también debe evitar ser comida por una serpiente mientras o hace! Vamos a continuar desde donde dejamos nuestro proyecto la vez anterior, así que si te perdiste los artículos pasados, quizá sea una buena idea verlos primero para ver cómo llegamos hasta aquí (Parte 1, Parte 2, Parte 3).

Limpiando Nuestro Código

El método act de nuestra tortuga, como lo dejamos la última vez, se muestra a continuación:

Antes de que vayamos a añadir más funcionalidad a nuestro programa (y, en el proceso, hacer nuestro código más complejo), es una buena idea tomarse un minuto para mejorar la estructura de nuestro código. Especialmente, nuestro método act se está volviendo un poco largo, y está comenzando a tomar algo de esfuerzo para leerlo y darse cuenta de lo que hace.

En general, deberíamos apegarnos a mantener nuestros métodos cortos y claros (o como diría Steve Oualline, apegarnos al principio KISS: “Keep It Simple, Stupid”). Podemos hacer esto rompiendo el método act en múltiples métodos, cada uno definiendo una tarea lógica. En nuestro ejemplo, nuestro método act hace dos tareas lógicas distintas:

Movimiento (moverse hacia adelante y posiblemente girando)
Buscar pizza (y posiblemente comiéndola)

Podemos mover cada una de estas dos tareas en un método por separado, y entonces llamar a cada método desde el método act. En esta versión del código, hemos definido dos métodos adicionales, moveAndTurn y eat. Da una buena mirada a continuación para ver cómo fue hecho esto:

Cada una de las definiciones de método tiene una sección al inicio conteniendo algunos asteriscos. Por ejemplo, el método eat comienza con esto:

Este es un comentario de método.Un comentario es escrito para el programador (no para la computadora). El comentario explica, en tus palabras, (o las de otro programador si estás viendo el comentario de alguien más) el propósito del método que está debajo. Las líneas siguientes al comentario definen el método. Te darás cuenta que los cuerpos de los métodos contienen exactamente el mismo código que estaba previamente en el cuerpo del método act.

Ahora, el método act contiene sólo llamadas a los dos nuevos métodos:

Nota que esta versión de nuestro código hace exactamente lo mismo que la versión anterior—es funcionalmente equivalente. De todas formas, a causa de que lo hemos cortado en partes más pequeñas, es ahora más fácil de leer, y podemos reconocer más fácilmente qué hace el método act.

Deberías hacer los mismos cambios en tu propio código.

¡Serpientes Abordo!

Ahora que hemos mejorado la estructura de nuestro código, podemos seguir adelante añadiendo cosas a nuestro proyecto. Queremos introducir un enemigo de nuestra tortuga: serpientes.

Comienza por crear otra subclase de Actor, llamada Snake, con la imagen de una serpiente. Recuerda, puedes crear una subclase de Actor dando click derecho a la clase Actor y eligiendo New subclass. Nombra a la clase Snake y elige una imagen de serpiente de la categoría Animals como se muestra a continuación:

Compila tu scenario y pon unas cuantas serpientes en el mundo como se muestra a continuación:

Quizá quieras salvar el mundo de nuevo (click derecho en la imagen de fondo del mundo y elige Save the World) agrega tus serpientes al mundo salvado.

Comportamiento de la serpiente

Inicialmente, nuestra serpiente no hace nada.

Nos gustaría que ellas se movieran en toda la pantalla al azar y trataran de comerse a la tortuga.

La meta para el jugador, entonces, es controlar a la tortuga y comer todas las rebanadas de pizza mientras evade las serpientes.

Podemos empezar copiando todos los tres métodos de la clase Turtle (act, moveAndTurn, eat) en la clase Snake.

Haz esto usando copy y paste para remplazar el método act que está vacío por default en la clase Snake. Asegúrate de ver las llaves { } —El cuerpo de la clase aún necesita una llave que abra ‘{’ y otra que cierre ‘}’. En este punto, quizá quieras compilar y correr tu scenario para probar lo que hace. No es exactamente lo que queremos aún, pero hace algo. (Verás que las serpientes siguen tus presiones de tecla, exactamente como lo hace la tortuga.)

Hay dos cosas que nos gustaría cambiar en la clase Snake del comportamiento copiado de la tortuga. Primero, las serpientes deberían comer tortugas, no pizza. Y segundo, las serpientes deberían moverse por su cuenta (al azar), en lugar de ser controladas por el teclado.

Podemos hacer el primer cambio dirigiéndonos al método eat de la serpiente y reemplazando todas las menciones de “pizza” con “turtle”, como se muestra a continuación:

Presta atención a la capitalización: Letras mayúsculas y minúsculas deben ser usadas exactamente como se muestran. Cuando escribimos Turtle (con T mayúscula), nos estamos refiriendo a la clase Turtle. Cuando escribimos en minúsculas (turtle), nos estamos refiriendo a una variable.

Prueba tu scenario. Las serpientes deberían comer tortugas, no pizza.

Caminando al azar

En este momento, las serpientes siguen controladas por las mismas teclas que dirigen a las tortugas. Eso no es bueno. Podemos cambiar esto, primer haciendo a la serpiente correr en círculos.

Elimina el código del cuerpo del método moveAndTurn de la serpiente que implementa un giro controlado por teclado, y reemplazalo con una simple sentencia turn(3). El método debería verse ahora así:

Inténtalo. Las serpientes ahora se mueven por su cuenta (aún cuando es en un patrón muy predecible).
Ahora queremos hacer el movimiento más aleatorio. Para hacer esto, podemos usar un método de la clase Greenfoot llamado getRandomNumber. Este método va a darnos un número aleatorio entre 0 y el límite especificado. Por ejemplo, lo siguiente nos dará un número aleatorio entre 0 y 19 (el límite especificado en sí siempre es excluido):
Podemos usar este método para hacer las vueltas de las serpientes menos predecibles.Si usamos un número aleatorio como parámetro para el método turn (en lugar del número 3 que usábamos anteriormente), la serpiente debería caminar más aleatoriamente:
Si intentas esto, te darás cuenta de que la serpiente sigue moviéndose en círculo, aunque es un círculo algo irregular. La razón es que las vueltas—aún cuando tienen algo de aleatorias—son siempre vueltas a la derecha.

Para arreglar esto, necesitamos hacer a la serpiente girar a la izquierda también. Girar a la izquierda puede hacerse girando en un ángulo negativo. En lugar de girar entre 0 y 20 grados, nos gustaría girar entre menos 20 grados y 20 grados.

Podemos lograr esto con el siguiente cambio:

Eso es, primero obtenemos un número aleatorio usando 40 como el límite especificado, y entonces restamos 20 de él. El resultado estará entre -20 y 20. (En realidad, si piensas con cuidado sobre ello, esto es un tanto incorrecto. El resultado sería entre -20 y 19. ¿Puedes descubrir por qué? ¿Puedes corregirlo? No es realmente muy importante en nuestro contexto corregir esta ligera imprecisión—la serpiente se mueve erráticamente, así que un poco de tendencia no duele mucho.)

Intenta esta instrucción de giro (en lugar del anterior turn(3)) en tu propio código.

¡Verás que el juego de pronto se vuelve mucho más interesante!

Mejorando el juego

Hay muchas formas en las cuales podrías mejorar este juego. En lugar de hablarlo deberías probar algo de eso ahora mismo, te mostraré algo más útil: cómo puedes averiguar más por tu cuenta.

Hasta ahora, introdujimos varios métodos útiles que podemos usar, como move y turn en la clase Actor y getRandomNumber de la clase Greenfoot. Así que, ¿cómo descubrir que otros métodos están para usarlos?

La respuesta está en buscar la documentación de clase. Elige Greenfoot Class Documentation del menú Help de Greenfoot. Esto abrirá un explorador web que enlista todas las clases en el sistema Greenfoot. (Verás que hay seis clases: Actor, World, Greenfoot, GreenfootImage, GreenfootSound y MouseInfo.)

Da click en la clase Greenfoot para ver la documentación para esta clase. Si tú te desplazas un poco en la página, verás una lista d métodos disponibles en la clase. Están los métodos getRandomNumber e isKeyDown que ya hemos usado y un buen número de otros tantos.

El formato mostrado está en el llamado javadoc. Es un formato estándar para documentar métodos Java, y esto ayuda a determinar lo que clases particulares pueden hacer. La documentación incluye el tipo devuelto (lo que el método regresa cuando lo llamas), la firma (que es, el nombre y parámetros), y un comentario explicando lo que hace el método. Aquí, puedes averiguar todo acerca de otros métodos disponibles y cómo puedes llamarlos.

Por ahora, te dejaré explorar estos métodos por tu cuenta. (Las clases más interesantes para mirar inicialmente son Actor y Greenfoot.)

Tip: Puedes ver y descargar muchos programas Greenfoot Java en el sitio web de Greenfoot.

Conclusión

En este artículo, aprendiste unas cuantas cosas específicas acerca del código Java y algunos principios generales:

El código debe ser estructurado de manera que tengas métodos pequeños y cada uno haga una tarea lógica. (El método act en sí debería muchas veces contener sólo llamadas a otros métodos.)
Los números aleatorios se pueden usar para crear comportamiento aleatorio en nuestro programa (como movimiento aleatorio).
Puedes encontrar acerca de los métodos disponibles en las clases Greenfoot buscando en la documentación de clase Greenfoot.
La documentación de clase es provista en formato javadoc, el cual te muestra información acerca de todas las clases disponibles y acerca de cada método dentro de cada clase.

Y bien, eso es todo por este artículo, espero lo hayan disfrutado, no se pierdan los siguientes porque se añadirá más “inteligencia” a la serpiente y en el camino aprenderemos más de la clase World de Greenfoot.

Si no quieren perderse lo que sigue, pero tampoco pueden venir a revisar mis entradas cada que recuerden, lo ideal sería suscribirse vía mail, ¿cómo? Escribiendo su correo en la parte superior derecha de mi blog, donde dice “Noticias del blog a tu Email” dan click en “Submit” y de esa forma cada que suba una entrada tendrán un aviso en su bandeja de correo, y pues ya saben, criticas, dudas, peticiones o comentarios abajo, saludos.

Traducción: El Blog De Baro.

Escrito por: Michael Kölling.

Fuente: Java Magazine.

Entradas Relacionadas:
Aprender Java creando un juego (Parte 6)
Aprender Java creando un juego (Parte 5)
Aprender Java creando un juego (Parte 3)
Aprender Java creando un juego (Parte 2)
Aprender Java creando un juego (Parte 1)

Aprender Java creando un juego (Parte 3)

2012-09-25T14:26:00.000-07:00

Hola y buen día a todos mis lectores, esta es la tercera parte del proyecto para desarrollar el inicio de un juego para PC en lenguaje Java utilizando el entorno Greenfoot, (Parte1, Parte 2) aquí les va...

¿Qué comen las tortugas? ¡Pizza!

Lo siguiente, queremos dar a la tortuga algo que hacer: recolectar algo de comida y comerla. Para hacer esto, necesitamos algunos nuevos objetos en nuestro mundo: rebanadas de pizza. (Así es, nuestra tortuga come pizza. Ésta no es una lección de biología—Es un juego de computadora.)

¿De dónde vienen los objetos? De una clase. Así que primero, necesitamos crear una clase Pizza.

Damos click derecho en la clase Actor y seleccionar la función New Subclass. En la caja de dialogo resultante, ingresa Pizza como el nombre de la clase, y busca la imagen de la rebanada de pizza en la categoría food. Da click en OK.

Tan pronto como las clases son compiladas de nuevo, puedes añadir unas cuantas rebanadas de pizza (al igual que tortugas) a tu mundo.

Inténtalo. Deja a tu tortuga correr alrededor para recolectar pizza. Te darás cuenta, sin embargo, que la tortuga no come la pizza (aún). Solamente atraviesa la pizza. Arreglaremos eso ahora.

Dos tips

Si estás trabajando y experimentando en Greenfoot un poco, te habrás dado cuenta que necesitas re-crear todos los objetos en el mundo después de cada compilación. Esto se puede volver un poco tedioso después de un tiempo, especialmente si tenemos muchos objetos.

Aquí hay dos tips rápidos para hacer tu vida en Greenfoot un poco más fácil.

Puedes dar click + shift en el mundo. Éste es un atajo para crear un objeto de la clase que esté actualmente seleccionada en el diagrama de clase a la derecha.
Cuando todos los objetos están en el mundo como quieres que estén al inicio de tu juego, puedes dar click derecho en el fondo del mundo y seleccionar Save the World para guardar este estado del mundo. Este estado va entonces a ser re-creado automáticamente después de cada compilación o reset.

Detección de colisión

OK, tenemos pizza. Tenemos una tortuga. La tortuga está hambrienta.

La última parte qué hacer por hoy es hacer que la tortuga se dé cuenta cuando pasa por alguna pizza y hacer a la tortuga comer la pizza. Para esto vamos a necesitar lo que se llama collision detection (detección de colisión) para detectar cuando hemos pasado por alguna rebanada de pizza. El código completo para hacer esto se encuentra a continuación:

Este código debería ser agregado al final del método act en la clase Turtle. Hay varios nuevos elementos en este segmento de código. Vamos a verlos uno por uno.

La primera línea llama a un método Greenfoot: getOneIntersectingObject(Pizza.class). Este método revisa donde la tortuga interseca un objeto de la clase pizza (o, en otras palabras, pregunta, “¿Estamos tocando una rebanada de pizza?”). Si estamos tocando una rebanada de pizza, este método regresa el objeto pizza que encontramos. Si no, regresa un valor especial, null, que nos dice que no estamos tocando nada.

El símbolo de igual ( = ) en la primera línea es un operador de asignación. Almacena el resultado de nuestra revisión de colisión (el objeto pizza o null) en una variable. Una variable es una parte de almacenamiento donde podemos guardar objetos. En nuestro caso, la variable ha sido declarada usando la siguiente sentencia al inicio de la primera línea:

Esto declara una variable llamada pizza que puede sostener objetos Actor (objetos que viven en el mundo Greenfoot).

Después de la primera línea, la variable pizza sostiene el objeto pizza sobre el que pasamos, o sostiene null si no hemos pasado sobre una rebanada de pizza en este paso.
Ahora sigue otro ejemplo de una sentencia if. En pseudocódigo, el estado de las siguientes líneas sería el siguiente:

La revisión de condición es hecha con la siguiente expresión:

El símbolo != significa no igual. Por lo tanto, aquí estamos diciendo, “Si nuestra variable pizza no es igual a null…” El efecto es que la instrucción en el cuerpo de la sentencia if es ejecutada sólo si la variable pizza no es igual a null, eso es, si hemos pasado sobre alguna pizza.

La siguiente línea entonces elimina el objeto pizza del mundo. Se muestra a continuación la versión completa de nuestro método act en esta etapa.

Inténtalo. Una vez que hayas escrito este código, tu tortuga puede caminar alrededor y comer pizza:

Conclusión

En este artículo, aprendiste un poco más sobre escribir código Java, y acerca de algunos métodos útiles de Greenfoot.

Las sentencias if pueden ser usadas para ejecutar una acción solo bajo cierta condición.
Las sentencias if tienen una condición y un cuerpo. El cuerpo es ejecutado solamente si la condición es true.
El método Greenfoot.isKeyDown puede ser usado para revisar presiones de tecla.
El método Greenfoot.isKeyDown puede ser usado como la condición en una sentencia if.
La detección de colisión puede ser usada para revisar donde un objeto toca a otro.
Las variables son usadas para almacenar objetos.
El valor especial null es usado para indica que no tenemos un objeto.

Bien, eso es todo por ahora, pero próximamente tendremos mucho más de este interesante proyecto, no se lo pierdan porque pondremos a nuestra tortuga en la mira de un predador. No olviden comentar, compartir, hacer peticiones, plantear sus dudas o criticas abajo, con gusto daré respuesta, saludos.

Traducción: El Blog De Baro.

Escrito por: Michael Kölling.

Fuente: Java Magazine.

Entradas Relacionadas:
Aprender Java creando un juego (Parte 6)
Aprender Java creando un juego (Parte 5)
Aprender Java creando un juego (Parte 4)
Aprender Java creando un juego (Parte 2)
Aprender Java creando un juego (Parte 1)

Aprender Java creando un juego (Parte 2)

2012-09-25T10:07:00.000-07:00

Buen día a todos mis lectores, hoy, les tengo un tema muy interesante, como ya habrán visto en las letras grandes de arriba, se trata de cómo iniciar nuestro primer juego de computadora en Java en el entorno Greenfoot, este articulo es la segunda parte de un proyecto de varias partes, para ver la primera click aquí , les dejo la información...

Tener un gráfico animado en pantalla en la primera parte es bastante bueno, pero se pone aburrido después de un rato si no puedes hacer nada más con él, así que hoy, te diré como añadir interacción con el teclado (eso es, cómo controlar el movimiento de tu tortuga usando teclas), que quizá sea el primer paso en un pequeño juego de computadora.

Comenzando

Cuando dejamos el método act de nuestra tortuga la última vez, se miraba así:

Observamos que esto causaba que la tortuga corriera en un círculo, porque el método act es repetidamente ejecutado cuando el programa corre:

Ahora, queremos que cada tortuga vaya en línea recta cuando no presionamos nada en nuestro teclado y que gire a la derecha o izquierda si presionamos las teclas de dirección de derecha o izquierda.

Para lograr esto, necesitamos dos cosas:

Necesitamos poder revisar cuando una tecla ha sido presionada.
Necesitamos tener una sentencia en Java que nos permita ordenar que queremos girar la tortuga sólo si la tecla de dirección derecha o izquierda ha sido presionada.

Revisando si se ha presionado una tecla

Greenfoot tiene un método, llamado isKeyDown, que nos permite revisar cuando se ha presionado cierta tecla. Éste método está en la clase Greenfoot. Podemos, por ejemplo, escribir lo siguiente para revisar cuando la tecla de dirección izquierda está siendo presionada:

El parámetro (dentro del paréntesis) es el nombre de la tecla que queremos revisar. Las teclas alfabéticas tienen el nombre de su carácter como su nombre (por ejemplo, la tecla A es llamada a, la tecla B es llamada b, y así sucesivamente). Las teclas especiales de control tienen nombres indicando lo que son; por ejemplo, left (izquierda en español) es el nombre de la tecla de dirección izquierda y—como habrás adivinado—right (derecha en español) es el nombre de la tecla de dirección derecha. El método isKeyDown, cuando se le llama, va a responder con un valor ya sea true (verdadero, la tecla de dirección izquierda se ha presionado) o false (falso, la tecla no está siendo presionada).

Una Sentencia if

La segunda parte que necesitamos para hacer que nuestro plan funcione es una sentencia que nos permita ejecutar una acción (en nuestro caso, girar) sólo durante ciertas condiciones (cuando la tecla de dirección derecha o izquierda es presionada). Esto es llamado una sentencia if. Una sentencia if tiene la siguiente forma general:

Cuando una sentencia if es ejecutada, revisa la condición, y entonces ejecuta solamente las sentencias que están entre sus llaves { } si la condición es true. (Incidentalmente, quizá sea bueno introducir una terminología más profesional: La parte de la sentencia if que contiene las sentencias—sus llaves { } y todo lo que esté entre ellas—se llama el cuerpo de la sentencia if.) El cuerpo quizá contenga una secuencia completa de sentencias si eso es lo que queremos.

Si la condición es false, el cuerpo es solo ignorado, y la ejecución continúa después de la sentencia if (y sus llaves).

Girando la tortuga al presionar una tecla

Con estos dos puntos reunidos, ahora podemos hacer lo que necesitamos. Necesitamos escribir lo siguiente:

Este no es código Java real (se llama pseudocódigo).

Ahora podemos llenar el pseudocódigo con código Java real:
Este código ahora indica que vamos a girar menos 3 grados durante cada ciclo act en el cual la tecla de dirección izquierda (left) esté siendo presionada. (Noten que podemos usar un ángulo negativo para girar a la derecha.)

Haciendo lo mismo para la tecla de dirección derecha (right) para girar a la derecha es ahora simple. Solamente escribimos una sentencia similar nuevamente, pero esta vez girando 3 grados para la tecla de dirección derecha. El nuevo método completo act se muestra a continuación:
Pruébalo. Compila tus clases, pon una tortuga en el mundo, y corre el scenario.

Ahora puedes controlar una tortuga en tu pantalla con las teclas de dirección. ¡Bastante divertido hasta ahora!

Actualmente, la tortuga continuamente va a caminar hacia adelante. Si tú quieres, puedes cambiar tu código para que la tortuga se mueva hacia adelante sólo cuando presiones la tecla de dirección arriba. Podrías hacer eso añadiendo otra sentencia if alrededor de la sentencia move(4). El nombre de la tecla de dirección arriba es up.

Y bueno, eso es todo por esta entrada, pero no para el proyecto, en la siguiente entrada veremos cómo darle algo que hacer a nuestra tortuga: ¡Comer! Espero hayan disfrutado este artículo y “nos vemos” en el siguiente, saludos.

Traducción: El Blog De Baro.

Escrito por: Michael Kölling.

Aprender Java creando un juego (Parte 1)

2012-09-24T14:50:00.000-07:00

Buen día a todos mis lectores, hoy les tengo la primera parte (Parte 2 aquí) de un interesante proyecto de varias partes, se trata del inicio de un pequeño juego para computadora, lo mejor de todo, es que está diseñado para aprender los conceptos básicos de la programación orientada a objetos, así que si eres principiante en Java ¡Esto es perfecto para ti! No se necesitan conocimientos avanzados del lenguaje ni de la programación orientada a objetos (POO) en general, aquí les va...

En este articulo, vamos a saltar directos a comenzar nuestra propia clase. En el proceso, vamos a aprender acerca de objetos, métodos y parámetros.

Prerrequisitos

Para poder continuar, necesitarás que el siguiente software esté instalado en tu computadora:

Plataforma Java (Descargar), Edición estándar (Java SE por sus siglas en inglés)
Greenfoot versión 2.1.0 o una más nueva. Asegúrate de que tengas una versión suficientemente buena de Greenfoot. Puedes revisar la versión que tienes usando el artículo de menú About Greenfoot.

Creando nuestro propio proyecto

Greenfoot llama a sus proyectos scenarios. Así que la primera cosa que haremos, es crear un nuevo scenario.

Inicia Greenfoot.
Greenfoot usualmente abre el último scenario en el que trabajaste. Ciérralo seleccionando la función Close del menú Scenario.
Selecciona New del menú Scenario.
En la caja de dialogo New Scenario, pon de nombre turtle al nuevo scenario y da click en OK.

Deberías ahora tener una nueva ventana scenario que es principalmente gris, como se muestra a continuación:

Ahora tenemos el caparazón de un nuevo scenario, un lugar donde podemos empezar a trabajar. No tenemos un mundo aún para hacer que cosas pasen en él, y no tenemos actores que puedan hacer cosas.

Las dos clases que se ven en el lado derecho de la ventana, World (Mundo en inglés) y Actor, son superclases. Ellas no son ni un mundo especifico ni un actor especifico, son mejor dicho descripciones de todos los mundos y actores posibles.

Vamos a crear un mundo específico y actores creando subclasses de éstas. Las subclases representan especializaciones de las superclases. Vamos a comenzar haciendo un mundo.

Creando un nuevo mundo

Da click derecho en la clase World (La caja color beige) y selecciona la función New Subclass.

Una caja de dialogo nos pide un nombre y una imagen para la nueva clase como se muestra a continuación:

Nombra a tu clase TurtleWorld, y selecciona una imagen de la categoría Backgrounds de la librería de imágenes. Para los pantallazos en este artículo, se seleccionó una imagen de fondo llamada weave.jpg.
Da click en OK entonces click en el botón Compile en la ventana principal de Greenfoot. Deberías ver aparecer un mundo en la ventana Greenfoot con tu fondo seleccionado como se ve a continuación:

Ahora que hemos creado un mundo, estamos listos para crear actores para ponerlos dentro del mundo.

Una Nota Lateral Sobre Compilar

Cuando programamos, escribimos código Java. Desafortunadamente, las computadoras no pueden ejecutar el código Java directamente. Necesitan sus instrucciones en un lenguaje de máquina especializado.

Afortunadamente, hay una solución fácil: El compilador. Un compilador es un software que puede trasladar código Java en lenguaje máquina. Cada vez que creamos una nueva clase o haces cambios al código fuente de una clase existente, la clase necesita ser trasladada nuevamente a lenguaje máquina. Puedes hacer esto fácilmente dando click en el botón Compile.

En Greenfoot, una clase aparece a rayas si no ha sido compilada desde el último cambio como se muestra a continuación:

Una vez que damos click en el botón Compile y la clase es trasladada, las rayas desaparecen, y la clase está lista para usar:

Creando un actor

Ahora tenemos un mundo en el que nuestros actores pueden vivir. De todas formas, no tenemos un actor para hacer nada aún. Así que vamos a hacer un actor.

Click derecho en la clase Actor y selecciona la función New subclass.
En la caja de dialogo resultante, nombre la nueva clase Turtle, y selecciona la imagen turtle2.png de la categoría Animals como se muestra en la imagen (bajo el punto 4).
Click OK. Ahora tenemos una nueva clase Turtle en nuestro scenario. Nota que esta clase está inicialmente rayada (eso significa, sin compilar).
Click en el botón Compile para compilar la clase.

Nota que por convención, los nombres de las clases Java siempre comienzan con letra mayúscula.

Creando Objetos

Ahora tenemos una clase actor (Turtle), pero no tenemos objetos actor todavía. Click derecho en la clase Turtle y selecciona new Turtle(). Esto crea un objeto tortuga—que es, un actor real—el cual se puede poner entonces en el mundo.

Eso es. Acabas de crear tu primera tortuga. Nota que se pueden crear tantas tortugas como quieras. Haz la prueba.

Programando tus objetos

Click en el botón Run. Notarás que nada pasa al presionar tal botón, nuestra tortuga sólo se sienta ahí, sin hacer nada. Eso es porque no hemos programado a nuestra tortuga para que haga algo. Así que aquí es donde la diversión comienza. Vamos ahora a comenzar a programar en Java para hacer a la tortuga actuar.
Abre el editor para Turtle haciendo doble click en la caja de clase Turtle. Verás algo de código para la clase Turtle como se muestra a continuación:

Nos vamos a concentrar en el método act. Ésa es la parte del código que se ve así:

Esta parte del código especifica lo que la tortuga hace cuando actúa. El código entre las llaves { } es ejecutado cada vez que la tortuga actúa. En este caso, todo lo que está escrito aquí es lo siguiente:

// Add your action code here.

La doble barra al inicio de la línea marca esta línea como un comentario. Es ignorado por el sistema Java y es sólo un recordatorio para el programador humano. En otras palabras, este método act no contiene código alguno. Ése es el porqué de que nuestra tortuga no haga nada.

Vamos a cambiar eso.

Reemplazar el comentario con una instrucción de tal manera que nuestro método act se mire así:
Compila, crea una nueva tortuga, y trata de dar click en el botón Act y en el botón Run.
Así que, ¿qué acabamos de hacer?
La instrucción move(2); le dice a la tortuga que se mueva 2 pixeles adelante. La tortuga hace esto cada vez que actúa. Cuando das click en el botón Act, el método act es ejecutado una sola vez, así que la tortuga se mueve un poquito (2 pixeles) a la derecha. Dando click al botón Run se llama al método act una y otra vez (hasta que lo pauses otra vez), así que la tortuga se sigue moviendo.
Experimenta con valores diferentes de 2. ¿Qué pasa cuando usamos 20 en lugar de 2?
Trata con otra instrucción reemplazando la instrucción move(2); con esta instrucción:

Recuerda: Cambia el código, compila, crea una nueva tortuga, y entonces ejecuta (Run). Experimenta con diferentes valores aquí también.

Métodos y Parámetros

Así que, ¿qué acabamos de hacer?

Hemos llamado (o invocado) a un método llamado move y a un método llamado turn, y hemos pasado un parámetro, 2, para cada uno de ellos.

Un método es un poco del comportamiento que un objeto sabe ejecutar, y todos los actores conocen los métodos move y turn (quiere decir que ellos saben cómo moverse y girar).

Ambos métodos esperan un parámetro, el cual es un poco de información adicional que les dice exactamente qué tan lejos moverse o qué tanto girar. Amos métodos esperan un numero como parámetro, y nosotros suplimos ése número escribiéndolo entre paréntesis después del nombre del método. Y cada instrucción en Java es finalizada con un punto y coma (;).

Errores

Quizá te hayas dado cuenta que necesitas escribir el código muy precisamente. Teniendo siquiera un carácter mal hace que el programa completo no trabaje. El compilador entonces reporta un mensaje de error, y necesitas arreglar el código. Si no has visto un mensaje de error aún, trata ahora. Por ejemplo, borra el punto y coma (;) después de tu instrucción y trata de compilar. Verás a lo que me refiero.

Secuencias de instrucciones

Puedes escribir múltiples instrucciones, tantas como quieras, en el método act. De hecho, puedes escribir una tras otra:

Intenta esto. Además, pon varias tortugas en el mundo, y experimenta con diferentes valores en los parámetros para los métodos move y turn:

Resumen

En este artículo, aprendimos los primeros pasos para escribir tu propio código Java, que demuestran los siguientes principios:

Que el comportamiento de un objeto está especificado en la clase del objeto.
Más precisamente, el comportamiento de un objeto está especificado en una definición de método en la clase del objeto.
Las clases Actor en Greenfoot tienen un método llamado act que especifica su comportamiento principal.
El cuerpo del método (la parte entre las llaves { } ) contiene el código que determina que hace el método cuando es llamado.
Las instrucciones pueden ser especificadas llamado a los métodos existentes (como move y turn en nuestro ejemplo).
Las llamadas a los métodos consisten del nombre del método que estás llamando seguido por parámetros en paréntesis.
Todas las instrucciones son terminadas con un punto y coma (;).
Podemos además escribir secuencias de instrucciones.

Y bien, esto es todo para la primera parte de este interesante proyecto, no tardo en subir las demás, cualquier duda, comentario, petición o critica, en la parte de abajo, saludos.

Traducción por: El Blog De Baro.

Escrito por: Michael Kölling.

Cómo instalar SQLITE en Eclipse IDE

2012-09-18T11:18:00.001-07:00

Hola y buen día a todos mis lectores (Que no son muchos) hoy veremos cómo instalar la librería de SQLITE para trabajar en Eclipse (y con Eclipse me refiero al entorno de desarrollo, no a la película), pero primero veamos qué es SQLITE...

SQLITE es una librería que implementa un motor de base de datos SQL con varias ventajas, por ejemplo, no es necesaria configuración o administración, es multiplataforma, portable, no necesita servidor (Aunque puede usarse con PHP) y lo mejor: ¡Es de dominio público! :D. Es utilizado en aplicaciones muy conocidas como por ejemplo en el sistema operativo para dispositivos móviles Google Android, otro ejemplo es el muy conocido antivirus Avast!, así que si ellos utilizan esta librería ¿porqué nosotros no?.

Otros puntos a favor de SQLITE son: Que es extremadamente fácil de usar, que no hay casi ninguna diferencia entre SQL, MySQL o SQLITE (Descargar tutorial SQL en PDF) ya que se basa en el estándar SQL92 (Para ver características no soportadas por SQLITE click aquí) y otro punto muy importante es que es más rápido que la mayoría de los motores de base de datos Cliente/Servidor en las operaciones más comunes por lo tanto es ideal para aplicaciones Java, grandes o pequeñas que requieran una base de datos.

Ahora, los pasos necesarios para instalar la librería en nuestro proyecto de Eclipse IDE (Descargar Eclipse IDE) y comenzar a trabajar con la misma:

Primero que nada, obviamente necesitamos descargar la librería de SQLITE.

Ya en nuestro proyecto, damos click secundario en donde dice JRE System Library[etc] buscamos la opción Build path y luego Configure build path así como se muestra en la imagen:

Veremos un dialogo como el que se muestra abajo y daremos click en el botón que está rodeado en rojo “Add external jars”:

Seleccionamos la carpeta donde tenemos nuestra librería y damos click en “Abrir” o doble click como se muestra a continuación:

¡Y listo! Si todo salió bien, veremos en nuestro proyecto el archivo .jar que acabamos de agregar como se muestra en la imagen:

En mi próxima entrada veremos (Ahora sí) cómo trabajar con esta librería en Java e incluso dar la opción al usuario de donde guardar el archivo de base de datos, como siempre, espero que hayan disfrutado la entrada, no duden en poner comentarios, criticas o dudas abajo, saludos.

Entradas Relacionadas:
Utilizando SQLITE en Java

Escribir un archivo de texto en Java

2012-09-12T10:24:00.000-07:00

Las entradas y salidas en Java pueden llegar a ser algo confuso para programadores que vienen de otros lenguajes como Visual Basic, C++, etc. También claro para quienes comienzan a aprender de este tema en Java, pero en realidad llega a ser algo muy sencillo de utilizar cuando lo aprendemos de la manera correcta, veremos una introducción al tema de Entradas y Salidas (I/O) en otro artículo, pero ahora sólo voy a escribir a cerca de como crear un simple archivo de texto en Java (Para aprender como leer archivos de texto en Java click aquí), ahí vamos...

Digamos que quiero crear un archivo de nombre "nota.txt" con el texto "Hola mundo" dentro:

Otra cosa muy importante es que después de llamar al método close() no tratemos de escribir en el archivo con el método write() ya que esto va a generar una excepción, aunque yo recomendaría no usar nuevamente el escritor de archivo una vez llamado al método close() para nada más ya que puede tener resultados inesperados.

Ahora, si vamos a la carpeta que nos devolvió user.home (en mi caso) "C:\Documents and Settings\Gustavo" encontraremos un archivo llamado nota.txt y al abrirlo encontraremos el texto: "Hola mundo".

Espero hayan disfrutado de esta entrada, cualquier duda, comentario o critica pueden ponerlo abajo y con gusto les daré respuesta, saludos.

Entradas Relacionadas:
Leer un archivo de texto en Java
Entradas y Salidas en Java - Lo básico

Bienvenida

2012-09-12T08:17:00.000-07:00

¡Bienvenido al blog de Baro!

Éste blog está dedicado a las personas interesadas en aprender programación orientada a objetos (POO) en lenguaje Java SE, utilizando el entorno de desarrollo (IDE) Eclipse y algunas librerías interesantes, veremos algunos ejemplos de entradas y salidas (I/O), conexión a base de datos, etc. Para la programación de interfaces gráficas (GUI's) no se utilizarán plugins ya que a mi criterio, es mucho mejor saber como hacerlo "a mano" antes de utilizar herramientas para ello, espero que mi blog sea de su agrado, no olviden compartir las entradas que les gusten, saludos.