Sesión 3

API de Java. Métodos y objetos. Modificador static. Herencia.

1. El API de Java

Vamos a comenzar con un ejercicio para aprender a consultar el API de Java (y algunas cosas más).

1. Repasa la sección API de Java del apartado 1.1.1 de los apuntes.
2. Busca en el API de Java el paquete java.util.zip. Consultando la página HTML que describe el paquete, contesta en el fichero respuestas.txt las siguientes preguntas:
   • ¿Para qué es el paquete?
   • ¿Qué interfaces, clases y excepciones se declaran en el paquete?
3. Busca en el API la clase Stack. Contesta en el fichero respuestas.txt las siguientes preguntas:
• ¿En qué paquete se encuentra la clase Stack? ¿Qué instrucción import tendrías que definir para usar la clase Stack?
• ¿Qué constructores tiene la clase?
• ¿Qué métodos modifican el estado de un objeto Stack?
• ¿De qué clase son los objetos que puedes añadir y obtener de un stack?
• El siguiente código no es correcto, ¿por qué? (consulta el apartado 1.7.3 de los apuntes) ¿Cuál sería el código correcto?
  

  int i = 10;
  Stack pila = new Stack();
  pila.add(i);

  Nota: en la versión 1.5 de Java y en BeanShell el código de arriba es correcto ya que usan una técnica denominada autoboxing.
  
4. Ejecuta en BeanShell un conjunto instrucciones que trabajen con un Stack. Recuerda que para visualizar el valor de un objeto o en BeanShell debes usar el comando print(o). Copia la sesión de interacción con BeanShell en el fichero respuestas.txt.

2. Métodos y objetos

Vamos a hacer un ejercicio más elaborado en el que se definan clases y objetos. Puedes usar el entorno de desarrollo que desees. Si tu ordenador no tiene la potencia (memoria sobre todo) suficiente para que Eclipse funcione con fluidez usa algún editor de texto para editar las clases.

Todas las clases las vamos a definir en el paquete modulo1.sesion3. Se encuentran en la plantilla de ejercicios de la sesión 3.

1. Supongamos las siguientes clases Contador y ContadorTest
   

   package modulo1.sesion3;
   public class Contador {
       static int acumulador = 0;
       int valor;
       
       static public int acumulador() {
           return acumulador;
       }
   
       public Contador(int valor) {
           this.valor = valor;
           acumulador += valor;
           // no es valido this.acumulador
           // es valido Contador.acumulador
       }    
       
       public void inc() {
          valor++;
          acumulador++;
       }
       
       public int getValor(){
           return valor;
       }
   }

   package modulo1.sesion3;
   
   public class ContadorTest {
   
       public static void main(String[] args) {
           Contador c1, c2;
           
           System.out.println(Contador.acumulador());     
           c1 = new Contador(3);
           c2 = new Contador(10);
           c1.inc();
           c1.inc();
           c2.inc();
           System.out.println(c1.getValor());
           System.out.println(c2.getValor());
           System.out.println(Contador.acumulador);        
       }
   }
   

   Compila las clases y pruébalas. Responde a las siguientes preguntas en el fichero respuestas.txt:
   • ¿Se pueden realizar las siguientes modificaciones en el código de la clase Contador? ¿Por qué?
     
     1. Cambiar "acumulador += valor" en el constructor Contador por "this.acumulador += valor".
     2. Cambiar "acumulador += valor" en el constructor Contador por "Contador.acumulador += valor".
     3. Cambiar "valor++" por "this.valor++" en el método inc().
        
   • ¿Qué valores imprime el programa ContadorTest?
   • Si cambiamos en la clase Contador la línea "static int acumulador = 0" por "private static int acumulador = 0", ¿aparece algún error? ¿por qué?
   • ¿Qué sucede si no inicializamos el valor del campo acumulador?
     
2. Vamos a complicar un poco más el código de Contador, añadiendo una constante (VALOR_INICIAL) a la clase y otro nuevo constructor. El código es el que sigue (en negrita lo que se ha añadido). El modificador final indica que el valor asignado a VALOR_INICIAL no puede modificarse.
   

   package modulo1.sesion3;
   
   public class Contador {
       static int acumulador;
       final static int VALOR_INICIAL=10;
       int valor;
       
       static public int acumulador() {
           return acumulador;
       }
   
       public Contador(int valor) {
           this.valor = valor;
           acumulador += valor;
       }    
       
       public Contador(){
           this(Contador.VALOR_INICIAL);
       }
   
       public void inc() {
          this.valor++;
          acumulador++;
       }
       
       public int getValor(){
           return this.valor;
       }
   }
   

   Fíjate en la llamada "this(Contador.VALOR_INICIAL)". ¿Qué hace? Escribe un programa ejemplo ContadorTest2 que compruebe el funcionamiento de la clase modificada. Por último, una pregunta algo complicada: ¿Qué sucede si cambiamos la línea "this(Contador.VALOR_INICIAL)" por "new Contador(Contador.VALOR_INICIAL)"?
3. Por último, realiza las siguientes modificaciones en la clase Contador:
   • Añade una variable de clase nContadores que contenga el número de contadores creados
   • Añade una variable de clase valores que contenga un array con los valores de los contadores creados.
   • Añade un metodo getValores que devuelva un array con los valores de los contadores creados.

3. Un ejemplo de herencia

1. En el fichero de plantillas de esta sesión encontrarás los ficheros Figura.java, Circulo.java, Rectangulo.java y FiguraTest.java, que contienen el siguiente código:
   

   package modulo1.sesion3;
   
   public abstract class Figura {
       double area;
   
       public abstract double getArea();
   }
   

   package modulo1.sesion3;
   
   class Circulo extends Figura {
       double radio;
   
       public Circulo(double radio) {
           this.radio = radio;
       }
   
       public double getArea() {
           area = 3.14 * (radio * radio);
           return (area);
       };
   }
   

   package modulo1.sesion3;
   
   class Rectangulo extends Figura {
       double lado;
       double altura;
   
       public Rectangulo(double lado, double altura) {
           this.lado = lado;
           this.altura = altura;
       }
   
       public double getArea() {
           area = lado * altura;
           return (area);
       };
   
   }

   package modulo1.sesion3;
   
   import java.util.Stack;
   
   public class FiguraTest {
       public static void main(String args[]) {
           Figura f;
   
           Rectangulo rect = new Rectangulo(10, 15);
           System.out.println("El area del rectangulo es: " + rect.getArea());
   
           Circulo circ = new Circulo(3);
           System.out.println("El area del circulo es: " + circ.getArea());
   
           Stack pila = new Stack();
           pila.push(rect);
           pila.push(circ);
   
           while (!pila.isEmpty()) {
               f = (Figura) pila.pop();
               System.out.println("El area de la figura es: " + f.getArea());
           }
       }
   }

2. Compila las clases y ejecuta el ejemplo. Contesta las siguientes preguntas en el fichero respuestas.txt:
   
   • ¿Podría crear un objeto de tipo Figura? ¿Por qué?
   • ¿Por qué puedo añadir a la pila objetos de tipo Rectangulo y Circulo, siendo tipos diferentes?
   • Supongamos un método como el siguiente

     public void draw(Figura fig);

     ¿Podría pasar un objeto de la clase Circulo como parámetro del método? ¿Y un objeto de la clase Rectangulo? ¿Y un objeto de la clase plj.geom.Rect?
   • ¿Cómo se deberían modificar las clases para que el método getArea() no fuera abstracto, sino que tuviera la implementación definida en la clase Figura (y funcione correctamente, claro).

4. Crea una jerarquía de clases

Define e implementa un ejemplo de jerarquía de clases. Recuerda algunas reglas básicas sobre herencia de clases:

• Una subclase A hereda de una superclase B si pasa el test ES-UN. Este test consiste, sencillamente, en comprobar que A ES-UN B. Por ejemplo, un Sonar ES-UN Sensor. O también, un Perro ES-UN Animal. O también, un Empleado ES-UNA Persona. Pero un Animal no ES-UN Naturaleza (por lo que Animal no puede ser subclase de Naturaleza).
• Construye una subclase sólo cuando necesites hacer una versión más específica de una clase y necesites sobrecargar o añadir nuevas conductas.
• Usa una clase abstracta cuando quieras definir una plantilla para para un grupo de subclases, y tengas algún código de implementación que todas las clases puedan usar. Haz la clase abstracta cuando quieras garantizar que nadie va a hacer objetos de esa clase.

PARA ENTREGAR

Debes crear un ZIP llamado sesion3.zip con:

• El fichero de texto respuestas.txt con las cuestiones contestadas.
• Los ficheros con las clases que has implementado y modificado.