greenfoot – Digital Learning

Programando en Java con Greenfoot

DL — Sun, 05 Aug 2012 20:28:32 +0000

En el anterior post, donde explicábamos conceptos básicos de la POO como las clases, objetos, métodos y atributos, nos apoyamos principalmente en el interfaz visual que nos ofrece Greenfoot. En este artículo, vamos a entrar un poco más a fondo y explorar el programa Java que estamos creando con la ayuda de esta herramienta.

Para ello, con el proyecto abierto, nos situamos en la clase wombat en el diagrama de la derecha. Hacemos que aparezca el menú contextual (botón derecho del ratón) y elegimos ‘Abrir el editor‘. Lo que vemos es el código escrito en lenguaje Java que define esta clase.

Si tienes muy poca experiencia en programación quizás te resulte casi incomprensible, pero analizando por partes verás que no es tan difícil de entender.

En una primera revisión, como podemos ver en la imagen de abajo, se distinguen varias secciones enmarcadas con recuadros de distintos colores que explicaremos a continuación:

* Importación de clases: es la sección inicial, en fondo blanco. Mediante la cláusula ‘import‘, podemos incluir las clases que necesitemos en nuestro programa para que todo funcione correctamente. Las clases suelen encontrarse agrupadas de forma lógica en librerías o packages(paquetes). Un paquete es por tanto un conjunto de clases ya construidas que podemos utilizar en nuestra aplicación, lo que nos ahorra programar todas las funcionalidades desde cero:

import greenfoot.*;  // (World, Actor, GreenfootImage, and Greenfoot)
import java.util.List;
import java.util.ArrayList;

En el apartado ‘la API de Java’, en este mismo artículo, te explicamos más en detalle estos conceptos.

* Declaración de la clase: es el bloque donde definimos la clase Wombat en sí y que está delimitada visualmente por un cuadro verde. Comienza con unos comentarios (qué hace la clase, su autor, versión…), cuyo inicio y final se marcan con los caracteres ‘/* ‘ y ‘*/’ (es muy recomendable incluir comentarios a lo largo del programa para hacer más entendible nuestro código) y continúa con:

public class Wombat extends Actor
{ ...............
...............

la expresión public class Wombat extends Actor’ la podríamos traducir literalmente por ‘la clase Wombat extiende la clase Actor , y encierra uno de los elementos fundamentales de la POO, la herencia. Explicaremos más detenidamente el concepto de herencia en un siguiente apartado en este artículo, pero básicamente estamos diciendo que creamos la clase Wombat (más específica) a partir de la clase Actor (más genérica) ‘heredando’ o teniendo disponibles sus atributos y métodos.

El término public es un modificador de acceso y define a esta clase como pública, siendo accesible por tanto por cualquier otra clase. Por defecto, si no incluímos ningún modificador (default), solo sería accesible por clases que están incluídas en su paquete.
Hay otros dos modificadores de acceso, que al igual que los anteriores, también son aplicables a los métodos y a los atributos: protected (similar a default aunque permite heredar a una subclase que no está en el paquete ) y private (si queremos que los métodos o atributos sean solo accesibles dentro de la clase). Si quieres saber más, puedes consultar este artículo sobre modificadores Java.

El código que define la clase se encierra entre llaves ‘{‘ y ‘}’ ‘. Vemos que a su vez tiene bloques diferenciados, Vamos a analizarlos:

* Declaración de atributos: es el recuadro inicial en fondo blanco:

private static final int EAST = 0;
private static final int WEST = 1;
private static final int NORTH = 2;
private static final int SOUTH = 3;

private int direction;
private int leavesEaten;

El grupo de los cuatro primeros: EAST, WEST, NORTH y SOUTH, son las direcciones a las que puede orientarse el Wombat. Son de tipo entero (int) y se han definido de forma que actúan como constantes para cualquier objeto Wombat al tener los modificadores final y static. El primero no permite que se modifiquen sus valores (0,1,2 y 3),y el segundo las define como variables de clase, es decir, no es necesario crear un objeto para utilizarlas. Recordemos en el anterior post el efecto que producía pasar uno de estos números como parámetro al método setDirection(int direction). ¡Hacían que el Wombat se girará a derecha, izquierda, arriba o abajo !. El otro modificador (private) indica que solo son accesibles dentro de la clase.

El grupo de los dos siguientes atributos, direction y leavesEaten, son variables de instancia y almacenarán la información en formato entero (int) de la dirección y las hojas que han comido cada uno de los objetos Wombat que creemos (instanciemos) a partir de esta clase. Se les denomina también campos y toman valores particulares a nivel de objetos.

* Constructor: es el proceso que crea un objeto a partir de una clase y que se ejecuta automáticamente cada vez que instanciamos un objeto (al seleccionar new WombatWordl, new Wombat() ó new Leaf()).
Su código aparece en el recuadro amarillo justo debajo de la definición de atributos:

public Wombat()
{
setDirection(EAST);
leavesEaten = 0;
}

Tiene la misma estructura que un método aunque con algunas particularidades: debe tener siempre el mismo nombre que la clase y no tener ningún return type.

No es necesario declarar siempre un constructor, ya que toda clase tiene uno que inicializa los campos del objeto con valores por defecto. Si queremos personalizar ese proceso de creación, entonces podemos escribir uno o varios constructores, a los que a su vez podemos pasar o no parámetros. Por ejemplo, en este caso, el constructor inicializa los campos direction con el valor ‘EAST’ y leavesEaten con el valor ‘0’.

* Métodos: todo el código restante de esta clase, son las definiciones de sus métodos. Cada uno aparece en un recuadro amarillo, con una estructura muy parecida:

Comentario indicando que realiza ese método
Declaración del método: ‘public void act()‘, ‘public boolean foundLeaf()‘, ‘public void eatLeaf()‘,…
encerrados entre llaves {}, las instrucciones que han de ejecutarse

Aunque no podemos entrar en detalle de todo el código, vamos a revisar por ejemplo el primer método que aparece: act()

public void act()
{
if(foundLeaf()) {
eatLeaf();
}
else if(canMove()) {
move();
}
else {
turnLeft();
}
}

Sabemos por un post anterior, que la palabra reservada void nos indica que el método no devolverá ningún valor. Interpretando o traducciendo del inglés el código encerrado entre las llaves, vemos que hay una estructura condicional:

if(condición 1) {
instruccion 1…..
}
else if (condición 2) {
instrucción 2
}
else {
instrucción 3
}

If, es el ‘si’ condicional en inglés y el ‘else’ nos permite evaluar una alternativa. Podríamos leer todo este código literalmente como:
“si se cumple la condición 1, ejecuta la instrucción 1, si en cambio se cumple la condición 2, ejecuta la instrucción 2 y en cualquier otro caso (no se cumple ninguna de las dos anteriores), ejecuta la instrucción 3”

¿Qué condiciones e instrucciones hay? Pues vemos que son precisamente llamadas a otros métodos de este mismo objeto. Si seguimos traduciendo literalmente sería algo así como:

“si se cumple la condición ‘he encontrado una hoja’, ejecuta ‘comer hoja’, si en cambio se cumple la condición ‘puedo moverme’, ejecuta la instrucción ‘mover’ y en cualquier otro caso, ejecuta la instrucción ‘gira a la izquierda’ ”

Si queremos cambiar el comportamiento de los Wombat que creemos, solo tenemos que modificar los métodos adecuados. Lo iremos viendo en próximos posts, pero puedes practicar un poco con cambios sencillos. Por ejemplo, si modificas este método act() en su primer condicional de forma que añadas llamadas a los otros dos métodos de la forma:

if(foundLeaf()) {
eatLeaf();
turnLeft;
move(3);
}

¿qué ocurrirá cuando el Wombat encuentre una hoja? Es fácil de adivinar ¿verdad?. Prueba las variantes que quieras y no olvides compilar siempre después de realizar los cambios. Puede ser buena idea que al hacer el primer cambio guardes el proyecto con otro nombre (save as…) y continuar ya con éste, de forma que mantegas el proyecto y código original de referencia.

La API de Java

Si analizamos más en detalle el primer bloque, vemos que estamos importando las clases List y ArrayList que están contenidas en el package java.util. Estos paquetes están organizados de forma jerárquica a modo de directorios/carpetas, agrupando clases relacionadas entre sí y la notación ‘.’ nos indica que estamos descendiendo en la jerarquía de esa estructura. La librería java.util se suministra en el entorno de desarrollo Java SE que si recordamos, instalamos al inicio. Podemos ver todo el conjunto de paquetes disponibles para la versión 7 en lo que se denomina la API de Java: http://docs.oracle.com/javase/7/docs/api/index.html

Si accedemos a ella, podemos pinchar en cualquier package y nos mostrará todas las clases que contiene. Por ejemplo en java.util, veremos que tanto List como ArrayList son dos interfaces (una construcción en Java similares a las clases que veremos más adelante). Si pinchamos a su vez en cualquiera de ellas, nos mostrará todos sus métodos y los detalles de implementación. Esta documentación es de gran utilidad, con miles de clases y sus métodos correspondientes. Es una herramienta con la que un programador Java debe familiarizarse para localizar clases y métodos que puedan tener funcionalidades que necesite para su programa y saber cómo utilizarlas.

Por defecto, en cualquier clase que construyamos se incluirá el package java.lang, que contiene clases fundamentales para el funcionamiento de cualquier programa Java. En concreto, el paquete java.lang,contiene la clase Object, que es la superclase de todas las clases existentes en Java, es decir la que se encuentra en la raíz de esta estructura jerarquica.

La otra libreria que importamos es la de Greenfoot. Esta es una colección de clases que han sido desarrolladas por los creadores de este entorno para facilitar la creación de los juegos y simulaciones.

En este caso no viene incluída en el Java SE 7, sino que se instalan con el propio programa, y la denominaremos API de Greenfoot. También podemos acceder a su documentación con información muy valiosa sobre las clases que contiene (descripción de su funcionalidad, métodos y atrbutos) en: http://www.greenfoot.org/files/javadoc/

Herencia

El mecanismo de herencia de la POO facilita la creación de una nueva clase a partir de una ya existente. Esta nueva clase tendrá (heredará) los atributos y métodos de la anterior, pudiendo mantener o modificar dichos elementos o añadir unos nuevos si así lo necesita, para que se adapten a sus características y comportamiento particulares (recordemos la expresión ‘extiende a…’).

Si nos fijamos en las flechas del diagrama de clases que nos aparece en el lado derecho del proyecto Wombat, veremos que nos indican la jerarquía o relaciones de herencia entre ellas. Decimos que ‘la clase Actor es padre o es una superclase de las clases Wombat y Leaf(hoja)’ o viceversa, ‘Wombat y Leaf son subclases o clases hijas de la clase Actor‘. Estamos indicando que ésta es más genérica que las clases Wombat o Leaf y que hay una relación ‘is-a‘ (‘Wombat es un Actor’, ‘Leaf es un Actor‘).

Un aspecto que debemos tener en cuenta es que estas relaciones de jerarquía deben tener sentido, pero no tienen que ser idénticas y recrear todas las que existen en el mundo real. Ya comentamos que en la POO, modelamos una situación que queremos tratar con nuestro programa en base a abstracciones esquemáticas (clases) que van a sernos útiles en ese contexto. En el mundo real, existiría, de manera simplificada, la relación de herencia: Animal –> Mamífero –> Wombat, pero en el contexto del juego que estamos creando, esas características (animal, mamífero) no son relevantes. Preferimos crear una clase Actor que define a cualquier elemento que podemos poner en el juego para que ‘actúe’ (juegue). La clases en este caso modelan los ‘roles’ que van a desempeñar los objetos.

Para ver como funciona todo esto en Greenfoot, podemos hacer una prueba. Elige con el ratón la clase Actor y en el menú contextual (botón derecho ratón) elige ‘Nueva subclase‘. Puedes crear la que quieras, por ejemplo Roca, y elegir la imagen ‘rock.gif’. Verás que aparece en el diagrama de clases, al mismo nivel que Wombat y Leaf. Compila el escenario (botón en la parte inferior derecha) y si abres el editor de código, ¿qué características tiene esta nueva subclase?. Como ves solo cuenta con el método act(), pero si creas un objeto Roca con newRoca() y la situas en el cuadrado del juego, puedes seleccionarla y con el menú contextual ver que en la opción ‘heredado de Actor‘ aparecen muchos otros métodos. Si eliges por ejemplo move(), y pones ‘3’ en el cuadro de diálogo que te aparece a continuación, ¡la roca se mueve tres cuadrados a la derecha!. Es decir, funciona un método que no veíamos en el código de esta clase al haberlo heredado de su superclase Actor.
¿Qué ocurre con los atributos?. Si seleccionas en la clase la opción ‘Inspeccionar’ del menú contextual verás que dice que no hay, lo que indica que la clase Actor no tiene variables de clase. Si haces lo mismo en el objeto Roca que creamos antes, verás que sí aparecen una serie de variables de instancia (objeto) como son su posición en los ejes X e Y. Arrastra la roca a otra celda y verás como los valores de esas variables van cambiando.

Si quieres, puedes dar un paso más y crear ahora una subclase de Wombat. Por ejemplo Hormiga. Si sigues los mismos pasos que antes verás que ahora sí aparecen las variables de clase EAST, WEST, NORTH y SOUTH y al seleccionar un objeto Hormiga en el cuadro de juego comprobarás que ahora no solo hereda todos los métodos de Actor, sino también de Wombat. En ese mismo objeto, al inspeccionar los atributos, aparecerán también las variables de instancia ‘direction‘ y ‘leavesEaten‘.

Clases y Objetos. Java y POO con Greenfoot

DL — Wed, 25 Jul 2012 12:00:43 +0000

Tras ver en el anterior post la instalación del entorno de programación visual Greenfoot, vamos a empezar a trabajar con él. Crearemos un juego muy simple que nos servirá a su vez para familiarizarnos con los conceptos de clases y objetos, que son básicos en de la Programación Orientada a Objetos (POO) y por supuesto en Java.

En primer lugar vemos que al abrir un escenario, por ejemplo el ‘Wombat’, y tras dar al botón de compilar en la parte inferior derecha no aparecen la siguiente pantalla, que será nuestra interfaz visual donde editaremos y ejecutaremos nuestros programas:

Se divide en tres partes principales:

El Mundo, que es el cuadrado con retícula de color arena que nos aparece en la izquierda. Es donde pondremos los objetos y donde se desarrollará el juego o simulación que programemos. Variará su apariencia en función del escenario que carguemos, ya que cada uno tiene un Mundo por defecto (en este caso es ‘WombatWorld“) y éste a su vez tiene una imagen de fondo que podemos cambiar fácilmente como veremos más adelante.
El Diagrama de Clases, en la parte derecha. Ahí nos aparecen tanto las clases de Mundo que tenemos disponibles y las clases de Actores (‘Wombat‘ y ‘Leaf’) a partir de las cuales crearemos los objetos que incluiremos en el mundo elegido.
Los botones que aparecen en la parte inferior y que nos permiten ejecutar una serie de acciones que veremos a continuación.

Si posicionamos el puntero del ratón en la clase Wombat y pulsamos el botón derecho para que apareca el menú contextual, obtendremos lo que aparece en la imagen de la derecha.

Si elegimos la opición ‘new Wombat()‘ estaremos creando un objeto a partir de esa clase, apareciéndonos una imagen de este animal que podremos arrastrar y posicionar en el mundo que tenemos a la izquierda (imagen de abajo).

Podemos crear tantos objetos como queramos a partir de la clase Wombat, y podemos hacer lo mismo con la clase Leaf (hoja), posicionando todos esos objetos en el cuadrado de la izquierda.

A la acción de crear objetos se le denomina instanciar (un objeto es una instancia de una clase). A partir de ahí, ya podemos interactuar con ellos.

Una clase es una especie de plantilla o molde a partir de la cual podemos crear objetos.

Para desarrollar un programa en Java, o utilizando en general el enfoque POO, descomponemos el sistema que estamos estudiando en ‘cosas’ (objetos), ya sean tangibles, físicas, cómo es el caso de los wombats y las hojas, o conceptuales, representando una idea, como sería el mundo de nuestro escenario. Estos objetos (con)tendrán datos y comportamiento, como veremos un poco más adelante.

Un programa en Java se compone por tanto de un conjunto de clases que modelan ese sistema que queremos implementar. Todo el código del programa está contenido en esas clases.

En este paradigma de la POO, los sistemas se conciben como un conjunto de objetos que cooperan e interaccionan entre sí. Es una filosofía de diseño que difiere de la programación estructurada, donde los sistemas se descomponen en una colección de procedimientos y se piensa más en términos de procesos, instrucciones o algoritmos.

Pasamos a la acción

Si pulsamos el botón accionar, veremos que el (o los) wombat que hayamos creado se moverán una celda hacia la derecha mientras que las hojas permanecen quietas. Si pulsamos el botón ejecutar (run si lo tienes en versión inglesa), los wombats seguirán moviéndose celda a celda hacia la derecha con dos particularidades: si encuentran una hoja, ésta desaparece (se la come!) y si llegan a los límites del mundo (los lados del cuadrado), girán 90 grados y continuan en esa nueva dirección.

¿Por qué hacen cosas los wombats y no las hojas (leaf)? Lógicamente porque está así programado. Si nos posicionamos en un wombat situado en la cuadrícula y accedemos al menú contextual (botón derecho ratón) nos aparecerá una lista de métodos, tal como vemos en la imagen de la derecha. Descubriremos más adelante, cuando inspeccionemos el código Java, que los métodos son un conjunto de instrucciones que hacen una determinada tarea, al estilo de las funciones que utilizamos en la programación estructurada.
Podemos adivinar más o menos de que se trata por sus nombres en ingles: act (actuar), eatLeaf (comer hoja), … Si pulsamos en cualquiera de ellos, ese objeto wombat ejecutará la operación correspondiente. Por ejemplo, con move(), se moverá un cuadro a la derecha, con turnLeft(), se girará a la izquierda.

La palabra que aparece delante del nombre de los métodos (void, boolean, int) indica el tipo que tienen los valores que retornan al ejecutarlos (return type). Prueba a pulsar todos los métodos de la lista. ¿Qué observas? Verás que hay dos tipos de métodos:

los que tienen un return type ‘void’ (‘vacio’ en inglés) ejecutan una acción y no devuelven ningún resultado
los que contestan con algún tipo de información. Con estos, estamos haciendo una pregunta al objeto:
- canMove(): ¿puedes moverte?
- foundLeave(): ¿has encontrado una hoja?
- getLeavesEaten(): ¿cuántas hojas has comido?
y devuelven distintos tipos de respuesta en un cuadro de diálogo:
- boolean: valor ‘true/false‘ (es decir, ‘verdadero/falso’)
- int: (número entero)

En la imagen de abajo vemos el ejemplo del resultado del método canMove(). Nos contesta ‘true‘, es decir, es verdad que el wombat puede seguir moviéndose porque no ha llegado a uno de los lados del cuadrado. Si movemos el objeto hasta el final e invocamos otra vez el método, veremos que nos contestará con un ‘false‘. Ese resultado lo puede utilizar el programa para decidir que el objeto gire y cambie de dirección su trayectoria. Lo veremos cuando analicemos el código Java.

También habrás observado que uno de los métodos, setDirection (que podemos traducir por ‘establecer dirección’), contiene una expresión entre los paréntesis. Nos indica que para ejecutarlo el método está esperando que le pasemos un parámetro, en este caso ‘direction‘ que debe ser de tipo ‘int’. Prueba con los valores 0,1,2 y 3 y verás como el wombat cambia su orientación. Estamos modificando el valor de un atributo o propiedad de este objeto (lo explicamos en el cuadro de abajo). Si introduces otro tipo de valor que no sea un nº entero (por ejemplo un nº decimal como 2,3 o una letra) te devolverá un mensaje de error.

Otra detalle que habrás visto en la lista de métodos, es la primera entrada ‘heredado de Actor‘. Si pulsas ahí, verás una lista adicional de métodos que están definidos en la clase Actor y que automáticamente también tiene la clase Wombat como puedes comprobar ejecutándolos. Tiene que ver con el mecanismo de la herencia (una clase más genérica es `padre’ de una más específica, la ‘hija’ y ésta recibe sus características), fundamental en la POO y que explicaremos más adelante.

Una clase está definida por unos atributos y unos métodos:

Los atributos son las propiedades o características significativas de los objetos de esa clase. Por ejemplo, una clase ‘Alumno’ podría tener los atributos nombre, DNI, edad, sexo, calificación, … y cada objeto alumno tomaría unos valores determinados de ese conjunto de atributos compartidos. Serían los datos, el estado del objeto.
Los métodos son las operaciones o procedimientos que pueden realizar los objetos de esa clase. Sería su comportamiento.

Hay que entender que aunque estos objetos correspondan a ‘cosas reales’, son abstacciones esquemáticas en el contexto en que los utilizamos. Por ejemplo, un wombat, podría tener muchos atributos: peso, edad, color,…pero al no ser significativos para el desarrollo de este juego, no están definidos en la clase Wombat. En cambio, veremos que sí tiene otros como la dirección en que se está moviendo o el nº de hojas que ha comido.

Si pensaramos como objetos en primera persona, diríamos que los atributos son ‘lo que sabemos‘ (la información que conocemos) y los métodos son ‘lo que sabemos hacer‘.

Podemos intuir ya otra características fundamental de la POO: la encapsulación de datos y comportamiento dentro de cada clase-objeto. Los convierte en cierta manera en componentes ‘autocontenidos’ que podemos incluso diseñar como ‘cajas negras’, ocultando la complejidad interna al exterior (métodos de otras clases), con los que se comunicará solamente a través del interfaz que definamos.
Esta característica (junto a otras propias del enfoque orientado a objetos) hace que los programas bien diseñados sean más modulares que los que desarrollamos con un enfoque procedimental (*). Esa ‘modularidad’ los hará más flexibiles y escalables y nos facilitará la reutilización de código (clases) en programas diferentes.

(*): La programación estructurada o procedimental, está basada en flujos de procesos que manipulan datos globales y ambos (datos e instrucciones) se engloban en un bloque no diferenciado, lo que le confiere mayor ‘rigidez’ ante cambios. Es cierto que con la creación de funciones, podemos ‘aislar’ ciertas funcionalidades y facilitar la reutilización de código pero no se consigue el mismo nivel de modularidad que en la programación orientada a objetos.

En próximos posts, accederemos al código Java de este programa para comprender mejor como se implementan los conceptos que estamos presentando y generaremos un juego con objetos y reglas nuevas a partir de uno ya desarrollado. Mientras, si tienes curiosidad, abre el menú contextual de la clase Wombat y elige la opción ‘Abrir el editor‘. ¿Puedes entender cómo está construida y localizar los métodos de los que hemos hablado? Inténtalo, es un buen ejercicio…

Greenfoot: introducción a Java y a la Programación Orientada a Objetos

DL — Sun, 08 Jul 2012 13:31:27 +0000

Vamos iniciar una serie de artículos relacionados con Greenfoot, un entorno de desarrollo (IDE) para Java con fines educativos. Con esta herramienta podemos crear aplicaciones gráficas (simulaciones, juegos…) en dos dimensiones que nos permiten familiarizarnos con Java y los conceptos básicos de la Programación Orientada a Objetos (POO) de una forma práctica y divertida.

A la vez que mostramos este entorno, iremos ampliando información sobre algunos aspectos de Java y la POO. Podemos manejar esta herramienta sin necesidad de leer esta información, pero será útil para los que quieran aprender más sobre programación. Esta información adicional la incluiremos en recuadros, diferenciándolos de la documentación básica.

Greenfoot es un proyecto de software libre y gratuito, desarrollado en la Universidad de Kent (UK), enfocado en principio a jóvenes estudiantes que quieren inicarse en el mundo de la programación. Existen otras herramientas con objetivos similares, como Scratch o Alice, pero Greenfoot tiene características más avanzadas, como la edición de código fuente en Java, lo que lo hace más potente e incluso interesante para personas que tienen ya conocimientos en programación. Greenfoot se distribuye gratuitamente con licencia GNU GPL y está disponible para Windows, Mac OS X y Linux.

Instalación del programa Greenfoot

Descarga e instalación del JDK

Para ejecutar Greenfoot es necesario tener instalado previamente el entorno de desarrollo Java (JDK), que provee las herramientas para programar y ejecutar aplicaciones en este lenguaje. Podemos descargarlo de forma gratuita desde esta página:

http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u3-download-1501626.html

eligiendo la versión acorde a nuestro sistema operativo e instalándola según el proceso habitual de nuestro sistema.

Nosotros vamos a descargar el JDK (Java Development Kit ) denominado SE (Stándar Edition) versión 7 (es la última, aunque también valdría la versión 6) que incluye a su vez el JRE (Java Runtime Enviroment – Entorno de Ejecución de Java). El JRE puede descargarse e instalarse de forma autónoma, lo que nos permitiría ejecutar aplicaciones Java en nuestro equipo, pero no crear y compilar programas en este lenguaje. Además de la SE, utilizada usualmente para aplicaciones en entornos desktop-PC, hay otros kit de desarrollo: como ME, EE, FX,… que están orientados a otros tipo de entornos (móviles, aplicaciones corporativas, interfaz webs…)

Descarga e instalación de Greenfoot

Una vez instalado JDK, pasamos a la instalación del programa. Para ello nos dirigimos a la página http://www.greenfoot.org/download

Una vez alli, se nos presentan distintas versiones dependiendo del sistema operativo que usemos, e incluso podemos descargar una versión Java para cualquier SO o una que corra desde una memoria USB.

¡Ojo!, en el caso de que nos hubiésemos saltado el anterior paso, se hubiera instalado incorrectamente el JDK o en un directorio que el instalador de Greenfoot no encuentra nos aparecería un mensaje de error: “No (suitable) Java SDK s were found…“. Debemos comprobarlo o proporcionarle el directorio donde lo tenemos ubicado en nuestro equipo.

Durante la instalación se eligirán diversas opciones respecto al programa, tales como su ubicación y si se desea crear accesos directos al escritorio.

Si queremos cambiar la interfaz del programa a español, deberemos modificar el fichero “greenfoot.defs” que se encuentra en la carpeta “lib” ubicada en el directorio donde hallamos instalado el programa (p.ej., por defecto en Windows: “archivo de programas/greenfoot/lib/greenfoot.defs“).

Para ello lo editamos con un editor de texto como el Bloc de Notas ó Notepad++ y quitaremos el carácter comentario “#” del idioma español y se lo pondremos delante del idioma inglés (ver imagen a la izquierda). Si tienes dudas, consulta la página de traducciones en su sitio web.

Inicio de Greenfoot

Una vez instalado, iniciamos Greenfoot. Sus aplicaciones se basan en Escenarios, que contienen todos los elementos necesarios para que dichos programas se visualicen y funcionen. Los escenarios incluyen un fondo gráfico, denominados Mundos (Worlds), y Actores (Actors ) que colocaremos en dichos mundos y que realizan acciones (ya lo veremos más adelante).
Hay muchos escenarios disponibles. El programa viene con algunos instalados pero también podemos acceder a escenarios creados por otros usuarios que los comparten libremente en la web de Greenfoot.

La primera vez que accedemos al programa nos saldrá un cuadro con opciones para empezar con un escenario ejemplo, elegir algún otro, crear uno nuevo o continuar sin cargar nada. Si elegimos un escenario, nos aparecerá otro mensaje indicándonos que debemos guardarlo en otra carpeta si queremos modificarlo:

Si escogemos el escenario ‘Wombat’ y lo guardamos en una carpeta (p.ej: ‘proyectos_greenfoot‘ en un directorio personal), nos lo abrirá pero sin ningún fondo gráfico. Si pulsamos el botón ‘Compilar todo’ en la parte inferior derecha, nos debe aparecer ya el mundo cargado. Nosotros vamos a crear un Wombat (un marsupial de Australia) y tres hojas:

¿Te animas a jugar ya con este escenario?. Una pista: selecciona la casilla Wombat con el ratón y pincha el botón derecho para que te aparezca el menú contextual. Si no sabes como seguir, en los siguientes posts te iremos contando como hemos creado los ‘actores’, cómo se juega y cómo podemos ir adaptado éste o cualquier otro escenario mediante programación Java de forma muy sencilla.