05 – ¿Quién construye los objetos? Quién va a ser, ¡el Constructor!

Hasta ahora, hemos creado usando el entorno Greenfoot los objetos que nos interesaban en nuestro mundo y hemos programado el comportamiento, mediante la programación de sus métodos de clase.

Pero, la pregunta es, ¿existe un reflejo en código java de esas acciones que hacemos para crear nuestros objetos? La respuesta es, evidentemente, sí.

Debemos darnos cuenta que nuestros objetos viven en un mundo determinado, que no es sino otro objeto. Un objeto que es especial, eso sí, pues es un objeto que contiene a otros.

Para ver cómo funciona este objeto, vamos a partir del proyecto del mundo Tortuga original y crearemos las clases Lechuga y Serpiente como en los proyectos anteriores. Una vez hayamos hecho esto, vamos a crear un objeto tortuga, una serpiente, y dos lechugas en el mundo y, tras hacerlo, guardaremos el mundo con la opción Save the World del menú contextual sobre el escenario.

Si accedemos al código fuente de la clase mundo tortuga (TurtleWorld), observamos que se ha añadido un método, prepare(), cuyo código fuente tiene las instrucciones que detallamos en las imágenes a continuación.

constructores

constructores2

Vemos cómo se crea un nuevo objeto tortuga invocando al constructor de la clase Tortuga con la sentencia

new Turtle()

y creamos una variable-referencia a dicho objeto, para poder referirnos al mismo en nuestro código fuente.

Lo mismos sucede con el resto de objetos (se crean dos lechugas con new Lechuga() y una serpiente con una instrucción new Serpiente()). Además, dichos objetos se añaden al mundo mediante el método addObjetc(Object) de la clase World.

A los métodos Turtle(), Lechuga() y Serpiente() que se invocan con la instrucción new se les llama constructores de la clase correspondiente y son los encargados de crear los objetos de esa clase cuando son invocados.

Si accedemos al código fuente de cualquiera de esas clase veremos que esos métodos no aparecen por ningún lado. El motivo es porque una Tortuga, Lechuga o Serpiente no se crea de manera distinta a los Actores que se crearían en el mundo con el constructor de la clase Actor y, por eso, cuando invocamos al constructor correspondiente, realmente se usa, por herencia, el constructor de la clase Actor, clase padre de todas.

Sin embargo, ¿y si quisiésemos que las serpientes naciesen con un giro aleatorio predeterminado? Es decir, queremos que cada serpiente, al ser creada, se cree para que dicha serpiente gire en el borde del mundo con un giro de ángulo aleatorio y distinto de otras.

Deberíamos entonces crear en la clase serpiente su constructor, con el código que muestro a continuación.

serpiente_cons

El atributo giro almacenará el giro con el que girará siempre esa serpiente. El método siguiente es el constructor, al que hay que pasarle como argumento el ángulo de giro.

Observemos que los constructores son métodos especiales:

  • son públicos, para que todos puedan usarlos.
  • no se espera que devuelvan ningún valor, por lo que ni siquiera tienen la palabra reservada void.
  • su nombre debe ser el mismo de la clase, Serpiente en este caso.

¿Cómo creamos ahora una serpiente en nuestro mundo? Vamos a hacerlo por código, sin más que escribir en el método prepare() de nuestro mundo el siguiente código fuente.

crea-serpiente

Hemos usado un bucle for de Java (para conocer la sintaxis de la instrucción for, seguir el enlace) para crear tres objetos Serpiente que girarán, cada uno, con un ángulo de giro distinto aleatorio.

Si programamos ahora el comportamiento de las tortugas y las serpientes igual que hemos hecho en actividades anteriores, veremos como todo funciona y las serpientes giran, cada una, con ángulos distintos al llegar al borde.

¡Adelante, inténtalo, es tu turno!

04 – Atributos de una clase

En el siguiente vídeo introducen el concepto de atributo de clase. Para comprenderlo vamos a modificar la clase Tortuga con la que estamos trabajando para que acumule cuántas lechugas se va comiendo.  Así, el estado de cada objeto Tortuga quedará definido por su aspecto (la imagen de tortuga), su posición en el mundo (las coordenadoas x e y) y las lechugas que ha comido hasta el momento.

Recordad que el estado de un objeto se puede consultar sin más que usar la opción Inspect que aparece en el menú contextual de cada objeto del mundo.

Para practicar, añadir el atributo lechugasComidas en la clase Turtle, jugad un rato al juego (evitando que os coma ninguna serpiente) e inspeccionad el estado de la tortuga tras algunas lechugas comidas.

03- Un juego de persecución.

En esta entrada voy a incluir todos los vídeos en los que se explica todo lo necesario para hacer un juego sencillo. En ellos, aprenderemos lo siguiente:

  • la clase Greenfoot contiene métodos que podemos usar en cualquiera de nuestras clases. Por ejemplo, contiene el método getRandomNumber(int limit) que nos devolverá un valor aleatorio entre 0 y limit  o el método isKeyDown(String), que devuelve verdadero o falso si la tecla indicada con el parámetro String está pulsada o no, respectivamente.  Así, el método getRandomNumber lo podemos usar para dar un ángulo de giro aleatorio cada vez que un objeto deba girar, y el método isKeyDown podemos usarlo para implementar un control del movimiento de nuestra tortuga por teclado.
  • podemos crear nuevas subclases sin más que usar la opción new subclass() del menú contextual del diagrama de clases. Toda nueva clase, subclase de Actor, debe tener un nombre y una imagen asociada.
  • los métodos canSee(class) y eat(class) nos permiten implementar interacción entre objetos. En particular canSee(class) nos devuelve Verdad o False en función de si un objeto de una clase está tocando o no a otro objeto de otra clase; el método eat(class) nos permite simular que un objeto se ha comido a otro, haciendo desaparecer al segundo.

Para practicar y comprender todos los conceptos anteriores debes hacer las siguientes tareas (todas ellas explicadas en clase):

  • crea una subclase nueva, de nombre serpiente y con la imagen de una serpiente.
  • Implementa en el código de la serpiente un movimiento aleatorio para los objetos que se creen de dicha clase. Para ello, sigue las instrucciones del vídeo Joy of Code#6: random behaviour.
  • Además, la serpiente debe verificar si toca a la tortuga, en ese caso, se la debe comer y se acaba el juego.
  • crea una subclase nueva de nombre lechuga y con la imagen de “algo que parece una lechuga”. No es necesario que implementes nada para esta clase.
  • modifica el código de la clase tortuga para que haga lo siguiente:
    • se mueva 5 pasos cada vez.
    • verifique, tras cada movimiento,
      • si pulsamos la tecla “flecha derecha” (“right”); entonces la tortuga debe girar 7 grados en el sentido de las agujas del reloj.
      • si pulsamos la tecla “flecha izquierda” (“left”); entonces la tortuga debe girar 7 grados en el sentido contrario a las agujas del reloj.
    • verifique, también, si está sobre una lechuga. Si es el caso, que se la coma.

 

02-Codificando… en Java.

En los siguientes vídeos vamos a aprender los conceptos básicos de codificación en Java, haciendo uso de las facilidades que nos ofrece el entorno de Greenfoot.

Haremos que una pequeña tortuga se mueva por el mundo en el que vive y que gire si ha llegado al borde de su mundo.

Con la explicación dada en clase y que podéis recordar con los vídeos enlazados anteriores, hemos aprendido lo siguiente:

  • La llamada a un método es una instrucción que le dice a un objeto qué hacer. Algunos métodos necesitan parámetros o datos de entrada para saber hacer su trabajo y algunos, también, devuelven algún valor al finalizar. El valor de retorno debe controlarse en el lugar donde se realiza la llamada al método.
  • Algunos de los tipos de valores que hemos visto que pueden devolver son int, para números enteros, y boolean, para valores de tipo Verdadero o Falso.
  • Las instrucciones se ejecutan en secuencia, en el orden en que son escritas. Las instrucciones elementales terminan con una “;”.
  • Cuando cambiamos algo en el código, éste debe compilarse de nuevo para generar el nuevo código ejecutable con los cambios.
  • Si algo está mal escrito, el compilador nos da un error de sintaxis y señala dónde está el error.
  • La sentencia if, usada para realizar instrucciones si se da una condición o ejecutar otras en caso contrario, tienen la siguiente sintaxis en Java:

sintaxis-if

  • La clase Greenfoot contiene métodos que pueden ser usado por todos los objetos de nuestros escenarios.

Para practicar, abre el escenario, crea varias tortugas y haz que se muevan por el mundo en el que viven. Tras crearlas, orienta cada una hacia una dirección distinta de las otras mediante el método void turn(int) heredado de la clase Actor.

Las tortugas deben detectar que están en el borde del mundo y girar unos grados para seguir caminando.

¿Sabrías hacer que el giro fuese aleatorio en cada momento? Una pista, prueba la generación de números aleatorios en la clase Greenfoot… (mira la documentación)

01-Clases y objetos… y un lenguaje para modelarlos a todos: UML.

En el vídeo siguiente introducimos los conceptos fundamentales de la programación orientada a objetos: el concepto de clase y la creación de objetos de una misma clase.

Lo que haré será explicarlo en clase, pero os dejo a continuación el vídeo para que lo tengáis siempre a mano por si queréis recordar algo.

En el vídeo hemos aprendido:

  • Los escenarios de Greenfoot son representación de partes de nuestro mundo.
  • El escenario de Greenfoot, al igual que nuestro mundo, está compuesto por una serie de clases, que no son más que tipos de cosas.
  • El escenario muestra mediante un diagrama de clases UML las clases disponibles en esta parte del mundo en la que estamos, el escenario Greenfoot. Para saber más sobre UML y los diagramas de clases, seguid los enlaces.
  • Podemos crear tantos objetos de un tipo, de una clase, como deseemos. Lo que hacemos es crear instancias de esa clase.
  • Las clases recogen lo que cómo serán los objetos que se creen de las mismas y lo que saben hacer. Es decir, los objetos de una clase tendrán una serie de atributos que definen su estado y una serie de métodos que determinan qué sabe hacer ese objeto.
  • Todos los objetos del mundo Greenfoot son, realmente, objetos actores en ese mundo. Es decir, todas las clases son hijas de la clase Actor y heredan sus atributos y métodos.
  • Los métodos pueden necesitar datos para hacer lo que deben hacer. Esos datos se proporcionan al método mediante parámetros o argumentos del método.
  • A su vez, los métodos puede no ofrecer ningún resultado de su acción o pueden devolver algún valor. Si un método no devuelve ningún valor, mostrará delante de su nombre la palabra void. Si devuelve algún valor, mostrará una palabra que indique el tipo de valor (int, por ejemplo, si devuelve un número entero).
  • Las características de una clase y sus métodos se especifican en código fuente escrito en lenguaje Java.
  • Cada vez que se cambia el código fuente, se debe compilar para crear el código máquina que puede ser ejecutado.

Para practicar con el entorno y con vuestras primeras clases y objetos, debéis hacer las siguientes prácticas:

  • Abrir el Escenario Erizos.
  • Crea dos erizos y 10 manzanas, dispuestas aleatoriamente por la cuadrícula del escenario.
  • Pulsa el botón Act 4 veces. Observa que pasa. Luego pulsa el botón Run y observa qué sucede. Pulsa, finalmente, el botón Pause. ¿Qué ha sucedido en cada caso?
  • Ejecuta el método move() de uno de los erizos, hasta que alcance un borde del escenario. En el borde, vuelve a ejecutar move(). ¿Hace algo el erizo? Verifica con el método canMove() si puede moverse.
  • Ejecuta el método turnLeft() del erizo que tengas en el borde. Vuelve a comprobar si se puede mover con el método canMove(). Comprueba que ya puede moverse invocando al método move().
  • Sitúa un erizo al lado de una manzana e invoca el método foundApple(). ¿Cuál es el valor devuelto?. Sitúa, ahora, el erizo sobre la manzana y vuelve a invocar el método foundApple(). Comprueba cuántas manzanas se ha comido hasta ahora el erizo mediante el método getAppleEaten(). Después, haz que se coma la manzana con el método eatApple() y vuelve a comprobar el número de manzanas comidas, pero esta vez invocando la acción inspect que te dará el estado global del erizo.
  • Abre el código fuente del erizo y de la manzana. ¿La manzana hace algo?. Ve al código fuente del erizo y estudia el método act(). Describe brevemente lo que hace.
  • Usa el método setLocation(int, int) que el erizo hereda de Actor, para situar al erizo en la cuadrícula de coordenadas x=4 e y=3.

00-Greenfoot: un entorno para aprender OO.

Con el tema anterior nos hemos introducido en el mundo de la programación. He tratado de que comprendierais el proceso que debe seguirse:

  • empezando por un análisis del problema que se nos planteaba,
  • continuando por un diseño de la solución a ser programada
  • para, finalmente, acabar implementando el programa solución escribiendo el código necesario.

Como lenguaje de programación usado Python y hemos aprendido las estructuras clásicas en el mundo de la programación estructurada  modular.

Ahora toca cambio de paradigma, y el que debemos aprender es el paradigma Orientado a Objetos y el lenguaje que aprenderemos es Java. Para ello utilizaremos un entorno de desarrollo que, para un curso de iniciación como este, nos oculta muchas de las dificultades habituales de programar con Java. Este entorno es Greenfoot.

gf_paginicial

Haz clic sobre la imagen para acceder al Prezi de explicación de elección de Greenfoot

Otro de los motivos de usar este entorno es que sus creadores, profesores de la Universidad de Kent, han preparado, además del entorno, multitud de materiales (proyectos de ejemplo, videotutoriales, un libro de texto…) que usaremos como guía para nuestro trabajo.

Son excelentes, bien organizados y completos. No los usaremos todos (no tenemos tiempo…) pero si a alguno de vosotros os pica el gusanillo de continuar con esto, os invito a que los uséis para avanzar en vuestro aprendizaje.

Para empezar, vamos a ver el vídeo de introducción que nos muestra las posibilidades de este entorno.

Todos los proyectos o escenarios, como se llaman en Greenfoot, los podréis encontrar en la página The Joy of Code de los creadores del entorno. Además, por si acaso, también os he preparado carpetas Drive que os iré compartiendo a medida que las necesitamos.

En particular, los proyectos que aparecen en el vídeo anterior, los podéis encontrar en la carpeta Escenarios del primer vídeo, o directamente, en la página correspondiente del blog de Joy of Code.

Además, en el segundo vídeo del proyecto encontraréis instrucciones de cómo instalar el entorno en vuestra casa, para que podáis seguir divirtiéndoos allí, además de en clase…

Os lo enlazo, también, a continuación.