Codigos Fuera de Clase

Los siguientes codigos son para darle un poco mas de complejidad a los que hemos estado viendo en el curso, leeanlos, cualquier duda manden un correo, dejen un comentario, una mentada lo que sea.

Empecemos por definir un concepto nuevo, las clases abstractas, tienen la caracteristica principal de que no pueden ser instanciadas, es decir, no podemos crear un objeto del tipo de una clase abstracta. Ademas las clases contienen metodos abstractos, los cuales son metodos que unicamente estan definidos pero su cuerpo esta vacio y debe ser implementado en las clases que heredan.

Estas clases nos sirven para modelar de manera mas eficiente el comportamiento de las clases que heredan de ella.

¿pero para que me sirve una clase que no puede ser instanciada?

Tomemos el ejemplo que hemos venido trabajando, podemos decir que una Persona es un Ser, pero no sabemos concretamente que es un ser solo conocemos sus atributos y metodos; no podemos crear un Ser asi como asi, este debe ser una persona, un animal, alf o lo que sea, por lo tanto todos los que se digan seres deben tener atibutos y metodos en comun.

Siendo asi definimos la clase Ser dentro del paquete universo de la siguiente manera:

  package universo;

  public abstract class Ser {
   private int vida = (int) (Math.random() * 10 + 1);

   protected void vivir(){
    vida--;
   }
  
   protected int getVida(){
    return this.vida;
   }

   protected abstract void respirar();
  }

Para indicarle a la JVM que se trata de una clase abstracta debemos de utilizar la palabra abstract en la declaracion de la clase. De igual manera agregamos la palabara abstract en la firma del metodo para indicar que este es abstracto y por lo tanto debe estar vacio.

Ahora debemos de cambiar la definicion de la clase Persona para que herede de Ser

  package sociedad;

  import universo.Ser;

  public class Persona extends Ser {
   private String nombre;
   private float peso;
   private int edad;
   private boolean mujer;// true: mujer, false: hombre
   private Thread viviendo = new Thread(){
    @Override
    public void run(){
     while(getVida() > 0 ){
      vivir();
      System.out.println(nombre + ": Tengo " + getVida() + " de vida");
      try {
       Thread.sleep(2500);
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
     }
     System.out.println("RIP " + nombre);
    }
   };

  //...aqui va todo el codigo que hemos hecho

   public Persona(){
    this.nombre = "pepito";
    viviendo.start();
   }

   @Override
   public void respirar() {
    System.out.println("estoy respirando");
   }
  }

<

Observamos algunos cambios en la clase.

1. En su declaracion decimos que hereda de Ser
2. Agregamos un nuevo atributo del tipo Thread llamado viviendo, este nos sera muy util para utilizar el metodo vivir de la clase padre.
3. Hemos cambiado el constructod por defecto para que invoque a viviendo.start()
4. Finalmente implementamos el metodo abstracto respirar() -sin mucha imaginacion cuando lo hice ¬¬

espera, espera, ¿que es eso de Thread?

Un thread o hilo, es una fraccion de codigo que se ejecuta de manera paralela al flujo principal del programa, en este caso lo utilizamos para invocar al metodo vivir mientras realizamos otras tareas con nuestra clase Persona.

La implementacion de un hilo en esta clase fue express solamente la puse para ilustrar un poco los hilos, ya que eston son bastante complejos y nos llevaria un rato aprenderlos.

En el codigo

  private Thread viviendo = new Thread(){
   @Override
   public void run(){
    while(getVida() > 0 ){
       vivir();
         System.out.println(nombre + ": Tengo " + getVida() + " de vida");
       try {
         Thread.sleep(2500);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    System.out.println("RIP " + nombre);
   }
  };

lo que hicimos fue crear un nuevo hilo de ejecucion cada vez que se instancie la clase, todos los hilos deben de sobreescribir el metodo run().

Con el metodo sleep() le decimos al hilo que detenga su ejecucion durante un tiempo en milisegundos, este metodo lanza una excepcion en caso de que no pueda mandar a dormir al hilo.

  public Persona(){
   this.nombre = "pepito";
   viviendo.start();
  }

Cuando invocamos el metodo start() es la señal para que el hilo comience a trabajar.

Ya hemos terminado con la clase Persona, bien ahora lo que sigue; en Java existe un concepto llamado interface, las cuales son un conjunto de metodos abstractos y constantes que tiene una relacion entre si.

En Java solo se puede heredar de una clase y se pueden implementar N interfaces

Ahora definimos una interface dentro del paquete sociedad.atleta.util

  package sociedad.atleta.util;

  public interface Atleta {

   Atleta competir(Atleta oponente);

   void entrenar();
  }

La interface solo tiene dos metodos competir() y entrenar(), los cuales deben ser implementados en todas las clases que implemente la interface, nosotros vamos a implementarla en la clase Futbolista de la siguiente forma:

  package sociedad.atleta;

  import java.util.ArrayList;
  import sociedad.Persona;
  import sociedad.atleta.util.Atleta;
  import sociedad.atleta.util.PosicionFutbol;

  public class Futbolista extends Persona implements Atleta {
   private String equipo;
   private ArrayList posicion;
   private int poder;
   
   public int getPoder() {
    return poder;
   }
   
   public void setPoder(int poder) {
    this.poder = poder;
   }
   
  //...todo lo demas

   @Override
   public Atleta competir(Atleta oponente) {
    if(this.getPoder() > ((Futbolista)(oponente)).getPoder())
     return this;
    else
     return oponente;
   }
  
   @Override
   public void entrenar() {
    this.poder++;
   }
  }

Con la palabra implements indicamos que la clase va a implementar los metodos de la interface.

Los cambios en la clase son:

• Agregamos el atributo poder, para indicar el nivel de destreza del jugador
• Implementamos el metodo competir(), el cual unicamente compara el atributo poder del objeto que se pasa por parametro contra el valor que tiene el objeto this y regresa el que tenga mayor poder.
• Implementamos el metodo entrenar(), que aumenta el poder de cada objeto.

Finalmente hechemos a andar este cacharro, en nuestra clase principal:

package main;

  import sociedad.atleta.Futbolista;
  import sociedad.atleta.util.PosicionFutbol;

  public class Main {
   public static void main(String[] args) {
    Futbolista jorge = new Futbolista("Jorge Campos","Pumas");
    jorge.setEdad(34);
    jorge.addPosicion(PosicionFutbol.PORTERO);
    jorge.addPosicion(PosicionFutbol.DELANTERO);
    System.out.println(jorge.saludar());
    
    jorge.entrenar();
    
    Futbolista temo = new Futbolista("El Cuau","America");
    
    Futbolista ganador = (Futbolista) (jorge.competir(temo));
    System.out.println("\tEl ganador es " + ganador.getNombre());
   }
  }

Despues de compilar y ejecutar nos arrojara algo como esto en la terminal, dependiendo de cuanto entrene y cuanta vida tenga nuestro jugador

Saludos!!!

No se olviden de instalar el plugin WindowBuilder Pro, para ver GUIs en Java el proximo sabado