Programando en Java con Greenfoot

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:

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:

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:

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:

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()

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:

¿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.