Publicado el Dejar un comentario

Estructura de una clase Java

Una clase java puede definir varios componentes. Los componentes que una clase java puede contener son:

  • La sentencia o instrucción package
  • La sentencia import 
  • Comentarios
  • Las declaraciones y definiciones de la clase
  • Variables
  • Métodos
  • Constructores

Además puede contener clases e interfaces anidadas y enumeraciones o tipos enum. Éstos últimos componentes no están contemplados en el examen OCA Java SE 7 Programmer I.

Por lo tanto la estructura de una clase Java se vería más o menos así:

Sentencia package
Sentencias import
Comentarios
Declaración de la clase {
    Variables
    Comentarios
    Constructores
    Métodos
    Clases anidadas
    Interfaces anidadas
    Enumeraciones
}

Sentencia package.

Esta sentencia puede o no aparecer en una clase, sin embargo toda clase Java pertenece a un package (paquete). Si la sentencia no es especificada significa que la clase pertenece al paquete por omisión (default).

Si la sentencia es especificada, debe ser la primera sentencia en la clase Java. No pueden existir otras sentencias antes de ésta sentencia, si sucediera esto, la clase Java no podrá ser compilada. Sólo puede haber una sentencia package en una clase Java, no más.

Sentencia import.

Cuando las clases e interfaces Java que utilizará otra clase Java se encuentran en el mismo paquete no es necesario especificar el nombre del paquete antes del nombre de esas clases o interfaces, pero si no es así, es necesario escribir el nombre completo de la clase con todo y nombre del paquete al que pertenece dicha clase o interfaz utilizada.

Para evitar estar escribiendo los nombres completos de las clases, se usa la sentencia import. Una vez utilizada esta sentencia, podemos llamar sólo con el nombre simple de la clase en nuestro código. Enseguida dos ejemplos:

// Sin sentencia import
package escuela;
class Curso {
    persona.Maestro maestro;
}

// Con sentencia import
package escuela;
import personal.Maestro;
class Curso {
    Maestro maestro;
}

En los ejemplo la clase Curso está contenida dentro del paquete escuela y la clase Maestro pertenece al paquete personal. Para que la clase Curso pueda utilizar la clase Maestro, debe escribir el nombre completo de la clase junto con el paquete  (como en el primer ejemplo) o utilizar la sentencia import y utilizar el nombre simple de la clase (como en el segundo ejemplo).

Si la sentencia import es usada, debe aparecer después de la sentencia package, si no, la clase no podrá compilar. La sentencia import puede aparecer varias veces en la clase.

Comentarios.

Java permite hacer o escribir comentarios en el código. Los comentarios pueden aparecer en cualquier parte de la clase, antes de la sentencia package, de la sentencia import, antes de la definición de la clase, antes de las variables, o antes de los métodos y dentro de los métodos mismos. Existen dos tipos de comentarios: los multilínea y los de “fin de línea”.

Los comentarios multilínea inician con /* y terminan con */, los comentarios “fin de línea” inician con // y  como su nombre lo indica, terminan con el salto o cambio de línea del código. Enseguida unos ejemplos de comentarios de los dos tipos:

 

// Comentario fin de linea antes de sentencia package
package escuela;
/*
 * Este es un comentario multilínea
 * continua el comentario
 */
class Curso {

    // Este es un comentario fin de linea

    persona.Maestro maestro; //Otro comentario fin de linea

    /* Otro comentario multilínea en una sola linea, es válido */

}

Antes dijimos que la sentencia package, si se especifica, debe ser la primera sentencia en una clase Java, los comentarios, sin embargo, pueden aparecer antes de ésta sentencia y el compilador no marcará error. Los comentarios pueden aparecer en cualquier parte del código Java.

Declaración de la clase.

La declaración class marca el inicio de la clase. Basta con especificar la palabra reservada class y enseguida el nombre de la clase. La declaración de una clase esta compuesta por varias partes:

  • Modificadores de acceso
  • Modificadores de no acceso
  • Nombre de la clase
  • Nombre de la clase base si ésta extiende de otra clase
  • Nombre de todas las interfaces que implemente, si está implementado alguan iterface
  • Cuerpo de la clase (campos de clase [class fields], métodos, constructores), incluidos dentro de llaves de inicio y fin, {}

De estas partes o componentes sólo la palabra reservada class, el nombre de la clase y las llaves de apertura y cierre son obligatorias, el resto son opcionales.

 

//Ejemplo de la definición mínima obligatoria de una clase

class Punto {}

//Ejemplo de la definición completa de una clase

public final class Predio extends Poligono implements Geometria {}

Definición de la clase.

La clase se diseña para especificar las propiedades y el comportamiento que tiene un objeto. Las propiedades del objeto se implementan o definen a través de variables  y el comportamiento de por medio de métodos. Las clases son como moldes de los cuales podemos producir varios objetos. Un objeto es creado a partir de una clase. La clase inicia con la palabra reservada class y es sensitiva a mayúsculas, es decir, que se debe escribir todas con minúsculas, Class no es palabra reservada válida para java, class sí. El estado de una clase se define mediante atributos o variables de instancia. El comportamiento se define mediante los métodos, los cuales pueden incluir una lista de argumentos. Una definición de clase puede incluir también comentarios y constructores.

/* Ejemplo de definición de 
 una clase */

class Predio {
  double area; // variables de instancia
  String nombre;
  Geometria geometria;

  Predio(String nombre) { // constructor
    this.nombre = nombre;
  }

  double calculaArea() { // método
    //aquí irá el código para calcular el área
  }

}

Variables.

En el ejemplo anterior ; area, nombre y geometria son variables llamadas de instancia o atributos de instancia, y almacenan el estado de un objeto (también llamado instancia de una clase) .  Cada objeto o instancia de una clase tiene su propia copia de estas variables de instancia. Si los valores de estas variables cambian, no afectan a los valores de instancia de otros objetos. Las variables de instancia se definen  o especifican dentro del cuerpo de la clase pero fuera de los métodos de la clase. Hay una excepción de variables que su valor son compartidas pro todos las instancias u objetos de clase, a este tipo de variables se le antepone la palabra static y se les llama variables estáticas o variables de clase.

Métodos.

calculaArea en el ejemplo de más arriba, es un método de instancia, por lo general, los métodos se usan para manipular las variables de instancia. Para manipular las variables de clase o estáticas, se usan los llamados métodos de clase o estáticos.

Constructor.

En el mismo ejemplo Predio es un constructor. Un constructor de clase se usa para inicializar o crear los objetos de una clase. Una clase puede definir varios constructores que acepten diferentes conjuntos de parámetros de método.

 

Publicado el 2 comentarios

Ejecutar un Job (trabajo) programáticamente con Kettle (Data Integrator)

Pentaho Data Integration también conocido como Kettle es una potente herramienta de Extracción, Transformación y Carga de datos (ETL por sus siglas en inglés) mediante un enfoque innovador basado en metadatos.

En forma gráfica, esta herramienta permite crear transformaciones de datos y trabajos (jobs) para, por ejemplo, pasar datos de una base de datos a otra y/o transformarlos en el proceso. Además permite guardar esas transformaciones y trabajos en un repositorio dentro de una base de datos relacional. Para más información de Kettle visita la página de este proyecto.

Esta herramienta esta hecha en lenguaje java y permite “embeber” o incrustar su tecnología en nuestras propias aplicaciones de escritorio o web. En el siguiente código se muestra cómo ejecutar un job que previamente se diseñó y guardó en el repositorio:

package xxx.bean;

import javax.enterprise.context.RequestScoped;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.inject.Named;
import org.pentaho.di.core.KettleEnvironment;
import org.pentaho.di.core.Result;
import org.pentaho.di.core.database.DatabaseMeta;
import org.pentaho.di.core.exception.KettleException;
import org.pentaho.di.core.exception.KettleSecurityException;
import org.pentaho.di.job.Job;
import org.pentaho.di.job.JobMeta;
import org.pentaho.di.repository.ObjectId;
import org.pentaho.di.repository.Repository;
import org.pentaho.di.repository.RepositoryDirectory;
import org.pentaho.di.repository.RepositoryDirectoryInterface;
import org.pentaho.di.repository.RepositoryMeta;
import org.pentaho.di.repository.kdr.KettleDatabaseRepository;
import org.pentaho.di.repository.kdr.KettleDatabaseRepositoryMeta;
import org.pentaho.di.trans.TransMeta;

/**
 *
 * @author SCyASIG
 */
@Named(value = "jobControladorMB")
@RequestScoped
public class jobControladorMB {

    /**
     * Creates a new instance of jobControladorMB
     */
    public jobControladorMB() {
    }

    public String ejecutaJob() {
        String irA = "";
        FacesContext contexto = FacesContext.getCurrentInstance();
        String nombreJob = contexto.getExternalContext().getRequestParameterMap().get("nombreJob");
        try {
            KettleEnvironment.init();
            DatabaseMeta dbm = new DatabaseMeta("", "Oracle", "Native", "localhost", "nombreInstancia", "1521", "usuario", "password");
            KettleDatabaseRepositoryMeta rm = new KettleDatabaseRepositoryMeta();
            rm.setConnection(dbm);

            KettleDatabaseRepository repo = new KettleDatabaseRepository();

            repo.init(rm);

            repo.connect("admin", "admin");

            RepositoryDirectoryInterface rdi = repo.getUserHomeDirectory();

            JobMeta jobMeta = repo.loadJob(nombreJob, rdi, null, null);

            Job job = new Job(repo, jobMeta);

            job.start();

            job.waitUntilFinished();
            Result result = job.getResult();

            System.out.println(result.getResult());

            repo.disconnect();
            contexto.addMessage(null, new FacesMessage("El trabajo " + nombreJob + " se generó exitosamente"));
        } catch (KettleSecurityException kse) {
            kse.printStackTrace();
            contexto.addMessage(null, new FacesMessage("Ocurrió un error al ejecutar el trabajo" + nombreJob ));

        } catch (KettleException ke) {
            ke.printStackTrace();
            contexto.addMessage(null, new FacesMessage("Ocurrió un error al ejecutar el trabajo" + nombreJob ));
        } 
        return irA; 
    } 
}

El código pertenece a una clase CDI Managed Bean llamado desde una página JSF. Dentro de la instalación de Kettle 4.4.0 se encuentra la documentación de la API.

Espero les sea útil este post. ¡Saludos!

 

Publicado el Dejar un comentario

Procesar archivos de Microsoft Office en java con la librería Apache POI

La librería Apache POI permite procesar archivos de Microsoft Office desde un programa en java. Puede leer y escribir tanto archivos clásicos .xls y .doc como los nuevos formatos .xlsx y .docx.

En entradas posteriores veremos como usar la librería y códigos ejemplo de cómo obtener el contenido de un archivo en excel.

Hasta pronto.