package clases;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

/**
 * @author CHENAO
 * 
 */
public class Principal {

 public static void main(String arg[]) {

  Principal miPrincipal = new Principal();
  miPrincipal.leerArchivo();
 }

 /**
  * Lee un archivo de propiedades desde una ruta especifica
  * y se imprime en pantalla.
  */
 private void leerArchivo() {
  try {

/**Creamos un Objeto de tipo Properties*/
   Properties propiedades = new Properties();

   /**Cargamos el archivo desde la ruta especificada*/
   propiedades
     .load(new FileInputStream(
       "D:/HENAO/codejavu/Workspace/PruebaProperties/src/properties/archivo.properties"));

   /**Obtenemos los parametros definidos en el archivo*/
   String nombre = propiedades.getProperty("nombre");
   String pagina = propiedades.getProperty("pagina");

   /**Imprimimos los valores*/
   System.out.println("Nombre: "+nombre + "\n" +"Pagina: "+ pagina);


  } catch (FileNotFoundException e) {
   System.out.println("Error, El archivo no exite");
  } catch (IOException e) {
   System.out.println("Error, No se puede leer el archivo");
  }
 }
}

• Tutorial Aplicaciones Web con Jboss Seam
• Despliegue de Aplicación Web Con Ant
• Instalación del servidor de aplicaciones JBoss
• Configuración Ambiente de Desarrollo... Descarga de Eclipse
• Trabajando con SVN desde Eclipse

• Integración Continua, Primeros Pasos Con Jenkins
• Leer Archivo Properties en Java
• Tutorial Proyecto Web Con Eclipse
• Instalación del servidor de aplicaciones JBoss
• Instalación Apache ANT

• Integración Continua, Primeros Pasos Con Jenkins
• Instalación Jenkins en Windows.
• Instalación JDK
• Leer Archivo Properties en Java
• Tutorial Proyecto Web Con Eclipse

• Habilitar seguridad en el proyecto: Al seleccionar esta opción podemos configurar los usuarios a los que les vamos a asignar permisos sobre la tarea, por ejemplo si un usuario es agregado y se activa solo el check “Read”, este usuario solo podrá visualizar la tarea, pero no podrá efectuar ninguna otra acción (para estos casos también se debe tener en cuenta los permisos otorgados al usuario al momento de su creación, pues si es un administrador podrá efectuar cualquier acción).

• Configurar el origen del código fuente: en esta sección definiremos cual es el sistema de control de versiones con el que vamos a trabajar y la ruta del repositorio donde se encuentra el proyecto, además dejamos la opción por defecto “Use ‘svn update’ as a much as possible” para que la tarea siempre realice una actualización de los archivos modificados en el repositorio y no un checkout completo.

• Ejecutar Tareas En Jenkins
• Instalación Jenkins en Windows.
• Opciones de Seguridad en Jenkins
• Instalación JDK
• Leer Archivo Properties en Java
• Tutorial Proyecto Web Con Eclipse

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;


/**
 * @author HENAO
 *
 */
public class Principal {

 /**
  * @param args
  */
 public static void main(String[] args) {

 /**Objeto de la clase */
 Principal objetoPrincipal=new Principal();

 String fecha1 = "12/05/2013";  
 String fecha2 = "13/05/2013";  
 String fecha3 = "14/05/2013";  

 /**Obtenemos la fecha del sistema y la convertirmos al String
  *  con el formato en el que vamos a trabajar*/
 Date fechaActual = new Date();
        SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy");
        String fechaSistema=formateador.format(fechaActual);

        /**Realizamos los llamados a los metodos de ejemplo*/

        System.out.println("\n********************************" +
          "****************************\n");

 String resultadoMenor=objetoPrincipal.compararFechasConDate(fecha1,fechaSistema);
 System.out.println(resultadoMenor+"\n");

 System.out.println("******************************" +
    "******************************\n");


 String resultadoIgual=objetoPrincipal.compararFechasConDate(fecha2,fechaSistema);
 System.out.println(resultadoIgual+"\n");

 System.out.println("******************************" +
    "******************************\n");

 String resultadoMayor=objetoPrincipal.compararFechasConDate(fecha3,fechaSistema);
 System.out.println(resultadoMayor+"\n");

 System.out.println("*****************************" +
    "*******************************\n");
 }

 /**
  * Comparamos las Fechas
  * @author CHENAO
  * @param fecha1
  * @param fechaActual
  * @return
  */
 private String compararFechasConDate(String fecha1, String fechaActual) {  
  System.out.println("Parametro String Fecha 1 = "+fecha1+"\n" +
    "Parametro String fechaActual = "+fechaActual+"\n");  
  String resultado="";
  try {
   /**Obtenemos las fechas enviadas en el formato a comparar*/
   SimpleDateFormat formateador = new SimpleDateFormat("dd/MM/yyyy"); 
   Date fechaDate1 = formateador.parse(fecha1);
   Date fechaDate2 = formateador.parse(fechaActual);

   System.out.println("Parametro Date Fecha 1 = "+fechaDate1+"\n" +
     "Parametro Date fechaActual = "+fechaDate2+"\n");

    if ( fechaDate1.before(fechaDate2) ){
    resultado= "La Fecha 1 es menor ";
    }else{
     if ( fechaDate2.before(fechaDate1) ){
      resultado= "La Fecha 1 es Mayor ";
     }else{
      resultado= "Las Fechas Son iguales ";
     } 
    }
  } catch (ParseException e) {
   System.out.println("Se Produjo un Error!!!  "+e.getMessage());
  }  
  return resultado;
 }
}

• Conceptos Básicos de Programación Orientada a Objetos
• Instalación de Jenkins en Windows
• Tutorial Aplicaciones Web con Jboss Seam
• Despliegue de Aplicación Web Con Ant
• Instalación del servidor de aplicaciones JBoss
• Configuración Ambiente de Desarrollo... Descarga de Eclipse
• Trabajando con SVN desde Eclipse

private void metodosString() {
    String cadena1=" Esto Es Un String ";

    /**Imprime la cadena original*/
    System.out.println("Cadena Original = "+cadena1);
    /**retorna la letra s (cuenta tomando el primer caracter como 0 )*/
    System.out.println("Usando charAt(2) = "+cadena1.charAt(2));
    /**retorna la posicion 9 (cuenta tomando el primer caracter como 0 )*/
    System.out.println("Usando indexOf(\"Un\") = "+cadena1.indexOf("Un"));
    /**retorna el tamaño 19 */
    System.out.println("Usando length() = "+cadena1.length());
    /**reemplaza la cadena "un" por la cadena "xxx"*/
    System.out.println("Usando replace(\"Un\", \"xxx\") = "+cadena1.replace("Un", "xxx"));
    /**convierte la cadena en mayusculas*/
    System.out.println("Usando toUpperCase() = "+cadena1.toUpperCase());
    /**convierte en minusculas*/
    System.out.println("Usando toLowerCase() = "+cadena1.toLowerCase());
    /**Elimina los espacios en blanco al principio y final de la cadena*/
    System.out.println("Usando trim() = "+cadena1.trim());
    /**Concatena al String el valor enviado*/
    System.out.println("Usando concat(\" En CoDejaVu\") = "+cadena1.concat("En CoDejaVu"));
    /**elimina la cadena de la posicion 0 a la 5*/
    System.out.println("Usando substring(6) = "+cadena1.substring(6));
    /**elimina la cadena de la posicion 4 a la 14*/
    System.out.println("Usando substring(4, 14) = "+cadena1.substring(4, 14));
    /**indica si dos cadenas son iguales, enviamos la misma cadena, retorna true*/
    System.out.println("Usando equalsIgnoreCase(cadenaOriginal) = "+cadena1.equalsIgnoreCase(cadena1));
    /**indica si dos cadenas son iguales, enviamos otra cadena, retorna false*/
    System.out.println("Usando equalsIgnoreCase(otroString) = "+cadena1.equalsIgnoreCase("Otro String")); 
 }

private void metodosStringBuilder() {
        StringBuilder cadena1=new StringBuilder(" Esto Es Un StringBuilder ");
 /**Imprime la cadena original*/
 System.out.println("Cadena Original = "+cadena1);
 /**concatena la cadena enviada como parametro*/
 System.out.println("Usando append(\"En CoDejaVu\") = "+cadena1.append("En CoDejaVu"));
 /**Elimina la cadena desde la posicion inicial hasta la final*/
 System.out.println("Usando delete(32, 37) = "+cadena1.delete(32, 37));
 /**Inserta la cadena enviada desde la posicion inicial*/
 System.out.println("Usando insert(32, String) = "+cadena1.insert(32, "ejaVu Otra Vez"));
 /**Reemplaza la cadena enviada en las posiciones definidas*/
 System.out.println("Usando replace(2, 4, String) = "+cadena1.replace(2, 4, "xxx"));
 /**Imprime la cadena en reversa*/
 System.out.println("Usando reverse() = "+cadena1.reverse());
    }

/**
 * @author HENAO
 *
 */
public class Cadenas {

 /**
  * constante que determina el numero de repeticiones 
  * en cada uno de los tres metodos de concatenacion
  */
 public final long ITERA = 100000;
 /**determina el tiempo total de concatenacion*/
 private long tiempo;

 /**
  * @param args
  */
 public static void main(String[] args) {

   Cadenas objetoCadenas=new Cadenas();
   String valorCadena="CoDejaVu";
   String usoString=objetoCadenas.calculaTiempoString(valorCadena);
   String usoStringBuffer=objetoCadenas.calculaTiempoStringBuffer(valorCadena);
   String usoStringBuilder=objetoCadenas.calculaTiempoStringBuilder(valorCadena);

   System.out.println("Tiempo Concatenacion String : "+usoString+
  "\nTiempo Concatenacion StringBuffer : "+usoStringBuffer+
   "\nTiempo Concatenacion StringBuilder : "+usoStringBuilder);  
 }


 /**
  * Metodo que calcula el tiempo de concatenacion de la cadena
  * usando la clase String
  * @param valor dato ingresado por el usuario
  * @return tiempo en milisegundos
  */
 public String calculaTiempoString(String valor) 
 {
  String cadena = "";
  tiempo = System.currentTimeMillis();
  for (int i = 0; i < ITERA ; i++) {
   cadena += valor;
  }
  tiempo = System.currentTimeMillis() - tiempo;
  return tiempo + " milisegundos";
 }

 /**
  * Metodo que calcula el tiempo de concatenacion de la cadena
  * usando la clase StringBuffer
  * @param valor dato ingresado por el usuario
  * @return tiempo en milisegundos
  */
 public String calculaTiempoStringBuffer(String valor) 
 {
  StringBuffer cadena = new StringBuffer();
  long tiempo = System.currentTimeMillis();
  for (int i = 0; i < ITERA ; i++) {
   cadena.append(valor);
  }
  tiempo = System.currentTimeMillis() - tiempo;
  return tiempo + " milisegundos";
 }
 /**
  * Metodo que calcula el tiempo de concatenacion de la cadena
  * usando la clase StringBuilder
  * @param valor dato ingresado por el usuario
  * @return tiempo en milisegundos
  */
 public String calculaTiempoStringBuilder(String valor)
 {
  StringBuilder cadena = new StringBuilder();
  tiempo = System.currentTimeMillis();
  for (int i = 0; i < ITERA ; i++) {
   cadena.append(valor);
  }
  tiempo = System.currentTimeMillis() - tiempo;
  return tiempo + " milisegundos";
 }
}

• Conceptos Básicos de Programación Orientada a Objetos
• Comparando Fechas En Java
• Tutorial Aplicaciones Web con Jboss Seam
• Despliegue de Aplicación Web Con Ant
• Instalación del servidor de aplicaciones JBoss
• Configuración Ambiente de Desarrollo... Descarga de Eclipse
• Trabajando con SVN desde Eclipse

/**Creamos el objeto como instancia de la clase Principal*/
    Principal miObjeto= new Principal();
    miObjeto.atributo="Este es el nuevo valor del atributo para el objeto";
    miObjeto.metodo();

public class Principal{

  public String atributo1;
  private String atributo2;
  protected String atributo3;

  /**Métodos Set y Get para trabajar con las variables*/

  public String getAtributo2() {
 return atributo2;
  }

  public void setAtributo2(String atributo2) {
 this.atributo2 = atributo2;
  }

}

public abstract class Principal{

    /**Método Abstracto sin implementación*/
    public abstract void metodoAbstracto();

}

class subClase extends Principal{

 @Override
 public void metodoAbstracto() {
  /**Implementación definida por la clase concreta*/
 }

}

Las interfaces son el mecanismo que utiliza Java para simular la herencia múltiple, como mencionamos en Java solo se puede extender de una sola clase, mediante el uso de interfaces esto se puede simular ya que el lenguaje permite implementar el numero de interfaces que necesitemos, básicamente son clases completamente abstractas, es común relacionarlas con un contrato en el que se define que se debe hacer, así cada clase concreta que implemente una interfaz esta obligada a implementar todos los métodos que la compongan.

interface InterfacePrincipal {

 public void metodoAbstracto();

 public String otroMetodoAbstracto();

}

public class Principal implements InterfacePrincipal{

 public void metodoAbstracto() {
  /**Implementación definida por la clase concreta*/
 }

 public String otroMetodoAbstracto() {
  /**Implementación definida por la clase concreta*/
  return "retorno";
 }
}

class FiguraGeometrica{

}

class Cuadrado extends FiguraGeometrica {

}

class Triangulo extends FiguraGeometrica {

}

class Circulo extends FiguraGeometrica{

}

public class Principal{

   public void metodo(){
 /**Puedo crear objetos concretos*/
 FiguraGeometrica miFiguraGeometrica = new FiguraGeometrica();
 Cuadrado miCuadro=new Cuadrado();

 /**Puedo crear objetos polimorficos*/
 miFiguraGeometrica=miCuadro;

 /**Objeto Cuadrado de tipo FiguraGeometrica*/
 FiguraGeometrica miCuadrado= new Cuadrado();
 /**Objeto Circulo de tipo FiguraGeometrica*/
 FiguraGeometrica miCirculo=new Circulo();
 /**Objeto Triangulo de tipo FiguraGeometrica*/
 FiguraGeometrica miTriangulo=new Triangulo();
 }
}

• Herencia en Java.
• ¿ String Vrs StringBuffer Vrs StringBuilder ?
• Comparando Fechas En Java
• Tutorial Aplicaciones Web con Jboss Seam
• Despliegue de Aplicación Web Con Ant
• Instalación del servidor de aplicaciones JBoss
• Trabajando con SVN desde Eclipse

public class Principal {

 /**
  * @param args
  */
 public static void main(String[] args) {

 System.out.println("*********************************************************************");
 System.out.println("*                        << CoDejaVu >>                             *");
 System.out.println("*                                                                   *");
 System.out.println("*********************************************************************");
 System.out.println();
 System.out.println("-------------------<< Clase Padre Vehiculo >>-----------------------");
 Vehiculo miVehiculo = new Vehiculo();
 miVehiculo.nombreVehiculo="El Gran Transportador";
 System.out.println("usando miVehiculo, nombreVehiculo : "+miVehiculo.nombreVehiculo);
 System.out.println("usando miVehiculo llama a: "+miVehiculo.transportar());
 System.out.println("--------------------------------------------------------------------");
 System.out.println();

 System.out.println("----------<< SubClase hija Acuatico Extiende de Vehiculo >>---------");
 Acuatico miAcuatico= new Acuatico();
 miAcuatico.nombreVehiculo="El Navegante";
 System.out.println("usando miAcuatico, nombreVehiculo : "+miAcuatico.nombreVehiculo);
 System.out.println("usando miAcuatico llama a : "+miAcuatico.transportar());
 System.out.println("usando miAcuatico llama a : "+miAcuatico.navegar());
 System.out.println("---------------------------------------------------------------------");
 System.out.println();

 System.out.println("-----<< SubClases hijas extienden de la Subclase Padre Acuatico>-----");
 Barco miBarco=new Barco();
 miBarco.nombreVehiculo="Titanic";
 System.out.println("usando miBarco, nombreVehiculo : "+miBarco.nombreVehiculo);
 System.out.println("usando miBarco llama a : "+miBarco.transportar());
 System.out.println("usando miBarco llama a : "+miBarco.navegar());
 System.out.println("usando miBarco llama a : "+miBarco.prenderMotor());
 System.out.println();

 Velero miVelero=new Velero();
 miVelero.nombreVehiculo="Tormenta";
 System.out.println("usando miVelero, nombreVehiculo : "+miVelero.nombreVehiculo);
 System.out.println("usando miVelero llama a : "+miVelero.transportar());
 System.out.println("usando miVelero llama a : "+miVelero.navegar());
 System.out.println("usando miVelero llama a : "+miVelero.izarVelas());
 System.out.println("---------------------------------------------------------------------");

 System.out.println("----------<< SubClase hija Aereo Extiende de Vehiculo >>---------");
 Aereo miAereo= new Aereo();
 miAereo.nombreVehiculo="El Volador";
 System.out.println("usando miAereo, nombreVehiculo : "+miAereo.nombreVehiculo);
 System.out.println("usando miAereo llama a : "+miAereo.transportar());
 System.out.println("usando miAereo llama a : "+miAereo.volar());
 System.out.println("---------------------------------------------------------------------");
 System.out.println();

 System.out.println("-----<< SubClases hijas extienden de la Subclase Padre Aereo >-----");
 Avion miAvion=new Avion();
 miAvion.nombreVehiculo="El Condor";
 System.out.println("usando miAvion, nombreVehiculo : "+miAvion.nombreVehiculo);
 System.out.println("usando miAvion llama a : "+miAvion.transportar());
 System.out.println("usando miAvion llama a : "+miAvion.volar());
 System.out.println("usando miAvion llama a : "+miAvion.bajarTrenDeAterrizaje());
 System.out.println();

 Helicoptero miHelicoptero=new Helicoptero();
 miHelicoptero.nombreVehiculo="El lobo del Aire";
 System.out.println("usando miHelicoptero, nombreVehiculo : "+miHelicoptero.nombreVehiculo);
 System.out.println("usando miHelicoptero llama a : "+miHelicoptero.transportar());
 System.out.println("usando miHelicoptero llama a : "+miHelicoptero.volar());
 System.out.println("usando miHelicoptero llama a : "+miHelicoptero.encenderHelices());
 System.out.println("---------------------------------------------------------------------");
 System.out.println();

 System.out.println("--<< Propiedad de la clase Vehiculo usada por todas las clases Hijas >--");
 System.out.println("nombre Vehiculo :"+miVehiculo.nombreVehiculo);
 System.out.println("nombre Acuatico :"+miAcuatico.nombreVehiculo);
 System.out.println("nombre Aereo :"+miAereo.nombreVehiculo);
 System.out.println("nombre Barco :"+miBarco.nombreVehiculo);
 System.out.println("nombre Velero :"+miVelero.nombreVehiculo);
 System.out.println("nombre Avion :"+miAvion.nombreVehiculo);
 System.out.println("nombre Helicoptero :"+miHelicoptero.nombreVehiculo);
 System.out.println("---------------------------------------------------------------------");

 }
}

• Conceptos Básicos de Programación Orientada a Objetos.
• ¿ String Vrs StringBuffer Vrs StringBuilder ?
• Comparando Fechas En Java
• Tutorial Aplicaciones Web con Jboss Seam
• Instalación del servidor de aplicaciones JBoss
• Configuración Ambiente de Desarrollo... Descarga de Eclipse
• Trabajando con SVN desde Eclipse

• Herencia en Java.
• Conceptos Básicos de Programación Orientada a Objetos.
• ¿ String Vrs StringBuffer Vrs StringBuilder ?
• Comparando Fechas En Java
• Tutorial Aplicaciones Web con Jboss Seam
• Instalación del servidor de aplicaciones JBoss

• Una clase Abstracta No puede ser instanciada (no se pueden crear objetos directamente - new ), solo puede ser heredada. 
• Si almenos un método de la clase es abstract, esto obliga a que la clase completa sea definida abstract, sin embargo la clase puede tener el resto de métodos no abstractos.
• Los métodos abstract no llevan cuerpo (no llevan los caracteres {}). 
• La primer subclase concreta que herede de una clase abstract debe implementar todos los métodos de la superclase.
  

/**
 * Clase Abstracta Instrumento
 */
abstract class Instrumento{ 

 public String tipo;

 public abstract void tocar();
}

/**
 * Clase Concreta Guitarra, hija de Instrumento
 */
class Guitarra extends Instrumento {

 public Guitarra(){
  tipo="Guitarra";
 }

 public void tocar() {
  System.out.println("Tocar La Guitarra");
 }
}

/**
 * Clase Concreta Violin, hija de Instrumento
 */
class Violin extends Instrumento {

 public Violin(){
  tipo="Violin";
 }

 public void tocar() {
  System.out.println("Tocar El violin");
 }
}

/**
 * Clase Concreta Saxofon, hija de Instrumento
 */
class Saxofon extends Instrumento {

 public Saxofon(){
  tipo="Saxofon";
 }

 public void tocar() {
  System.out.println("Tocar el Saxofon");
 }
}

public class Principal {

 public static void main(String arg[]){
  /**Objeto miGuitarra de tipo Instrumento */
  Instrumento miGuitarra= new Guitarra();
  System.out.println("Instrumento : "+miGuitarra.tipo);
  miGuitarra.tocar();
  System.out.println();
  /**Objeto miSaxofon de tipo Instrumento */
  Instrumento miSaxofon= new Saxofon();
  System.out.println("Instrumento : "+miSaxofon.tipo);
  miSaxofon.tocar();
  System.out.println();
  /**Objeto miViolin de tipo Instrumento */
  Instrumento miViolin= new Violin();
  System.out.println("Instrumento : "+miViolin.tipo);
  miViolin.tocar();

 }

}

• Clases en Java.
• Herencia en Java.
• Conceptos Básicos de Programación Orientada a Objetos.
• ¿ String Vrs StringBuffer Vrs StringBuilder ?
• Comparando Fechas En Java
• Tutorial Aplicaciones Web con Jboss Seam
• Instalación del servidor de aplicaciones JBoss

class FiguraGeometrica{

}

class Triangulo extends FiguraGeometrica {

}

public class Principal{

   public void metodo(){
  /**Puedo crear objetos polimorficos*/
  /**Objeto Triangulo de tipo FiguraGeometrica*/
  FiguraGeometrica triangulo=new Triangulo();
 }
}

• Una variable de referencia puede ser de un solo tipo, y una vez que fue declarada, ese tipo jamás puede modificarse..... por ejemplo, si declaramos triangulo de tipo FiguraGeometrica, no podemos decir mas adelante que el mismo objeto triangulo es de tipo FiguraPuntiaguda... 

• Una referencia es una variable, de manera que puede ser reasignada a otros objetos (a menos que se declare como final). por ejemplo podemos hacer lo siguiente:

 FiguraGeometrica miFiguraGeometrica = new FiguraGeometrica();
 Cuadrado miCuadro=new Cuadrado();

 /**Puedo crear objetos polimorficos, asignando su referencia*/
 miFiguraGeometrica=miCuadro;

• Una variable de referencia puede tomar como referencia cualquier objeto del mismo tipo, o un subtipo del mismo..... va muy ligada a la anterior, pero nos dice que si por ejemplo tenemos la clase cuadroPequeño que es subClase de cuadro, al ser "nieta" de FiguraGeometrica, si se crean instancias de ella, se pueden reasignar a instancias de FiguraGeometrica... 

• Un tipo de variable de referencia determina los métodos que pueden ser invocados sobre el objeto que la variable referencia.... Triangulo al ser de tipo FiguraGeometrica puede acceder no solo a los métodos de la clase Triangulo sino también a los de FiguraGeometrica (Claro, pues tiene que existir una relación de Herencia entre ellos)  

• Una variable de referencia puede tener como tipo el de una interface. Si es declarada de esta manera, podrá contener cualquier clase que implemente la interfaz..... las interfaces también permiten el uso de herencia, por lo tanto podemos crear objetos usando para esto una interfaz, por ejemplo si FiguraGeometrica fuera una interface, lo anterior seria igual..... (esto también aplica para las clases Abstractas).

• Interfaces en Java
• Clases Abstractas.
• Herencia en Java.
• ¿ String Vrs StringBuffer Vrs StringBuilder ?
• Comparando Fechas En Java
• Tutorial Aplicaciones Web con Jboss Seam

public class Gato extends Animal{

   /**
    * Constructor explicito clase Gato
    * @param nombre
    */
    public Gato(String nombre) {
  super(nombre);//envia el parametro a el constructor de la clase padre
 System.out.println("Constructor Gato, nombre : "+nombre);
    }

    public void tipoAnimal() {
 System.out.println("Tipo Animal : Es un Gato");
    }

    public void comunicarse(){
  System.out.println("Metodo comunicarse : El gato maulla... Miau Miau");
    }
}

public class Perro extends Animal{

  /**
   * @param nombre
   */
   public Perro(String nombre) {
   super(nombre);
   System.out.println("Constructor perro, nombre : "+nombre);
 }

 public void tipoAnimal() {
  System.out.println("Tipo Animal : Es un Perro");
 }

 public void comunicarse(){
  System.out.println("Metodo comunicarse : El perro Ladra... Guau Guau");
 } 
}

public class Test {
 public static void main (String[] arg){

 /**Creamos anim, un objeto Perro de tipo Animal*/
 Animal anim= new Perro("goliath") ;
 anim.tipoAnimal();
 anim.comunicarse();
 System.out.println();

 /**Creamos perro, un objeto Perro de tipo Perro*/
 Perro perro=new Perro("hercules");
 perro.tipoAnimal();
 System.out.println();

 /**Creamos animalPolimorfico, un objeto perro de tipo Animal
  * asignamos una referencia ya existente*/
 Animal animalPolimorfico=perro;
 animalPolimorfico.tipoAnimal();
 System.out.println();

 /**reasignamos la referencia del objeto anim a el objeto perro
  * esto es valido ya que ambos son de tipo Perro*/
 perro=(Perro) anim;
 perro.tipoAnimal();
 System.out.println();

 /**Creamos gat, un objeto Gato de tipo Animal*/
 Animal gat=new Gato("pichi");
 gat.tipoAnimal();
 gat.comunicarse();
 System.out.println();

 /**Creamos cat, un objeto Gato de tipo IAnimal
  * Para esto aplicamos polimorfismo usando la Interface*/
 IAnimal cat = new Gato("pitufa");
 cat.comunicarse();

 System.out.println("\nConstante en la interfaz Animal : "+IAnimal.valor);
 } 
}

Animal animales[]= { new Perro("simon"),new Perro("paco"),new Gato("mimi")};
  for(Animal a : animales){
        a.tipoAnimal();
  }
  System.out.println();

• Conceptos de Polimorfismo en Java
• Interfaces en Java
• Clases Abstractas.
• Herencia en Java.
• ¿ String Vrs StringBuffer Vrs StringBuilder ?
• Comparando Fechas En Java
• Tutorial Aplicaciones Web con Jboss Seam

try {
  //Bloque de código que vamos a procesar
} catch(excepcion) {
  //Tratamiento que se le da a la posible excepción
} finally {
  //Bloque de código que se ejecutará despues del try o del catch
}

private void metodoDividir(int dividendo, int divisor){
String resultado="";
 try {
   resultado+=dividendo/divisor;
  }catch (Exception e) {
   resultado="Se intentó dividir por cero";
   JOptionPane.showMessageDialog(null,"Error: No se puede dividir por cero ",
      "Advertencia",JOptionPane.WARNING_MESSAGE);
 }
   finally{
    System.out.println("Termino el proceso : el resultado es = "+resultado);
   }
}

try {
      //Sentencias con posibles errores;
    } catch(InterruptedException e){
      //manejo de la exepcion
    } catch(IOException e){
   //manejo de la exepcion
    } catch(Exception e){
   //manejo de la exepcion
    }

package prueba.connection;
import java.sql.*;

/**
 * Clase que permite conectar con la base de datos
 * @author chenao
 *
 */
public class DbConnection {
   /**Parametros de conexion*/
   static String bd = "codejavu";
   static String login = "root";
   static String password = "";
   static String url = "jdbc:mysql://localhost/"+bd;

   Connection connection = null;

   /** Constructor de DbConnection */
   public DbConnection() {
      try{
         //obtenemos el driver de para mysql
         Class.forName("com.mysql.jdbc.Driver");
         //obtenemos la conexión
         connection = DriverManager.getConnection(url,login,password);

         if (connection!=null){
            System.out.println("Conexión a base de datos "+bd+" OK\n");
         }
      }
      catch(SQLException e){
         System.out.println(e);
      }catch(ClassNotFoundException e){
         System.out.println(e);
      }catch(Exception e){
         System.out.println(e);
      }
   }
   /**Permite retornar la conexión*/
   public Connection getConnection(){
      return connection;
   }

   public void desconectar(){
      connection = null;
   }
}

package prueba.vo;


/**
 * CLase VO con los atributos del campo empleado
 * @author chenao
 *
 */
public class PersonaVO{

 private Integer idPersona;
 private String nombrePersona;
 private Integer edadPersona;
 private String profesionPersona;
 private Integer telefonoPersona;

 /**
  * @return the idPersona
  */
 public Integer getIdPersona() {
  return idPersona;
 }
 /**
  * @param idPersona the idPersona to set
  */
 public void setIdPersona(Integer idPersona) {
  this.idPersona = idPersona;
 }
 /**
  * @return the nombrePersona
  */
 public String getNombrePersona() {
  return nombrePersona;
 }
 /**
  * @param nombrePersona the nombrePersona to set
  */
 public void setNombrePersona(String nombrePersona) {
  this.nombrePersona = nombrePersona;
 }
 /**
  * @return the edadPersona
  */
 public Integer getEdadPersona() {
  return edadPersona;
 }
 /**
  * @param edadPersona the edadPersona to set
  */
 public void setEdadPersona(Integer edadPersona) {
  this.edadPersona = edadPersona;
 }
 /**
  * @return the profesionPersona
  */
 public String getProfesionPersona() {
  return profesionPersona;
 }
 /**
  * @param profesionPersona the profesionPersona to set
  */
 public void setProfesionPersona(String profesionPersona) {
  this.profesionPersona = profesionPersona;
 }
 /**
  * @return the telefonoPersona
  */
 public Integer getTelefonoPersona() {
  return telefonoPersona;
 }
 /**
  * @param telefonoPersona the telefonoPersona to set
  */
 public void setTelefonoPersona(Integer telefonoPersona) {
  this.telefonoPersona = telefonoPersona;
 }
}

package prueba.dao;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import javax.swing.JOptionPane;
import prueba.connection.DbConnection;
import prueba.vo.PersonaVO;


/**
 * Clase que permite el acceso a la base de datos
 * @author chenao
 *
 */
public class PersonaDAO 
{

 /**
  * Permite registrar un empleado
  * @param persona
  */
 public void registrarPersona(PersonaVO persona) 
 {
  DbConnection conex= new DbConnection();
  try {
   Statement estatuto = conex.getConnection().createStatement();
   estatuto.executeUpdate("INSERT INTO persona VALUES ('"+persona.getIdPersona()+"', '"
     +persona.getNombrePersona()+"', '"+persona.getEdadPersona()+"', '"
     +persona.getProfesionPersona()+"', '"+persona.getTelefonoPersona()+"')");
   JOptionPane.showMessageDialog(null, "Se ha registrado Exitosamente","Información",JOptionPane.INFORMATION_MESSAGE);
   estatuto.close();
   conex.desconectar();

  } catch (SQLException e) {
            System.out.println(e.getMessage());
   JOptionPane.showMessageDialog(null, "No se Registro la persona");
  }
 }

/**
 * permite consultar el empleado asociado al documento enviado
 * como parametro 
 * @param documento 
 * @return
 */
public ArrayList< personavo> consultarPersona(int documento) {
  ArrayList< personavo> miEmpleado = new ArrayList< personavo>();
  DbConnection conex= new DbConnection();

  try {
   PreparedStatement consulta = conex.getConnection().prepareStatement("SELECT * FROM persona where id = ? ");
   consulta.setInt(1, documento);
   ResultSet res = consulta.executeQuery();

  if(res.next()){
    PersonaVO persona= new PersonaVO();
    persona.setIdPersona(Integer.parseInt(res.getString("id")));
    persona.setNombrePersona(res.getString("nombre"));
    persona.setEdadPersona(Integer.parseInt(res.getString("edad")));
    persona.setProfesionPersona(res.getString("profesion"));
    persona.setTelefonoPersona(Integer.parseInt(res.getString("telefono")));
    miEmpleado.add(persona);
          }
          res.close();
          consulta.close();
          conex.desconectar();

  } catch (Exception e) {
   JOptionPane.showMessageDialog(null, "no se pudo consultar la Persona\n"+e);
  }
  return miEmpleado;
 }

/**
 * permite consultar la lista de empleados
 * @return
 */
public ArrayList< personavo> listaDePersonas() {
  ArrayList< personavo> miEmpleado = new ArrayList< personavo>();
  DbConnection conex= new DbConnection();

  try {
   PreparedStatement consulta = conex.getConnection().prepareStatement("SELECT * FROM persona");
   ResultSet res = consulta.executeQuery();
   while(res.next()){
    PersonaVO persona= new PersonaVO();
    persona.setIdPersona(Integer.parseInt(res.getString("id")));
    persona.setNombrePersona(res.getString("nombre"));
    persona.setEdadPersona(Integer.parseInt(res.getString("edad")));
    persona.setProfesionPersona(res.getString("profesion"));
    persona.setTelefonoPersona(Integer.parseInt(res.getString("telefono")));
    miEmpleado.add(persona);
          }
          res.close();
          consulta.close();
          conex.desconectar();

  } catch (Exception e) {
   JOptionPane.showMessageDialog(null, "no se pudo consultar la Persona\n"+e);
  }
  return miEmpleado;
 }

}

package prueba.principal;

import java.util.ArrayList;
import javax.swing.JOptionPane;
import prueba.dao.PersonaDAO;
import prueba.vo.PersonaVO;


public class Principal {

 PersonaDAO miPersonaDAO;

 /**
  * Método principal, hace el llamado al menú donde se
  * presentan todas las opciones del sistema
  * @param args
  */
 public static void main(String[] args) {

  Principal miPrincipal = new Principal();
  miPrincipal.verMenu();
 }

 /**
  * Método que permite presentar las opciones del sistema.
  * solicita el ingreso de un numero y se envia a su 
  * correspondiente proceso
  */
 private void verMenu() {

  String textoMenu="Menú Principal\n\n";
  textoMenu+="Ingrese alguna de las opciones del Menú    \n";
  textoMenu+="1. Registrar Persona\n";
  textoMenu+="2. Consultar Persona\n";
  textoMenu+="3. Ver Lista Personas\n";
  textoMenu+="4. Salir.\n\n";

  try {
  int seleccion= Integer.parseInt(JOptionPane.showInputDialog(textoMenu));
  defineSeleccion(seleccion);
  } catch (NumberFormatException e) {
   JOptionPane.showMessageDialog(null,"Error en el ingreso de Datos, " +
     "solo se permiten valores númericos","ERROR",JOptionPane.ERROR_MESSAGE);
   verMenu();
  } catch (Exception e) {
   JOptionPane.showMessageDialog(null,"Error en el ingreso de Datos, " +
     "solo se permiten valores númericos","ERROR",JOptionPane.ERROR_MESSAGE);
   verMenu();
  }
 }

 /**
  * Permite determinar que accion ejecutar dependiendo del parametro de 
  * ingreso correspondiente a las opciones del sistema
  * @param seleccion
  */
 private void defineSeleccion(int seleccion) {

   System.out.println("Selecciona "+seleccion);

   switch (seleccion) {
   case 1:
     registrarPersona();
     verMenu();
    break;
   case 2:
    int doc=Integer.parseInt(JOptionPane.showInputDialog("Ingrese el numero" +
      " de documento de la persona"));
    buscarPersona(doc);
    verMenu();
    break;
   case 3:
    obtenerRegistros();
    verMenu();
    break;
   case 4:
    System.exit(0);
    break;
   default:
    JOptionPane.showMessageDialog(null, "Ingrese un " +
      "numero valido","ADVERTENCIA",JOptionPane.WARNING_MESSAGE);
    verMenu();
    break;
   }
 }

 /**
  * Permite solicitar los datos de la persona a registrar, se solicitan mediante
  * una ventana de ingreso y se almacenan en un arreglo con toda la informacion usando
  * para esto un ciclo for, posteriormente estos datos son almacenados en el
  * atributo correspondiente del objeto persona para ser enviado al metodo de registro
  * en la clase DAO
  */
 private void registrarPersona() {
  miPersonaDAO = new PersonaDAO();
  PersonaVO miPersona=new PersonaVO();

  String mensajeIngreso="Ingrese\n\n";

  String datosSolicitados[] = {"Documento : ","Nombre : ",
          "Edad: ","Profesión: ","Telefono: "};
  String datosPersona[] = new String[5];
  for (int i = 0; i < datosSolicitados.length; i++) {
   //solicita el ingreso del dato y se almacena en el arreglo de datosPersona
   datosPersona[i]=JOptionPane.showInputDialog(null, mensajeIngreso+
      datosSolicitados[i],"Datos Persona",JOptionPane.INFORMATION_MESSAGE);

   System.out.println(datosSolicitados[i]+datosPersona[i]);
  }

  miPersona.setIdPersona(Integer.parseInt(datosPersona[0]));
  miPersona.setNombrePersona(datosPersona[1]);
  miPersona.setEdadPersona(Integer.parseInt(datosPersona[2]));
  miPersona.setProfesionPersona(datosPersona[3]);
  miPersona.setTelefonoPersona(Integer.parseInt(datosPersona[4]));

  miPersonaDAO.registrarPersona(miPersona);

 }

 /**
  * Permite obtener la lista de personas almacenada en la tabla persona
  * si la lista se encuentra vacia quiere decir que no hay personas registradas
  * acto seguido se presenta un mensaje en pantalla, sino se imprime la lista de 
  * todas las personas registradas en la BD
  */
 private void obtenerRegistros() {
  miPersonaDAO = new PersonaDAO();
  PersonaVO miPersona;

  //Se obtiene la lista de personas
  ArrayList< personavo> listaPersonas = miPersonaDAO.listaDePersonas();
  //se valida si se obtubo o no informacion
  if (listaPersonas.size()>0) {
   int numeroPersona=0;
   //se recorre la lista de personas asignandose cada posicion en un objeto persona
   for (int i = 0; i < listaPersonas.size(); i++) {
    numeroPersona++;
    miPersona=listaPersonas.get(i);
    System.out.println("****************Persona "+numeroPersona+"**********************");
    System.out.println("Id Persona: "+miPersona.getIdPersona());
    System.out.println("Nombre Persona: "+miPersona.getNombrePersona());
    System.out.println("Edad Persona: "+miPersona.getEdadPersona());
    System.out.println("Profesión Persona: "+miPersona.getProfesionPersona());
    System.out.println("Telefono Persona: "+miPersona.getTelefonoPersona());
    System.out.println("*************************************************\n");
   }
  }else{
   JOptionPane.showMessageDialog(null,"Actualmente no " +
     "existen registros de personas","INFORMACIÓN",JOptionPane.INFORMATION_MESSAGE);
  }

 }

 /**
  * Permite la consulta de una persona en especifico mediante el envio de
  * su documento de identidad como parametro, en caso de que no se retorne
  * informacion se presenta un mensaje en pantalla, sino entonces se imprimen los
  * datos de la persona encontrada
  * @param documento
  */
 private void buscarPersona(int documento) {
  miPersonaDAO = new PersonaDAO();
  PersonaVO miPersona;
  ArrayList< personavo> personasEncontrada = miPersonaDAO.consultarPersona(documento);
  //se valida que se encuentre la persona
  if (personasEncontrada.size()>0) {
   //se recorre la lista y se asignan los datos al objeto para imprimir los valores
   for (int i = 0; i < personasEncontrada.size(); i++) {
    miPersona=personasEncontrada.get(i);
    System.out.println("****************Persona*************************");
    System.out.println("Id Persona: "+miPersona.getIdPersona());
    System.out.println("Nombre Persona: "+miPersona.getNombrePersona());
    System.out.println("Edad Persona: "+miPersona.getEdadPersona());
    System.out.println("Profesión Persona: "+miPersona.getProfesionPersona());
    System.out.println("Telefono Persona: "+miPersona.getTelefonoPersona());
    System.out.println("*************************************************\n");
   }
  }else{
   JOptionPane.showMessageDialog(null,"El documento ingresado " +
     "no corresponde a ninguna persona","INFORMACIÓN",JOptionPane.INFORMATION_MESSAGE);
  }
 }
}