Programacin en Java

[next] [prev] [prev-tail] [tail] [up]

5.3 Programación en Java

Java es un lenguaje de programación creado por Sun Microsystems Inc.. Su invención y uso son relativamente recientes, y se utiliza fundamentalmente porque su vasta biblioteca de objetos son capaces de realizar una gran cantidad de tareas. En nuestro caso vamos a aprovecharnos de su potencia para el diseño de interfaces gráficos.

5.3.1 Estructura de un programa escrito en Java

Java es un lenguaje que sigue la filosofía de la programación orientada a objetos. De hecho, en Java casi todo es un objeto excepto los tipos de datos primitivos (que no lo son por motivos de eficiencia).

Un objeto es una colección de estructuras de datos (simples o compuestas por otras) y un conjunto de métodos. Además, en Java es muy corriente usar la herencia, por lo que estos métodos (funciones miembro) y estructuras de datos pueden estar declaradas en algún punto superior dentro de la jerarquía de clases.

Los objetos (instancias de las clases) se crean siempre de forma dinámica y se llaman unos a otros (o mejor dicho, desde los métodos de unos se invocan a los métodos de otros), comenzando siempre por el que contiene el método main. Por tanto, un programa escrito en Java tiene la siguiente estructura genérica:

/* public -> clase heredable. */
/* final -> Clase no heredable. */
/* abstract -> Clase no instanciable por tener métodos abstractos. */
/* static -> Clase no instanciable. */
/* strictfp -> Clase con aritmética en punto flotante determinística. */
/* interface -> Clase declara en realidad un interface (todos los métodos abstract). */
class ClasePrincipal extends ClaseHeredada implements Interface {

  public variablesAccesiblesDesdeObjetosInstanciados;

  protected variablesInaccesiblesDesdeObjetosInstanciados;

  private variablesSoloAccesiblesMetodosClasePrincipal;

  static variablesComunesTodasInstancias;

  final constantes;

  /* Declaración de otras clases anidadas. */

  ClasePrincipal() {
    /* this -> Instancia del objeto actual. */
    /* supper -> Instancia del objeto padre. */
    /* Constructor por defecto. */
  }

  ClasePrincipal(/* Argumentos 1. */) {
    /* Constructor 1. */
  }

  ClasePrincipal(/* Argumentos 2. */) {
    /* Constructor 2. */
  }

  /* abstract -> Método sin implementación. */
  /* final -> Método no sobreescribible. */
  /* static -> Método que manipula variables static .*/
  /* synchronized -> Método ejecutado en exclusión mútua. */
  /* native -> Método llama a código nativo. */
  /* strictfp -> Método utiliza aritmética en punto flotante determinística. */
  public metodo1ClasePrincipal(/* Argumentos */) {
  }

  public static void main(java.lang.String[] args) {
    /* Primera función ejecutada. Sólo existe una función main(). */
    try {
      /* Código. */
    } catch (/* Instancia objeto manipulador Excepción 1. */) {
      /* Código menejo excepción 1. */
    } catch (/* Instancia objeto manipulador Excepción 2. */) {
      /* Código menejo excepción 2. */
    } finally {
      /* Más código que puede lanzar otras excepciones. */
    }
  }
}

En Java se referencia a una clase dentro de la jerarquía de clases usando la directiva import. Esto tiene que hacerse para cada clase referenciada, si es que esta no se define en el directorio en el que se ejecuta la aplicación o en la variable de entorno que indica qué directorios debe recorrer la máquina virtual a la hora de ejecutar la aplicación.

5.3.2 Compilación y ejecución de un programa escrito en Java

Para el que nunca ha programado en Java este apartado le será de utilidad. La teoría es bastante simple: (1) escribir el programa según la sintaxis del programa, (2) compilarlo y (3) ejecutarlo. Bueno, hasta aquí todo bastante sencillo. Sin embargo, hay que tener en cuenta que realmente:

El paso (2) no debería llamarse realmente compilación sino traducción, porque el código no se compila, sino que se transforma en un código intermedio, llamado code-byte, “digerible” más fácilmente por el intérprete de Java.
El paso (3) tampoco debería llamarse simplemente ejecución porque lo que realmente ocurre es que el código intermedio, generado durante la compilación se interpreta en la máquina Java.

La razón de usar una máquina virtual es que así, el código code-byte se puede ejecutar en cualquier computadora que disponga de una máquina de Java. De esta forma generamos código “ejecutable” totalmente portable.

[next] [prev] [prev-tail] [front] [up]