Codigo Base de Datos

En esta entrada pondre el codigo que utilizaremos la clase del sabado para conectarnos a la base de datos(BD), para que esta clase pueda compilarse y ejecutarse correctamente es indispensable que tengamos en conector de Java con MySQL el cual lo pueden encontrar aqui.
Ya que lo bajemos es necesario agregarlo al classpath, que es decirle a la JVM donde va a buscar las clases que no conozca. Para hacer esto en eclipse damos click derecho en nuestro proyecto y en el menu vamos a Build Path>Configure Build Path...

Ahora en la ventana que se nos abre, damos click en Add External JARs... y buscamos el conector que hemos descargado, dentro del archivo que bajemos viene un archivo .jar ese es el que se agra al classpath.

Ya que hemos configurado nuestro classpath, vamos a crear la clase que nos ayudara a conectarnos a la BD en el paquete sociedad.datos

package sociedad.datos;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConexionDB {

  public static Connection conectar(String url, String usr, String pass){
   try {
    Class.forName("com.mysql.jdbc.Driver");
    return DriverManager.getConnection("jdbc:mysql://" + url, usr, pass);
   } catch (ClassNotFoundException | SQLException e) {
    e.printStackTrace();
   }
   return null;
  }

  public static void cerrarConexion(Connection cx){
   if(cx != null)
    try {
    cx.close();
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }

}

Listo con esta clase podremos abrir una conexion a la BD con el metodo conectar() y cerrar la conexion con el metodo cerrarConexion().
Para probar que todo esta jalando bien podemos utilizar el siguiente codigo:

package main;

import java.sql.Connection;
import sociedad.datos.ConexionDB;

public class Main {

 public static void main(String[] args) {

    Connection conx = ConexionDB.conectar( "127.0.0.1/sociedad" , "root" , "" );
    System.out.println(conx);
    ConexionDB.cerrarConexion(conx);
  }

}

Los parametros que le pasamos al metodo conectar son

1. host/basededatos.donde se encuentra el servidor de BD y a que base nos vamos a conectar
2. user.el usuario de la base de datos
3. password.la contraseña del servidor de BD

Listo si ejecutamos el codigo y todo esta bien nos debe de imprimir una cadena como la siguiente:

No se olviden de instalar su MySQL

Saludos!!!

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

Primeros Codigos

En esta entrada al fin publicare los códigos que hemos venido escribiendo en los cursos de los sábados, con una breve explicación.

Primero debemos crear un nuevo proyecto en Eclipse

 

Ahí se nos mostrara un asistente donde nos pedirá información básica para crear el proyecto.

Luego crearemos la clase Persona dentro del paquete sociedad, la clase persona contendrá los siguientes atributos y métodos:

package sociedad;

public class Persona {

       private String nombre;

       private float peso;

       private int edad;

       private boolean mujer;// true: mujer, false: hombre

      

       public String getNombre() {

             return nombre;

       }

      

       public float getPeso() {

             return peso;

       }

      

       public int getEdad() {

             return edad;

       }

      

       public boolean isMujer() {

             return mujer;

       }

      

       public void setNombre(String nombre) {

             this.nombre = nombre;

       }

      

       public void setPeso(float peso) {

             this.peso = peso;

       }

      

       public void setEdad(int edad) {

             this.edad = edad;

       }

      

       public void setMujer(boolean sexo) {

             this.mujer = sexo;

       }

       public Persona(){

             this.nombre = "pepito";

       }

      

       public Persona(String nombre){

             this.nombre =  nombre;

       }

      

       protected String saludar(){

             return "Hola mi nombre es " + nombre + " tengo " + edad + " años y soy " + (isMujer() ? "mujer" : "hombre");

       }

}

Ya tenemos nuestra primer clase, como podemos leer en el código los atributos de la clase son privados, es decir que únicamente la clase puede accesar a ellos; para cada atributo corresponden un par de métodos públicos, uno para establecer el valor y otro para devolverlo, esto se conoce como encapsulamiento, es decir, únicamente la clase puede acceder a sus atributos directamente las demás clases tienen que hacerlo atraves de los métodos destinados para ello.

Existe una convención para la definición de estos:

Los métodos que sirven para establecer el valor de un atributo(llamados setters), por convención se escriben de la siguiente manera:

public void setAtributo(tipo atributo){
…   
this.atributo = atributo;
}

Donde:

• public(modificador acceso): para que las demás clases puedan invocar al método
• void(tipo de dato de retorno): es el tipo de dato que nos va a regresar el método, en este caso el método no nos regresa nada
• setAtributo(nombre del método): el nombre de los setters por convención se escribe como set seguido del nombre del atributo que va a modificar con la primera letra en mayúscula
• tipo atributo(parametro): el valor que se va a establecer en el atributo

Los métodos que nos ayudan a obtener el valor de un atributo(métodos getters), son declarados de la siguiente manera:

public tipo getAtributo(){

…

return this.atributo;

}

La diferencia entre estos es básicamente:

Los setters no nos regresan ningún valor y reciben como parámetro el valor que se va a establecer en el atributo.

Los getters nos regresan el valor de un atributo y no reciben parámetros.

 ¿¿que pasa con el método isMujer()??

Este es un caso especial cuando se trata de tipos de datos booleanos, para ser mas claros en lo que estamos haciendo cambia un poco la manera de nombrar los getters , el método get lo nombramos como isMujer(), para hacer notar que si el método nos regresa true se trata de una mujer y false si se trata de un hombre.

Ya tenemos la clase persona, pero una persona puede tener distintos roles en la sociedad uno de ellos podría ser un futbolista el cual es una persona, ya que tiene los mismos atributos y métodos, además tiene características y tareas especializadas de acuerdo a su profesión.

Ahora crearemos la clase Futbolista dentro del paquete sociedad.atleta, la cual esta definida como:

package sociedad.atleta;

import java.util.ArrayList;

import sociedad.Persona;

import sociedad.atleta.util.PosicionFutbol;

public class Futbolista extends Persona {

       private String equipo;

       private ArrayList<PosicionFutbol> posicion;

      

       public String getEquipo() {

             return equipo;

       }

      

       public ArrayList<PosicionFutbol> getPosicion() {

             return posicion;

       }

      

       public void setEquipo(String equipo) {

             this.equipo = equipo;

       }

      

       public void setPosicion(ArrayList<PosicionFutbol> posicion) {

             this.posicion = posicion;

       }

      

       public void addPosicion(PosicionFutbol posicion){

             if(this.posicion == null)

                    this.posicion = new ArrayList<PosicionFutbol>();

             this.posicion.add(posicion);

       }

      

       public Futbolista(){}

      

       public Futbolista(String nombre, String equipo){

             setNombre(nombre);

             this.equipo =  equipo;

       }

      

       @Override

       public String saludar(){

             String saludo =  "Soy " + getNombre() + " juego en el " + equipo + ", y soy ";

             for(PosicionFutbol p : posicion)

                    saludo += p + ",";

             return super.saludar() + "\n" + saludo;

       }

}

Para indicar que Futbolista es una Persona y hereda todos sus atributos y métodos public y protected, utilizamos la palabra extends seguida del nombre de la clase de la cual hereda.

Tanto Futbolista como Persona tienen el método saludar, pero se comportan de manera diferente esto se conoce como polimorfismo, ya que cambia el comportamiento del método dependiendo de la clase que lo invoque.

Para ser mas claro e indicar que estamos sobreescribiendo el método usamos la anotación @Override, de esta manera podemos identificar mas rápidamente los métodos que han sido sobreescritos.

Si deseáramos invocar al método de la clase Persona utilizamos super, que nos sirve para invocar métodos y constructores de la clase padre, se utiliza de la siguiente manera:

super.metodo(); //cuando se trata de un método

//cuando se trata de constructores

super();

super(param1, …);

También notamos que la clase Futbolista tiene un atributo posicion que es un arreglo que almacena datos tipo PosicionFutbol el cual es un enum.

¿qué es un enum?

Es un conjunto de constantes que se relación entre si, en nuestro caso serán las posiciones que puede desempeñar un jugador: defensa, delantero, portero, medio.

Definimos esta enum en el paquete sociedad.atleta.util de la siguiente manera:

package sociedad.atleta.util;

public enum PosicionFutbol{

       DELANTERO, DEFENSA, PORTERO, MEDIO

}

Las posiciones se escriben en mayúsculas ya que por convención las constantes se escriben asi. De esta manera podemos acceder a ellas de la siguiente forma:

PosicionFutbol.DELANTERO;
PosicionFutbol.DEFENSA;
…

Para ver en acción las clases que hemos escrito crearemos una clase que contenga el método main, por conveniencia y de manera que podamos abstraer mas nuestro código creamos una clase en otro paquete que contenga el método main y desde ahí es donde instaciamos nuestras clases.

Una sugerencia de esta clase es la siguiente:

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());

       }

}

Donde instanciamos una clase del tipo futbolista e invocamos sus métodos setEdad(), addPosicion() y saludar()

Después de ejecutar el código en la consola nos debe de aparecer esto:

 

Al final la estructura de directorios que tendremos será la siguiente:

 

Eso ha sido todo en esta entrada, son los códigos que hemos realizado hasta el momento con algunas modificaciones.

Saludos!!!