Beceoca

 

El pasado jueves entregamos el juego terminado. Vamos a contar un poco como lo hemos hecho y los problemas que nos hemos ido encontrando a lo largo de su programación.

 

Lo primero es que nuestro juego es el Brain Training. Partiendo de esta idea hemos creado un test con 15 preguntas en las que recorremos todos los aspectos para entrenar el todas las partes del cerebro.

Con las respuestas correctas hacemos un cálculo aproximado de la edad mental.

Para responder a cada pregunta disponemos, dependiendo del nivel de dificultad elegido de 17 o 13 segundos según hayamos escogido entre fácil y difícil respectivamente.

 

Para empezar el juego no elegimos la implementación de la algoritmia como se aconseja, ya que en nuestro caso las acciones a realizar dependen directamente de los botones que se pulsen y por tanto comenzamos por la parte de Swing.

 

Los principales problemas que nos encontramos a lo largo del juego se pueden resumir en estos cuantos:

- Cuántas clases crear. Esto nos llevó más de un quebradero de cabeza, tanto que hicimos que las clases heredaran de JFrame y así poder usar la clase entera como una ventana, y por lo tanto creamos una clase por ventana (en total 7). También podríamos haberlo echo de forma que en una sola ventana y mediante el método removeAll() quitáramos o pusiéramos componentes dependiendo de la parte del juego en que nos encontráramos, pero lo descartamos por falta de tiempo (al tener todo echo de la otra forma).

- Creación de una algoritmia capaz de decidir si la respuesta elegida es la correcta o no. Esto lo solucionamos creando un array de respuestas, ya que la pregunta y las posibles cuatro respuestas están contenidas en una sola imagen que no se puede modificar. Por lo tanto solo teníamos que comparar la respuesta pulsada (de la imagen i) con la posición i en el array de respuestas. Pensamos en realizar las respuestas de forma aleatoria, pero lo descartamos al decidir que las imágenes aparecerían en orden de dificultad creciente.

- Otro problema fue la forma de manejar el  timer, ya que no teníamos mayor experiencia con él que la vista en la teoría y en las prácticas. Esto lo solucionamos a última hora, y vimos que nuestro error no era otro que el de no crear el manejador para el timer que estábamos poniendo en marcha. Finalmente y tras mucho darle vueltas conseguimos controlarlo de forma que realizara la cuenta parcial de tiempo, es decir, cada 1 segundo.

- Otra de las cosas que nos quebraron la cabeza a la hora de programar el juego fueron los errores que el usuario podría cometer al introducir su nombre y su edad. En el nombre únicamente comprobamos que pongas al menos una letra o un número para que no se quede vacío, pero en la edad y para evitar problemas, decidimos controlar que lo único que se introdujese fueran números del 1 al 99. Par a informar de estos errores creamos varios JOptionPane con el error que hayas cometido.

- El ultimo problema que el juego nos dio fue el de crear un reproductor JMF que en un momento dado de la aplicación nos pusiera en marcha un sonido. Con el reproductor de la teoría no teníamos más que usar una parte de su código para conseguir lo que nos hacía falta.

 

En esta práctica se desarrollan los conceptos de eventos en Swing.

 

Para comenzar nos hacen una introducción de lo que vamos a realizar en la sesión, y es crear un programa controlado por la interfaz gráfica.

Hasta ahora los programas que hemos desarrollado no eran demasiado interactivas con el usuario, los únicos mecanismos que teníamos para comunicarnos con la aplicación eran: los argumentos de entrada, entrada estándar y el manejador de ventanas.

Necesitamos alguna forma de comunicarnos con la aplicación distinta a las mencionadas anteriormente, y para ello nos servimos de los componentes de swing que tienen esta utilidad.

 

En el primer apartado se pide realizar un programa de nombre Simple00GUI que presente una ventana con un botón, cada vez que se pulse el botón se imprimirá un mensaje por la salida estándar.

Únicamente debemos implementar el manejador del botón y añadir en su método actionPerformed la acción System.out.println(“Botón pulsado!”);

 

El siguiente apartado trata de implementar otra clase de nombre Simple01GUI que además de presentar un botón presente también una etiqueta. Cada vez que el botón sea pulsado debe cambiar el color de fondo de la etiqueta. No debemos olvidar añadir el código etiqueta.setOpaque(true); tras crear la etiqueta para que esta tenga color de fondo.

Para ello añadimos en el actionPerformed del botón la acción que mire el color al que está en ese momento la etiqueta y cambiarle por otro. Para ello debemos elegir un par de colores y crear un if-else para mirar que color tiene la etiqueta y cambiarlo (en nuestro caso hemos elegido los colores blanco y negro).

El algoritmo que realiza esta acción es el siguiente:

if(etiqueta.getBackground() == Color.white){

etiqueta.setBackground(Color.black);

}

else{

etiqueta.setBackground(Color.white);

}

}

 

El apartado tres consiste en crear otra clase que realice las mismas acciones anteriores, pero añadiendo otra más (cada vez que la tecla Enter sea pulsada se cambiará también el color de la etiqueta). En esta clase comenzaron nuestros problemas de hilos, ya que al atender al evento del botón se desatiende el evento de pulsado de la tecla Enter. Utilizando el método Thread.getName() antes de cambiar el color de la etiqueta vemos que hace caso únicamente al evento del botón.

En este apartado nos quedamos, ya que el resto del tiempo lo dedicamos a la realización de algunos asuntos relacionados con el juego.

 

La práctica trata sobre procesos e hilos.

 

En un principio se explica cómo funcionan los procesos abiertos en una CPU, ya que ésta dedica un tiempo a cada una de las tareas, dando la impresión de que está ejecutando todas a la vez.

La CPU intenta dar a todos los procesos el mismo tiempo.

Si la CPU tiene más procesos abiertos, dará menos tiempo a cada uno de ellos, y si un programa necesita más tiempo de dedicación por parte de la CPU del que ésta le proporciona se notará que comienza a ir lento o a trompicones.

 

El primer apartado de esta práctica es crear un programa que imprima un texto (DING!) cada vez que es pulsada la tecla INTRO

Necesitamos importar el paquete de excepciones java.io.IOException para posibles fallos de lectura del teclado

La clase tendrá como nombre Ding y contendrá únicamente el método main que a su vez contiene un try-catch para capturar el error lanzado por la aplicación en caso de fallo del teclado.

Dentro del try pondremos un while, que tendrá una condición (mientras sea cierto lo que contiene dentro del cuerpo), y dentro de éste un if cuya condición es que la lectura del teclado sea un intro, es decir: if(System.in.read() == ‘\n’)

Si esta condición se cumple imprimiremos en la consola el texto (DING!), en caso de algún error de teclado imprimiremos una línea de error.

 

La siguiente clase a programar fue la clase Dong que imprime por pantalla cada 1000ms  mediante el métoodo sleep la frase “Dong!”. También se introduce en un try-catch para capturar cualquier error que pueda surgir.

 

El siguiente ejercicio trata de juntar las dos clases anteriores, es decir, que cuando pulsemos INTRO salga “Ding!” y cuando pasen 1000ms salte la frase “Dong”.

Aquí comenzamos a tener el problema de los hilos, en el cual si estás atendiendo a un evento no puedes atender a otro a la vez. Atendemos al evento de dormir la ejecución y no podemos atender al del botón INTRO. Con lo cuál los dos eventos se imprimen por pantalla justo cuando pasa el tiempo entre las dos impresiones de la frase “Dong!”. Por supuesto debemos declarar los dos posibles errores.

 

Después de realizar estos ejercicios sobre hilos nos dedicamos a nuestro juego que es el Brain Training. Teníamos un problema, que se trataba de que habíamos declarado un array pero no lo habíamos creado, y por eso nos daba un error al ejecutar del tipo NullPointerException. También estuvimos intentando resolver el problema del timer, ya que no sabemos cúando pararlo y si pulsamos un botón antes de que se pase el tiempo permitido para ello, la siguiente vez tendremos menos tiempo para contestar la pregunta.

Esta práctica es la primera que trata sobre interfaces gráficas (swing).

En los primeros 45 minutos, el profesor nos estuvo explicando cuándo y dónde debemos emplear las GUIs, ya que no siempre son necesarias.

Posteriormente nos metimos en “materia”, y comenzamos a realizar el ejercicio 1, que trata de crear un “hola mundo” de forma gráfica, creando una clase llamada HelloWorldGUI, en la que importamos varios paquetes necesarios para su posterior uso.
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JLabel;
Creamos posteriormente un frame y le damos la función de salir en la X de la esquina superior derecha con las líneas de código:
JFrame frame = new JFrame(“HelloWorldGUI window title”);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
y le añadimos un panel que contiene una etiqueta, en la que pone Hello World!.
JPanel contentPane = (JPanel) frame.getContentPane();
JLabel label = new JLabel(“Hello World!”);
contentPane.add(label);
Con estas otras dos líneas damos tamaño a la ventana y la hacemos visible por pantalla
frame.setSize(100,50);
frame.setVisible(true);

Ahora se crea otra clase llamada HelloWorldGUIDelayed, a la que añadiremos un código dado en el enunciado entre la llamada al método setSize y a setVisible y cuya función es parar el programa 10 segundos antes de su ejecución, con lo que al ejecutar el programa deberemos esperar 10 segundos antes de que aparezca algo por pantalla.
try {
       Thread.sleep(10*1000);
} catch (InterruptedException e) {                  
        System.err.println(“Unexpected interruption while sleeping:”);
        System.err.println(e);        
        System.exit(1);
}

En otro apartado se pide introducir el código System.exit(0); al final del método main, con resultado la salida directa del programa tras ejecutarlo.

 

 

 

 

El código para esta clase es el siguiente:

public static void main(String args[]) {

//Creamos la ventana, le damos título y utilidad a la X
JFrame frame = new JFrame(“HelloWorldGUI window title”);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// Creamos el panel y le añadimos a frame
JPanel contentPane = (JPanel) frame.getContentPane();

//Creamos las cuatro etiquetas con las características indicadas en el enunciado
JLabel label = new JLabel(“Hello World!”);
label.setOpaque(true);
label.setBackground(Color.BLACK);
label.setForeground(Color.white);

JLabel label1 = new JLabel(“Hello World!”);
label1.setOpaque(true);
label1.setBackground(Color.WHITE);
label1.setForeground(Color.black);

JLabel label2 = new JLabel(“Hello World!”);
label2.setOpaque(true);
label2.setBackground(Color.BLUE);
label2.setForeground(Color.red);

JLabel label3 = new JLabel(“Hello World!”);
label3.setOpaque(true);
label3.setBackground(Color.RED);
label3.setForeground(Color.blue);

//Damos bordes entre el panel y el contenedor principal, es decir, frame y añadimos todas las etiquetas en la posición del panel que les corresponde, maximizamos la pantalla al ejecutar el programa y la hacemos visible.
contentPane.setBorder(BorderFactory.createEmptyBorder(25,100,25,100));
frame.setLayout(new BorderLayout());
frame.getContentPane().add(label,BorderLayout.NORTH);
frame.getContentPane().add(label1,BorderLayout.SOUTH);
frame.getContentPane().add(label2,BorderLayout.EAST);
frame.getContentPane().add(label3,BorderLayout.WEST);
frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
frame.setVisible(true);
}
}

 

No nos dio tiempo a realizar los demás apartados, ya intentaremos acabarla por nuestra cuenta y riesgo cuando tengamos algún rato libre, ya que el juego quita muchísimo tiempo.

 

La octava práctica trata sobre la Tabla hash y la recursirsividad
Pasamos ahora a definir estos dos conceptos.

Tabla Hash
La principal función de esta clase es asociar un valor a una clave, y sus principales métodos son:
- put(clave, valor): añade una clave y un valor asociado.
- get(clave): introduciendo una clave te devuelve su valor.

Recursividad
Se dice que un objeto es recursivo si forma parte de sí mismo o de define en función de sí mismo.Esto quiere decir que una vez dentro de un método, por ejemplo, puedes llamarse así mismo con otros parámetros como valores de entrada a ese método.

La recursividad tiene bastantes aplicaciones, como por ejemplo obtener un factorial, una serie, etc

Es necesiario establecer una condición de parada, para finalizar el algoritmo y que no se convierta en un bucle infinito.

EJERCICIO 1
Consiste en definir una tabla Hash que contenga 10 palabras claves con sus 10 valores asociados respectivamente, de forma que cuando introduzcas la sentencia get(clave), obtengas su valor.

Para ello, debemos importar el paquete “java.util.Hashtable”, y en el propio main de la clase que creamos nosotros (llamada TablaJas) creamos un objeto de la clase HashTable con nombre t.
Posteriormente introducimos las distintas claves y sus valores con el código t.put(“clave1″,”valor1″).
Finalmente para probar que las claves y los valores se han añadido correctamente imprimimos los valores asociados a cada una de las claves con System.out.println(t.get(“clave1″)).

EJERCICIO 2
Con la clase proporcionada en la práctica, se pide explicar cada uno de los métodos.

Método factorial
public long factorial(long num){
    if (num==1)
        return 1;        
    else
        return (num * factorial(num-1));     
}
Este método impone una condición de parada que consiste en que el parámetro num sea igual a uno, devolviéndote en este caso un uno. Si esto no se cumple te devuelve el valor de num multiplicado por el factorial del número anterior a num, es decir (num-1), hasta que llegues a la condición de parada anteriormente descrita.

Método p1
public void p1(int a){
        if (a>0){
            System.out.println(a);           
             p1(a-1);
        }else{
            System.out.println(“FIN”);
        }
}
En este método la condición de parada es que el valor a sea menor o igual que cero, si es así imprime por pantalla “FIN”, en otro caso imprime el valor de a y vuelve a llamarse, introduciendo como parámetro de entrada el valor (a-10).

Método p2
public void p2(int a, int b){
        if (a>0){
             p2(a-1,b+a);
        }else 
             System.out.println(b);
}
En este caso introducimos dos números, a y b, que si no cumplen la condicion de que a sea mayor que cero imprimirán por pantalla el número b introducido y si la cumplen se llamará sí mismo, con parámetros a-1 y b+a.

Método suma
public long suma(long [] tabla, int posActual, int tamaño){ 
       if (posActual == tamaño -1 )
                return tabla[posActual];
        else             
                return (tabla[posActual] + suma(tabla, posActual+1, tamaño));
}
Este método suma todos los elementos de un array. Los parámetros de entrada del método son el array (tabla) anteriormente mencionado, un número posActual que indica la posición en que nos encontramos y otro tamaño que indica el tamaño del array.
La condición de parada en este caso es que el tamaño sea -1, es decir que nos encontremos en el último elemento. Si no cumple la condición de parada realiza la suma de la posición en que nos entontremos y las siguientes, para obtener finalmente el valor de la suma de todos los elementos del array tabla.

Método inverso
public void inverso(int n){
         System.out.print(n % 10);
         if (n>=10)
                inverso(n/10);
}
El parámetro de entrada del método es un número cualquiera. El método pinta por pantalla el resto de la división del número entre 10, y si el número sigue teniendo dos cifras, es decir, es mayor o igual que 10 se vuelve a llamar con número de entrada n dividido entre 10, para obtener el siguiente número a imprimir.

Método fibonacci
public long fibonacci(long num){
           if ((num == 1) || (num == 2))
                return 1;
            else         
                return (fibonacci(num-2) + fibonacci(num-1));
}
Este método requiere como parámetro de entrada un número sin decimales. La actividad que realiza es que mientra el número no sea igual a uno o a dos devuelve el resultado de llamarse a sí mismo con parámetro de entrada la suma de la llamada a sí mismo en este caso con parámetros de entrada el número del principio menos dos y el número del principio menos uno.
Por último está el método main que se encarga de hacer una prueba de todos los métodos.

EJERCICIO 3
Este ejercicio nos fue imposible de realizar por falta de tiempo, ya que los otros dos anteriores y las explicaciones del profesor para la realización de la práctica requirieron las dos horas de prácticas de las que disponíamos esa semana.
Por lo tanto nos tocará quedar algún día de la semana antes del puente para finalizarla.

Esta práctica consiste en seguir afianzando los conceptos de algoritmia, en este caso las estructuras de datos dinámicos.
En la práctica anterior implementamos una cola de manera estática, es decir, creando un array donde almacenábamos todas las piezas creadas para su posterior gestión.
En este caso debíamos transformar la cola para hacerla de forma dinámica.

Tuvimos bastantes problemas en cuanto a esta forma de realizar las colas, como por ejemplo no dar con la forma de hacerla sin utilizar arrays, vectores, colas, etc.

Mirando en los apuntes, observamos cómo se hacía mediante una clase nodo, pero realmente no entendemos como usar ese método para realizar una cola como la que se pide en la práctica. Esperamos que mirando los blogs de los demás compañero, o acudiendo a alguna tutoría con alguno de los profesores de la asignatura, podamos empezar a entender como ir realizando la cola de esta forma.

En la práctica 5 sólo nos dio tiempo a hacer el ejercicio 1 porque en la primera hora el profesor nos estuvo explicando los conceptos de:

 Polimorfismo :que es es la capacidad de un objeto de decidir a qué método invocar en función de la posición que ocupa en la jerarquía de clases.

Sobrecarga de métodos :Se produce cuando tenemos varias implementaciones de un mismo método pero con distintos parámetros.

Sobreescritura de métodos :Se produce cuando la subclase es la que implementa el método heredado de la superclase.

Luego nos explicó el concepto de clase abstracta que es aquella que define uno o más métodos abstractos.

Un método abstracto es una declaración de una interfaz(función) pero sin implementación asociada. Se declara con la palabra clave abstract y su implementación asociada se realiza en la subclase correspondiente. A esta clase se considera como una clase ya implementada.

Por último nos explicó el concepto de:

 Interfaz : que es un tipo de datos puramente abstracto que únicamente contiene métodos abstractos que no tienen implementación. Sirve para definir un comportamiento que han de cumplir los objetos que la implementen. Para ello, cualquier clase que implemente dicho interfaz lo hará mediante el uso de la palabra clave implements en la declaración de la clase y estará obligada a implementar todos los métodos de la misma. En Java sólo se puede heredar de una superclase (herencia simple), una clase sí que puede implementar cualquier número de interfaces y, además, estos pueden heredar de varios interfaces a su vez (herencia múltiple).

En el ejercicio 1, usando las soluciones de la practica anterior, teníamos que ver la implementación del método toString, y usando la herencia de clases mejorarla haciendo lo siguiente: 
en las clases Miembro,Atributo, Metodo y Constructor,tuvimos que usar el comando super para heredar los atributos de la clase superior (clase) y usarlos sin necesidad de crearlos de nuevo. En el método toString de cada clase heredada introducíamos el comando.
str += super.toString(); en los componentes comunes a la clase Miembro, dejando el resto como estaba.

Por ahora es todo lo que tenemos de esta practica,  ya que el juego nos quita bastante parte de nuestro tiempo. Cuando la acabemos editaremos este articulo para comentar los problemas y las soluciones a éstos que nos vayan surgiendo.

La practica trata sobre la implementación de una cola mediante un array (es decir, de forma estática).

Como hemos podido comprobar más adelante no es una forma muy correcta de crear este tipo de colas ya que para desencolar debemos mover todos los elementos una posicion, ya que la primera posición será siempre la posición 0 del array.

En un principio creamos la clase Cola que contiene los métodos encolar, desencolar, estaLlena y estaVacia.
El metodo encolar se encargará de añadir en la última posición la Pieza que le pasamos como parámetro. También sumará uno a la variable posición para que la proxima vez que añadamos algo a la cola se añada correctamente en la posicion que le toque.

Pieza contenido [];
      int posicion;
      int numElementos;
  
             
      public Cola(int numElementos){
             
         posicion = -1;
         this.numElementos = numElementos;
         contenido = new Pieza [numElementos];
      }

El método desencolar es la operación contraria a encolar y su función será devolverte el elemento que se encuentre en la posición 0 del array y desplazarte los demás para que la proxima vez que tengas que sacar algo encuentres algo en la primera posición. No debemos olvidar restar uno a la variable posición, para que apunte a la nueva última posición.

public void encolar(Pieza p){
             
         posicion++;
         contenido[posicion] = p;
      }
  
             
      public Pieza desencolar(){
             
         Pieza elemento = contenido[0];
         for(int i = 1; i<(numElementos-1) ;i++){
            contenido [i] = contenido [i-1];
         }
         posicion–;
         contenido [(numElementos-1)] = null;
     
         return elemento;
      }
Los métodos estaVacia y estaLlena te indican si la cola está vacía o llena respectivamente. Para ello si la variable posición es -1 (no hay nada en la posición 0 del array) te indicará que la cola está vacia y si es igual que (numeroElementos-1)(es decir, ultima posicion del array) te dirá que la cola está llena. 

public boolean estaVacia(){
             
      //Si no hay nada en la cola te devolverá true, si hay algo te devolverá false
         return (posicion == -1);
      }
  
  
             
      public boolean estaLlena(){
             
      // Si la ultima posicion es != de nulo te devolverá true,
      //si es igual a nula significa que en la ultima posicion no hay nada y por lo tanto no esta llena y devuelves false
         return (contenido[(numElementos-1)] != null);
      }

Posteriormente creamos la clase Pieza, que contiene tres atributos (tipo, x e y, siendo x e y la posicion de la pieza que en nuestro caso inicializaremos a 0 en el constructor de la clase). También contiene un método llamado mover que en este caso imprime por pantalla la frase “La pieza está quieta”. Y por último contiene un método toString que nos devuelve “La pieza es del tipo: “+tipo+”. Y su posicion es: (“+x+”, “+y+”)”, siendo en este caso tipo el tipo de pieza que sea, y x e y la posición de la pieza.

public class Pieza{
          
      char tipo;
      int x;
      int y;
  
             
      Pieza (char tipo){
             
         this.tipo = tipo;
         x = 0;
         y = 0;
      }
  
             
      public void mover(){
             
         System.out.println(“La pieza está quieta”);
      }
  
             
      public String toString(){
             
         return(“La pieza es del tipo: “+tipo+”. Y su posicion es: (“+x+”, “+y+”)”);
      }
  
   }

La clase Prueba contiene en su main la creación de varias piezas de distinto tipo, que en nuestro caso son las clases creadas en la segunda parte de la práctica y de tipo T, P, O, etc a las que no hace falta pasarles el tipo ya que heredan de la clase Pieza y en sus respectivos constructores se indica, tambien creamos un objeto de la clase Pieza en el cual tuvimos que introducirle el tipo, ya que en este caso sí hace falta indicárselo.
Añadimos las piezas a la cola e invocamos los métodos estaLlena y estaVacia, siendo las respuestas true y false en este caso. Posteriormente desencolamos todos los elementos y volvimos a preguntar estaLlena y estaVacia, en este caso con respuesta false y true.

public class Prueba{
          
  
             
      public static void main (String [] args){
             
         Pieza p1 = new Pieza(‘P’);
         System.out.println(p1.toString());
     
         PiezaT p2 = new PiezaT();
         System.out.println(p2.toString());
     
         PiezaO p3 = new PiezaO();
         System.out.println(p3.toString());
     
         PiezaL p4 = new PiezaL();
         System.out.println(p4.toString());
     
         PiezaI p5 = new PiezaI();
         System.out.println(p5.toString());
     
         PiezaS p6 = new PiezaS();
         System.out.println(p6.toString());
     
         PiezaJ p7 = new PiezaJ();
         System.out.println(p7.toString());
     
         Cola c = new Cola(7);
     
         c.encolar(p1);
         c.encolar(p2);
         c.encolar(p3);
         c.encolar(p4);
         c.encolar(p5);
         c.encolar(p6);
         c.encolar(p7);
     
     
         System.out.println(“Esta llena?”+c.estaLlena());
         System.out.println(“Esta vacía?”+c.estaVacia());
     
     
         c.desencolar();
         c.desencolar();
         c.desencolar();
         c.desencolar();
         c.desencolar();
         c.desencolar();
         c.desencolar();
     
         System.out.println(“Esta llena?”+c.estaLlena());
         System.out.println(“Esta vacía?”+c.estaVacia());
     
      }
   }

Ponemos un ejemplo de una de las clases heredadas de la clase Pieza

   public class PiezaI extends Pieza{
          
  
      public PiezaI(){

         super(‘I’);
      }
  
             
      public String toString(){
             
         return(super.toString());
      }
  
             
      public static void main(String args[]){
             
      }
   }

La práctica 4 sirve para poner en práctica los conceptos de herencia.

La introducción nos sirvió junto con las explicaciones del profesor para recordar la teoría sobre herencia y como usarla en la práctica.

Los ejercicios del 1 al 4  ponen en práctica el concepto de superclase y cómo al llamar a un método que existe en la clase padre debemos poner el comando “super”. Usando los métodos de la clase padre (Miembro.java) y modificando algo del código en cada una de las clases heredadas para añadir algun atributo o método más aparte de los heredados.

Estos 4 primeros ejercicios y parte del 5º fue lo que nos dio tiempo a realizar durante las  dos horas de prácticas. La práctica será terminada cuando encontremos un hueco en nuestras apretadas agendas… jajajaja XD (ya que el juego nos quita un poco de tiempo.)

Durante esta semana hemos acabado de hacer la práctica 3 del viernes pasado (07-03-08).

En los apartados 0 y 1 no tuvimos ningún problema, ya que el profesor explicó en la pizarra todos los conceptos necesarios para llevarlos a cabo.

A partir del ejercicio 2 todos los demás se repiten, ya que nos pedían implementar el código para el constructor y el método toString() de las distintas clases Atributo, Método, Constructor, etc.
El código empleado para el constructor this.nombre = nombre; repitiendo esto para cada uno de los atributos de la clase.
Y el empleado para el método toString() se basaría en el uso de return() poniendo en el paréntesis los Atributos que queramos que nos devuelva de cada clase, convirtiéndolos en un String que tenga la siguiente forma:

ATRIBUTO : NOMBRE=<nombre_Atributo> TIPO =java.lang.String MODIFICADOR ACCESO = public

En el ejercicio 3, comprendimos la forma de funcionamiento de la clase “Clase.java” y vimos los distintos métodos para obtener el número de atributos, constructores y métodos. Nosotros, para implementar el método toString() utilizamos la sentencia “System.out.println”  para representar los datos por pantalla, pero enseguida nos dimos cuenta que lo que había que utilizar era la sentencia return ya que en la práctica nos pide la devolución de los atributos, no imprimirlos por pantalla.

Los ejercicios 5 y 6 no pudimos terminarlos por la falta de tiempo, aunque en esta semana santa confiaremos en poder terminarla

¡¡¡Felices fiestas a todos!!!