martes, 18 de marzo de 2014

Interfaces en Java

Hola,
esta mañana hemos estado estudiando los interfaces y su relación con la herencia. A modo de repaso os dejo un par de vídeos que os pueden resultar de interés.

Creación y uso de Interfaces 1/2


En este vídeo se muestra cómo usar interfaces en Java para tratar de forma homogénea objetos de clases distintas. Este video se ha grabado en la clase de Programación Orientada a Objetos del Grado en Matemáticas que tuvo lugar el día 20 de marzo de 2012.

Creación y uso de Interfaces 2/2


En este vídeo se muestra cómo usar interfaces en Java para tratar de forma homogénea objetos de clases distintas. Este video se ha grabado en la clase de Programación Orientada a Objetos del Grado en Matemáticas que tuvo lugar el día 20 de marzo de 2012.

saludos

martes, 4 de marzo de 2014

Sobrecarga de métodos y constructores

Hola a todos,
esta mañana hemos dado un repaso a la herencia y hemos comentado dos temas nuevos. El primero ha sido la sobrecarga de métodos y constructores. Para repasarlo os aconsejo que echéis un vistazo a este par de vídeos:

Sobrecarga de métodos (1/2)


Este video tutorial explica cómo y cuándo sobrecargar métodos.

Sobrecarga de métodos (2/2)


Segunda parte del video tutorial acerca de la sobrecarga. En este caso vemos cómo y para qué sobrecargar constructores y cómo invocar un constructor desde otro.

También hemos hablado sobre la clase Object que es la clase padre de todas las clases que existen y que creemos nosotros en Java y su método toString. Como hemos visto es útil redefinirlo para poder mostrar objetos directamente con System.out.println.

Finalmente, hemos vuelto a ver lo interesante que es utilizar arrays cuyas celdas sean de un tipo padre para poder guardar objetos de los tipos "hijo" y así poder tratar de forma homogénea a objetos de distinto tipo.


martes, 25 de febrero de 2014

Creando clases por herencia


Esta mañana hemos visto cómo crear clases a partir de otras heredando sus miembros y métodos. A la clase de la que heredamos la llamábamos clase Padre y a la nueva clase la llamábamos clase Hija. La primera ventaja de hacer esto es que no es necesario repetir código ya que la nueva clase incluye todo lo que tenía la clase Padre. Todo, excepto el método constructor. La segunda ventaja la hemos visto al comprobar que una variable de tipo Padre puede referirse a objetos de la clase Hija. De esta forma hemos podido crear arrays heterogéneos compuestos por objetos de distinto tipo, aunque de la misma familia. Por último, hemos visto como era posible redefinir el comportamiento de los métodos heredados y Java era capaz de ejecutar el método correcto según el objeto sobre el cual se estuviera invocando.

Os dejo aquí otra visualización interactiva de Java con un pequeño programa que demuestra lo que hemos visto en clase. En el ejemplo, tenéis una clase Padre de la que hereda una clase Hijo que redefine uno de los métodos públicos del padre.

sábado, 22 de febrero de 2014

Referencias a objetos

Hola,
esta semana avanzamos bastante y casi terminamos Sokoban. Hicimos el método muevePersonaje de la clase escenario teniendo en cuenta todas las restricciones del juego en cuanto a cuándo se puede mover el personaje y cuándo las cajas. Para conseguirlo usamos un array de dos dimensiones de booleanos que guardaba true si había un muro en la celda asociada y false en caso contrario. Además escribimos el método Caja hayCaja(int x, int y) que comprobaba si en la fila y y columna x había una caja y, en ese caso, la devolvía. Si no devolvía nulo.

Estuvimos después viendo que, en realidad, las variables cuyos tipos son clases (no las variables de tipos básicos como int, boolean, char, o double) lo que almacenan es la referencia al objeto, es decir, cuál es el objeto por lo que al copiar variables de este tipo asignando el valor de una a otra no estamos creando un nuevo objeto sino haciendo que dos variables se refieran al mismo objeto. Sólo se crean objetos al hacer new pero no al asignar el valor de una variable a otra.

Para entenderlo hicimos un ejemplo en la pizarra en el que asignábamos a una variable de tipo Caja el contenido de una celda de un array de cajas. Aquí os dejo el mismo ejemplo para que podáis ver cómo pasa de una forma gráfica y animada y, además, con la opción de ver paso a paso cómo se van creando y asignando los distintos objetos. Prestad atención sobre todo a lo que pasa cuando se crean los objetos con new, lo que pasa cuando se ejecuta el método muévete y cómo en ese momento aparece el objeto this, y el efecto que tiene que tanto la segunda celda del array como la variable laPrimera se refieran al mismo objeto.

http://goo.gl/Ogmdvl

viernes, 7 de febrero de 2014

El comienzo de Sokoban

Hola a todos,
como varios me habéis pedido que suba el código de Sokoban que llevamos hecho hasta el momento os lo dejo en esta entrada del blog. Además aprovecho para explicar cómo incluir la biblioteca Graficos.jar para poder usar la clase CanvasFrame.

De momento hemos escrito un programa que dibuja el suelo del escenario usando imágenes que colocamos en la pantalla como si fueran losas. Es decir, suponiendo que el escenario es cuadrado y tiene un tamaño de 10x10 celdas dibujaremos 100 imágenes que representen las 100 losas del suelo.

Para poder dibujar usamos un objeto de la clase CanvasFrame y como esta clase no pertenece a Java hay que importarla. Para ello descargamos el fichero Graficos.zip y lo descomprimimos en el escritorio. Buscamos el fichero Graficos.jar y lo copiamos a la carpeta del proyecto en el que queramos usarlo. Después, desde NetBeans hacemos click con el botón derecho sobre el icono que pone "Libraries" o "Bibliotecas" y tras elegir la opción "add jar/folder" o "añadir jar/carpeta" buscamos el fichero Graficos.jar dentro de la carpeta del proyecto y lo añadimos para que quede así:


Una vez hecho podemos empezar a declarar y usar variables de tipo CanvasFrame. En concreto, el código para dibujar el suelo del escenario sería algo así:
import graficos.CanvasFrame;

public class Main {
  public static void main(String[] args) {
    // Declaramos la variable cf de tipo CanvasFrame
    CanvasFrame cf;

    // Creamos un objeto de tipo CanvasFrame
    cf = new CanvasFrame(340, 360);

    // Dibujamos el suelo como si fuera un mosaico
    for ( int y = 0 ; y < 10 ; y++ ) {
      for ( int x = 0 ; x < 10 ; x++ ) {
        cf.image("images/floor.gif", 10+x*32, 10+y*32, 32,32);
      }
    }
  }
}

Una vez que teníamos esto creamos una clase para representar al personaje. El personaje lo representamos usando dos variables que modelan la posición del mismo y un par de funciones: una que dibuja al personaje y otra que lo cambia de sitio. La clase que hicimos era algo así:

import graficos.CanvasFrame;

public class Personaje {
  // Atributos que modelan un personaje
  private int x;
  private int y;

  // Constructor de los objetos de tipo Personaje
  public Personaje(int x, int y) {
    this.x = x;
    this.y = y;
  }

  public int getX() {
    return x;
  }

  public int getY() {
    return y;
  }

  // Método que mueve el personaje
  public void mueve(int dx, int dy) {
    this.x = this.x + dx;
    this.y = this.y + dy;
  }

  // Métodos que dibuja el personaje en la pantalla cf
  public void dibuja(CanvasFrame cf) {
    // Dibujar el personaje
    cf.image("images/frog.png", 10 + x * 32, 10 + y * 32, 32,32);
  }
}

Una vez que tenemos la clase Personaje podemos usarla añadiendo a nuestro programa principal algo así:

  Personaje rana = new Personaje(0,0);
  rana.mueve(1,0);
  rana.dibuja(cf);

Pero para poder dibujar la imagen de la rana debemos tener el fichero "frog.png" guardado dentro de una carpeta llamada "images" que esté dentro de la carpeta "src" del proyecto.

Intentad hacer la clase Caja para usarla el martes que viene en clase. Recordad que tendremos que tener varias cajas en el escenario y poder moverlas por el mismo.

saludos

miércoles, 5 de febrero de 2014

Creando mis propias clases

Hola a todos,
el martes vimos cómo crear nuestras propias clases en Java por agregación. Usando variables de tipos de datos simples o incluso otras clases hemos sido capaces de crear otra clase más compleja que las anteriores.

Por otro lado, hemos visto la forma de ocultar los miembros para que no puedan ser utilizados desde clases distintas a aquella en la que están definidos y, al mismo tiempo, exponer públicamente los métodos que sí queremos que puedan ser utilizados.

Finalmente, hemos visto la importancia de aprovechar la posibilidad de incluir un método constructor explícito para inicializar todos los miembros de los objetos recién creados.

En relación con estos temas os recomiendo que echéis un vistazo a los siguientes vídeos:

Cómo crear clases en NetBeans
Visibilidad de miembros y métodos: public vs private
Métodos get y set