grados fahrenheit = 9/5 * grados centigrados +32

Los calculos los vamos a realizar para un intervalo de -30 a 100 grados centigrados con incremento de 6

Analicemos el problema. ¿De que trata el programa? De grados. Entonces podemos pensar en objetos “grados” que encapsulen un valor en grados centigrados y los metodos necesarios para asignar al objeto un valor en grados centigrados, asi como para obtener tanto el dato grados centigrados como su equivalencia en grados fahrenheit. En base a esto, podriamos escribir una clase CGrados como se puede observar a continuacion:

class CGrados
{
  private float gradosC; // grados centígrados
  
  public void CentígradosAsignar(float gC)
  {
    // Establecer el atributo grados centígrados
    gradosC = gC;
  }
  
  public float FahrenheitObtener()
  {
    // Retornar los grados fahrenheit equivalentes a gradosC
    return 9F/5F * gradosC + 32;
  }
  
  public float CentígradosObtener()
  {
    return gradosC; // retornar los grados centígrados
  }
}

El codigo anterior muestra que un objeto de la clase CGrados tendra una estructura interna formada por el atributo:

• gradosC, grados centigrados

y una interfaz de acceso formada por los metodos:

• CentigradosAsignar que permite asignar a un objeto un valor en grados centigrados
• FahrenheitObtener que permite retornar el valor en grados fahrenheit equivalente a gradosC grados centigrados.
• CentigradosObtener que permite retornar el valor almacenado en el atributo gradosC.

Entonces ¿Que tiene que hacer el objeto aplicacion? Pues, visializar cuantos grados fahrenheit son -30C, -26C, …, n grados centigrados, …, 96C y ¿Como hacer esto?. Enviando al objeto CGrados los mensajes CentigradosAsignar y FahrenheitObtener una ves para cada valor desde -30 a 100 grados centigrados con incrementos de 6.

Seguidamente veremos la clase de Aplicacion que llamara a un objeto de la clase CGrados

import java.lang.System;   // importar la clase System

public class CApGrados
{
  // Definición de constantes

  final static int limInferior = -30;

  final static int limSuperior = 100;
  final static int incremento = 6;

  public static void main(String[] args)
  {
    // Declaración de variables
    CGrados grados = new CGrados();
    int gradosCent = limInferior;
    float gradosFahr = 0;

    while (gradosCent <= limSuperior) // while ... hacer:
    {
      // Asignar al objeto grados el valor en grados centígrados
      grados.CentígradosAsignar(gradosCent);
      // Obtener del objeto grados los grados fahrenheit
      gradosFahr = grados.FahrenheitObtener();
      // Escribir la siguiente línea de la tabla
      System.out.println(gradosCent + " C" + "\t" + gradosFahr + " F");
      // Siguiente valor
      gradosCent += incremento;
    }
  }
}

Ahora seguramente pensaran que todo el proceso se podria haver hecho utilizando solamente el objeto aplicaion, escribiendo todo el codigo en el metodo main, lo cual es cierto.

Pero, lo que se pretende es que se pueda ver la forma clara que, en general, un programa Java es un conjunto de objetos que se comunican entre si mediante mensajes con el fin de obtener el resultado perseguido, y que la solucion del problema puede resultar mas sencilla cuando consiga realizar una presentacion del problema en base a los objetos naturales que se deducen de su enunciado.

piense que el realidad se enfrentara a los problemas mucho mas complejos y, por lo tantom la descomposición en objetos sera vital para resolverlos.

Seguidamente dejo el código completo con algunos comentarios para que se guíen (por supuesto son dos clases)

/**
 * Conversión de grados centígrados a fahrenheit:
 * F = 9/5 * C + 32
 */

import java.lang.System;   // importar la clase System

public class CApGrados
{
  // Definición de constantes
  final static int limInferior = -30;
  final static int limSuperior = 100;
  final static int incremento = 6;

  public static void main(String[] args)
  {
    // Declaración de variables
    CGrados grados = new CGrados();
    int gradosCent = limInferior;
    float gradosFahr = 0;

    while (gradosCent <= limSuperior) // while ... hacer:
    {
      // Asignar al objeto grados el valor en grados centígrados
      grados.CentígradosAsignar(gradosCent);
      // Obtener del objeto grados los grados fahrenheit
      gradosFahr = grados.FahrenheitObtener();
      // Escribir la siguiente línea de la tabla
      System.out.println(gradosCent + " C" + "\t" + gradosFahr + " F");
      // Siguiente valor
      gradosCent += incremento;
    }
  }
}




/**
 * Clase CGrados. Un objeto de esta clase almacena un valor
 * en grados centígrados.
 * Atributos:
 *   gradosC
 * Métodos:
 *   CentígradosAsignar, FahrenheitObtener y CentígradosObtener
 */
class CGrados
{
  private float gradosC; // grados centígrados
  
  public void CentígradosAsignar(float gC)
  {
    // Establecer el atributo grados centígrados
    gradosC = gC;
  }
  
  public float FahrenheitObtener()
  {
    // Retornar los grados fahrenheit equivalentes a gradosC
    return 9F/5F * gradosC + 32;
  }
  
  public float CentígradosObtener()
  {
    return gradosC; // retornar los grados centígrados
  }
}

Resumiendo tanto palabreo se puede decir que la programacion orientada a objetos es la forma o metodo de simplificar bloques de codigo y evitar la rebundancia en algun otro lugar del codigo. Y eso  es lo que tratamos de difundir y propagar

ax³ + bx² + cx + d

Una ecuación se puede ver como un objeto que devuelve el exponente, los coeficientes y los métodos que permitan manipularla. Para hacer sencillo el ejemplo que tratamos de exponer, el exponente lo supondremos fijo de valor 3, los coeficientes serán variables, y añadiremos dos métodos: uno que permita evaluarla para un valor de X dado. Resumiendo, los objetos CEcuacion tendran unos tributos que seran los coeficientes y unos metodos Ecuacion y ValorPara para manipularlo.

El método Ecuación simplemente asignara los valores pasados como parametros a los atributos respectivos de los coeficientes de la ecuacion.

El método ValorPara evaluara la ecuación para el valor x pasado como parametro. Este metodo, utilizando la sentencia return, devolvera como resultado el valor calculado (Tipo Double)

Empecemos por la Clase CEcuacion

class CEcuacion
{
    // El termino de mayor grado tiene exponente 3 fijo
    double c3, c2, c1, c0; // coeficientes
    public void Ecuación(double a, double b, double c, double d)
    {
        c3 = a; c2 = b; c1 = c; c0 = d;
    }
  
    public double ValorPara(double x)
    {
       double resultado;
       resultado = c3*x*x*x + c2*x*x + c1*x + c0;
       return resultado; // devolver el valor calculado
    }
}

El siguiente paso es añadir al mismo fichero una clase de aplicacion publica que utilice la clase de Objetos CEcuacion. Esta clase aplicacion debe ser de la siguiente forma:

public class CMiAplicacion
{
    public static void main(String[] args)
    {
       CEcuacion ec1 = new CEcuacion();
       ec1.Ecuación(1, -3.2, 0, 7);
    
       double r = ec1.ValorPara(1);
       System.out.println(r);
    
       r = ec1.ValorPara(1.5);
       System.out.println(r);
    }
}

Recuerda que el método main es por donde empieza a ejecutarse la aplicacion. Este metodo crea un objeto ecl de la clase CEcuacion.

Para probar la aplicacion con otros valores tenemos que modificar los siguientes datos en la Clase CMiAplicacion:

ec1.Ecuación ( 1 ,  -3.2 , 0, 7 );
r = ec1.ValorPara( 1.5 );

Hola, empezando con los ejercicios les dejo un simple ejemplo de como pintar por consola un Tablero de Ajedrez y como valor agregado tambien pintaremos la posicion de un Alfil incluyendo la trayectoria que puede recorrer dentro del tablero.

public class Ajedrez {
	// Imprimir un tablero de ajedrez.
	public static void main(String[] args) {
		int falfil, calfil; // posición inicial del alfil
	    int fila, columna;  // posición actual del alfil
	    falfil = 5; //Fila
	    calfil = 4; //Columna
	    System.out.println("Posición del alfil:"); 
	    System.out.println("-------------------------"); 
	    System.out.print(" fila    " + falfil); 
	    System.out.println(); 
	    System.out.print(" columna " + calfil); 
	    System.out.println(); 
	    System.out.println("-------------------------");    

	    for (fila = 1; fila <= 8; fila++)
	    {
	      for (columna = 1; columna <= 8; columna++)
	      {
	        if ((fila + columna == falfil + calfil) ||
	           (fila - columna == falfil - calfil))
	          System.out.print("* ");
	        else if ((fila + columna) % 2 == 0)
	          System.out.print("B ");
	        else
	          System.out.print("N ");
	      }
	      System.out.println(); // cambiar de fila
	    }
	}
}

En esta oportunidad tendremos que ingresar la posicion del alfil manualmente en:

• falfil = 5;   //Posicion de Fila
• calfil = 4;   //Posicion de Columna

Mas adelante implementaremos un metodo que permita ingresar la posicion en tiempo de ejecucion…

Como podemos apreciar en la captura tenemos la posición   vertical = 5      horizontal = 4

De la misma forma que se pudo implementar la posición del alfil en el tablero también se puede implementar todas fichas del ajedrez. Pruebenlo, practiquenlo y disfrútenlo…

Todos los componentes Swing cumplen la especificación de los JavaBeans. Entre las cinco características que debe soportar un JavaBean se encuentra un conjunto de propiedades y sus métodos de acceso asociados. Una propiedad es una variable global, y sus métodos de acceso, si tiene alguno, son normalmente de la forma setPropertyname(), getPropertyname() o isPropertyname().

Una propiedad que no tienen ningún evento asociado a un cambio en su valor se llama una propiedad simple. Una propiedad ligada (bound property) es aquella para la que se lanzan PropertyChangeEvents después de un cambio en su estado. Podemos registrar nuestros PropertyChangeListeners para escuchar PropertyChangeEvents a través del método addPropertyChangeListener() de JComponent. Una propiedad restringida (constrained property) es aquella para la que se lanzan PropertyChangeEvents justo antes de que ocurra un cambio en su estado. Podemos resgistrar VetoableChangeListeners que escuchen a PropertyChangeEvents por medio del método addVetoableChangeListener() de JComponent. Se puede vetar un cambio en el código de manejo de eventos de un VetoableChangeListener lanzando una PropertyVetoException. (Sólo hay una clase en Swing con propiedades restringidas: JInternalFrame).

Nota: Todos estos oyentes y eventos están definidos en el paquete java.awt.beans.

Los PropertyChangeEvent’s llevan consigo tres segmentos de información: nombre de la propiedad, el valor antiguo, y el nuevo. Los Beans pueden usar instancias de
PropertyChangeSupport para manejar el lanzamiento de PropertyChangeEvents correspondientes a cada propiedad ligada, a todos los oyentes registrados. De manera similar, una instancia de VetoableChangeSupport se puede usar para manejar el envío de todos los PropertyChangeEvents correspondientes a cada propiedad restringida.

Swing introduce una nueva clase llamada SwingPropertyChangeSupport (definida en javax.swing.event) que es una subclase casi idéntica de PropertyChangeSupport. La
diferencia es que SwingPropertyChangeSupport se ha construido para que sea más eficiente. Lo consigue sacrificando la seguridad entre los hilos, que, como veremos más tarde en este capítulo, no es asunto de Swing si se siguen consistentemente las reglas generales de la multitarea (porque todo el procesamiento de eventos debería llevarse a cabo en un solo hilo-el hilo de despacho de eventos). Por lo tanto, si confiamos en que nuestro código ha sido construido de manera segura respecto a los hilos,
deberíamos usar esta versión más eficiente, en lugar de PropertyChangeSupport.

Nota: No hay equivalente en Swing para VetoableChangeSupport porque sólo hay cuatro propiedades restringidas en Swing–todas definidas en JInternalFrame.

Swing introduce un nuevo tipo de propiedad que podemos llamar de cambio (change property), a falta de un nombre dado. Usamos ChangeListeners para escuchar ChangeEvents que se lanzan cuando cambia el estado de estas propiedades. Un ChangeEvent sólo lleva consigo un segmento de información: la fuente del evento. Por esta razón, las propiedades de cambio son menos poderosas que las propiedades ligadas y que las restringidas, pero están más extendidas. Un JButton, por ejemplo, envía eventos de cambios todas las veces que se arma (se pulsa por primera vez), se presiona, o se suelta .

Otro nuevo aspecto en el estilo de las propiedades que introduce Swing es la noción de propiedades cliente (client properties). Estas son básicamente pares clave/valor que se guardan en una Hashtable facilitada por todos los componentes Swing. Esto permite añadir y borrar propiedades en tiempo de ejecución, y se usa a menudo como un sitio donde guardar datos sin tener que construir una nueva subclase.

Peligro: Las propiedades cliente pueden parecer una forma fantástica de añadir soporte al cambio de propiedades para componentes personalizados, pero se nos recomienda explícitamente no hacerlo: “El diccionario clientProperty no está pensado para soportar un alto grado de extensiones de JComponent y no se debería considerar como una alternativa a la creación de subclases cuando se diseña un nuevo componente.”API

Las propiedades cliente son ligadas: cuando una de ellas cambia, se envía un PropertyChangeEvent a todos los PropertyChangeListeners registrados. Para añadir una propiedad a la Hashtable de propiedades cliente de un componente, tenemos que hacer lo siguiente:

miComponente.putClientProperty("minombre", miValor);

Para recuperar una propiedad cliente:

miObjeto = miComponente.getClientProperty("minombre");

Para borrar una propiedad cliente le asignamos un valor null:

miComponente.putClientProperty("minombre", null);

Por ejemplo, JDesktopPane usa una propiedad cliente para controlar la visualización del contorno mientras arrastramos JInternalFrames (esto funcionará sin importar el L&F que se esté usando):

miDesktop.putClientProperty("JDesktopPane.dragMode", "outline");

Nota: Puede localizar que propiedades tienen tienen eventos de cambio asociados con ellas, así como cualquier otro tipo de evento, inspeccionando el código fuente de Swing. A no ser que esté usando Swing para interfaces simples, le recomendamos que se acostumbre a esto.

Cinco componentes Swing tienen propiedades cliente especiales a las que solo el Metal L&F presta atención. Concretamente son estas:

• JTree.lineStyle

Un String que se usa para especificar si las relaciones entro los nodos se muestran como líneas angulosas (“Angled”), líneas horizontales que definen los límites de las celdas
(“Horizontal” — por defecto), o no se muestran líneas (“None”).

• JScrollBar.isFreeStanding

Un Boolean que se usa para especificar si JScrollbar tendrá un borde (Boolean.FALSE - - por defecto) o sólo las partes superior e izquierda (Boolean.TRUE).

• JSlider.isFilled

Un Boolean que especifica si la parte más baja de un deslizador (JSlider) debe estar rellena (Boolean.TRUE) o no (Boolean.FALSE — por defecto).

• JToolBar.isRollover

Un Boolean que sirve para determinar si un botón de la barra de herramientas muestra un borde grabado sólo cuando el puntero del ratón se encuentra entre sus límites y ningún borde cuando no (Boolean.TRUE), o se usa siempre un borde grabado (Boolean.FALSE — por defecto).

• JInternalFrame.isPalette

Un Boolean que especifica si se usa un borde muy fino (Boolean.TRUE) o el borde normal (Boolean.FALSE — por defecto). En Java 2 FCS no se usa esta propiedad.

Cambiando el tamaño y la posición

Como JComponent desciende de java.awt.Container, hereda todas las funcionalidades de posición y tamaño a las que estamos acostumbrados. Para manejar el tamaño preferido, máximo y mínimo de un componente disponemos de los siguientes métodos:

• setPreferredSize(), getPreferredSize()

El tamaño deseable de un componente. Lo usan la mayoría de los administradores de disposición (Layout Managers) para dimensionar los componentes.

• setMinimumSize(), getMinimumSize()

Usados durante el posicionamiento para especificar los límites inferiores de las dimensiones del componente.

• setMaximumSize(), getMaximumSize()

Usados durante el posicionamiento para especificar los límites superiores de las dimensiones del componente.

Cada uno de los métodos setXX()/getXX() acepta/devuelve una instancia de Dimension. Si un administrador de disposición presta atención o no a estos tamaños depende solamente de la implementación de dicho administrador. Es perfectamente factible construir un administrador que simplemente los ignore todos, o que sólo preste atención a uno. El dimensionado de los componentes en un contenedor es específico de cada administrador de disposición.

El método setBounds() de JComponent se puede usar para asignar a un componente el tamaño y la posición dentro de su contenedor padre. Este método está sobrecargado, y puede tomar tanto parámetros de tipo Rectangle (java.awt.Rectangle) como cuatro parámetros de tipo int que represente la altura, la anchura y las coordenadas x e y.

Por ejemplo, estas dos formas son equivalentes:

miComponent.setBounds(120,120,300,300);
Rectangle rec = new Rectangle(120,120,300,300);
miComponent.setBounds(rec);

Verá que setBounds() no pasará por encima de ninguna de las políticas de posicionamiento activas a causa de un administrador de disposición de un contenedor padre. Por esta razón una llamada a setBounds() puede parecer ignorada en determinadas situaciones porque intentó hacer su trabajo, pero el componente fue obligado a volver a su tamaño original por el administrador de disposición (los administradores de disposición siempre tienen la última palabra determinando el tamaño de un componente). setBounds() se usa normalmente para manejar componentes hijos en contenedores sin administrador de disposición (como JLayeredPane, JDesktopPane, y JComponent). Por ejemplo, usamos normalmente setBounds() cuando añadimos un JInternalFrame a un JDesktopPane. El tamaño de un componente se puede obtener al estilo de AWT:

int h = miComponente.getHeight();
int w = miComponente.getWidth();

El tamaño se puede recuperar también como una instancia de Rectangle o de Dimension:

Rectangle rec2 = miComponente.getBounds();
Dimension dim = miComponente.getSize();

Rectangle contiene cuatro propiedades accesibles públicamente que describen su posición y su tamaño:

int recX = rec2.x;
int recY = rec2.y;
int recAnchura = rec2.width;
int recAltura = rec2.height;

Dimension contiene dos propiedades accesibles públicamente que describen su tamaño:

int dimAnchura = dim.width;
int dimAltura = dim.height;

Las coordenadas que una instancia de Rectangle devuelve usando su método getBounds() representan la situación de un componente dentro de su padre. Estas coordenadas se pueden obtener también usando los métodos getX() y getY(). Adicionalmente, podemos determinar la posición de un componente dentro de su contenedor mediante el método setLocation(int x, int y).

JComponent también mantiene una alineación. La alineación horizontal o vertical se puede especificar con valores reales (float) entre 0.0 y 1.0: 0.5 significa el centro, valores más cercanos a 0.0 significan izquierda o arriba, y más cercanos a 1.0 significan derecha o abajo. Los correspondientes métodos de JComponent son:

setAlignmentX(float f);
setAlignmentY(float f);

Estos valores se usan sólo en contenedores que se manejan mediante BoxLayout o OverlayLayout.

Los componentes son los elementos básicos de la programación con Swing. Todo lo que se ve en un GUI de Java es un componente. Los componentes se colocan en otros
elementos llamados contenedores que sirven para agrupar componentes. Un administrador de diseño se encarga de de disponer la presentación de los componentes en un dispositivo de presentación concreto.

La clase javax.swing.JComponent es la clase padre de todos los componentes. A su vez, JComponent desciende de java.awt.container y ésta de java.awt.component. De esto se deduce que Swing es una extensión de AWT, de hecho su estructura es análoga.

La clase JComponent posee métodos para controlar la apariencia del objeto. Por ejemplo: la visibilidad, tamaño, posición, tipo de letra, color,… Al dibujar un componente, se le asigna un dispositivo de presentación. Además posee métodos que controlan el comportamiento del componente.

Cuando el usuario ejecuta una acción sobre un componente, entonces se crea un objeto de evento que describe el suceso. El objeto de evento se envía a objetos de control de eventos (Listeners). Los eventos son uno de los pilares de la construcción de Interfaces de usuario y una de las bases de la comunicación entre objetos.

Pares

En AWT se usaban interfaces de pares. Esto significaba que cada componente creado con AWT, creaba un par igual correspondiente al mundo real. Es decir al crear el botón,
existía el botón virtual creado en Java y el que realmente era dibujado en la pantalla (el real). El programador no necesita saber de la existencia de ese par, la comunicación del objeto creado con su par corría por cuenta de AWT.

Este modelo de componentes se elimina en Swing. En Swing se habla de componentes de peso ligero. La clase JComponent que es la raíz de clases Swing, no utiliza un par, cada componente es independiente del sistema de ventanas principal. Se dibujan a sí mismos y responden a los eventos de usuario sin ayuda de un par.

La ventaja de este modelo es que requiere menos recursos y que su modificación visual es más ágil y efectiva.

Modelo / Vista  / Controlador

Se trata del modelo fundamental del trabajo con interfaces de usuario por parte de Swing. Consiste en tres formas de abstracción. Un mismo objeto se ve de esas tres
formas:

• Modelo. Se refiere al modelo de datos que utiliza el objeto. Es la información que se manipula mediante el objeto Swing.
• Vista. Es cómo se muestra el objeto en la pantalla.
• Controlador. Es lo que define el comportamiento del objeto.

Por ejemplo un array de cadenas que contenga los meses del año, podría ser el modelo de un cuadro combinado de Windows. Un cuadro combinado es un rectángulo con un
botón con una flecha que permite elegir una opción de una lista. La vista de ese cuadro es el hecho de mostrar esas cadenas en ese rectángulo con flecha. Y el controlador es
la capa software que permite capturar el clic del ratón cuando apunta a la flecha del control a fin de mostrar y seleccionar el contenido.

Métodos del JComponent

La clase JComponent es abstracta, lo cual significa que no puede crear objetos, pero sí es la superclase de todos los componentes visuales (botones, listas, paneles, applets,…) y por ello la lista de métodos es interminable, ya que proporciona la funcionalidad de todos los componentes. Además puesto que deriva de Component y Container tiene los métodos de estos, por ello aún es más grande esta lista. Algunos son:

Métodos de Información:

Métodos de Apariencia y Posicion:

Los objetos java.awt.Point tienen como propiedades públicas las coordenadas x e y. Se construyen indicando el valor de esas coordenadas y disponen de varios métodos quepermiten modificar el punto.

Los objetos java.awt.Dimension tienen como propiedades la propiedad width (anchura) y height (altura). El método getDimension() obtiene un objeto Dimension con los valores del actual y setDimension() es un método que permite cambiar las dimensiones de varias formas.

Los objetos java.awt.Color representan colores y se pueden construir de las siguientes formas:

• Color(int rojo, int verde, int azul). Construye un objeto color indicando los niveles de rojo, verde y azul.
• Color(int rgb). Crea un color usando un único entero que indica los niveles de rojo, verde y azul. Se suele emplear con 6 dígitos en hexadecimal. Ejemplo: 0xFFCC33
• Color(int rojo, int verde, int azul, int alfa). Construye un objeto color indicando los niveles de rojo, verde y azul, y un valor de 0 a 255 indicando el valor alfa (alfa indica la transparencia).
• Color(int rgb). Crea un color usando un único entero que indica los niveles de rojo, verde y azul. Se suele emplear con 6 dígitos en hexadecimal. Ejemplo: 0xFFCC33
• Color(int rgb, int alfa).

Además existen constantes de colores ya fabricados: Color.RED, Color.YELLOW, Color.GREEN, Color.BLUE, Color.PINK, Color.GRAY, Color.CYAN, Color.DARK_GRAY, Color.LIGHT_GRAY, Color.MAGENTA, Color.PINK y Color.WHITE. Los objetos Color poseen además métodos interesantes para manipular colores.

Finalmente java.awt.Cursor es una clase que representa cursores y que se crea indicando un número que se puede reemplazar por una serie de constantes estáticas de
la propia clase Cursor, que representan cursores. Las constantes son: Cursor.HAND_CURSOR, Cursor.WAIT_CURSOR, Cursor.CROSSHAIR_CURSOR, Cursor.TEXT_CURSOR y otros.

Metodos de Dibujo

Activar y Desactivar Componentes

Enfocar

Para que un componente sea al que van dirigidas las pulsaciones de las teclas o, dicho de otra forma, el que recibe la interacción del usuario, debe poseer el enfoque (focus).

En muchos casos, el enfoque salta de un control al siguiente pulsando la tecla tabulador. Varios métodos se encargan de controlar ese salto:

Swing es un conjunto de clases desarrolladas por primera vez para Java 1.2 (el llamado Java2), para mejorar el anterior paquete que implementaba clases para fabricar interfaces de usuario, el llamado AWT (Abstract Window Tools) que aún se usa bastante en las aplicaciones Java.

Tanto Swing como AWT forman parte de una colección de clases llamada JFC (Java Foundation Classes) que incluyen paquetes dedicados a la programación de interfaces gráficos (así como a la producción multimedia).

Uno de los problemas frecuentes de la programación clásica era como programar interfaces de usuario, ya que esto  implicaba tener que utilizar las API propias del Sistema Operativo y esto provocaba que el código no fuera transportable a otros sistemas.
AWT fue la primera solución a este problema propuesta por Java. AWT está formada por un conjunto de clases que no dependen del sistema operativo, pero que proponen
una serie de clases para la programación de GUIs (graphic users interfaces, interfaces gráficos de usuario; cualquier entorno de comunicación entre el ordenador y el usuario).

AWT usa clases gráficas comunes a todos los sistemas operativos gráficos y luego la máquina virtual traduce esa clase a la forma que tenga en el sistema concreto en el que
se ejecutó el programa, sin importar que dicho sistema sea un sistema X, McIntosh o Windows. La popularidad de AWT desbordó las expectativas de la propia empresa Sun.
La clave de AWT era el uso de componentes iguales (peers). Los elementos de los interfaces AWT dejaban al sistema la responsabilidad de generar realmente los
componentes. Eso aseguraba una vista coherente respecto al sistema en el que se ejecutaba el programa. El problema es que ante la grandiosidad de la imagen en
Windows y Mac OS, otros sistemas quedaban peor ante la misma aplicación. Por ello (y por otros problemas) aparece Swing en la versión 1.2 como parte del JFC
(Java Foundation Classes) que es el kit de clases más importante de Java para las producciones gráficas.

Los problemas de AWT eran:

•  AWT tenía problemas de compatibilidad en varios sistemas.
•  A AWT le faltaban algunos componentes avanzados (árboles, tablas,…).
•  Consumía excesivos recursos del sistema.

Swing aporta muchas más clases, consume menos recursos y construye mejor la apariencia de los programas. En cualquier caso, AWT no desaparece; simplemente se
añade a las nuevas capacidades Swing.

Durante la ejecución de los programas existen muchas operaciones que precisan de una espera; en busca de una interacción con el exterior, dejando pasar el tiempo, esperando a que otro proceso acabe…

Java permite que estos tiempos desaprovechados sean utilizados por el programador para realizar determinadas tareas, y así aprovechar el microprocesador durante toda la ejecución del programa. Para ello implementa el concepto de threads, o hilos de control del programa.

Mediante el uso de varios threads, se consigue ejecutar varios procesos en paralelo, de forma que cuando uno de ellos esté esperando algún evento, permita que el microprocesador ejecute alguno de los otros threads en espera. Cuando el evento que el primer thread esperaba sucede, de nuevo se intercambian los threads para que el primer thread continúe su ejecución.

Todo esto viene a suplir a la técnica de exclusión mutua denominada utilización de semáforos, extendida entre los programadores de C en UNIX.

B. Utilización de thread

Para crear un thread, se ha de implementar una clase, extendiendo la clase base Runnable, y crear un objeto de la clase Thread. Este objeto representará un nuevo hilo de control, que será accionado cuando invoquemos al método start() del thread. En ese momento este hilo se activará, ejecutando (si el planificador de hilos considera que es el momento), el método run() de la clase en que todo esto suceda.

Por ejemplo, el siguiente programa utiliza dos hilos, el hilo general main, y el hilo thDemo que creamos:

import java.io.*;
import java.net.*;

class ThreadDemo implements Runnable {

     ThreadDemo() {
            Thread thDemo = new Thread( this, "ThDemo" );
            thDemo.start();
     }

     public void run() {
            try {
                  Thread.sleep(3000);
           } catch( InterruptedException e ) { }
           System.out.println("Saliendo del hilo hijo");
     }

     public static void main( String args[] ){
               new ThreadDemo();
               try {
                       for ( int i = 5 ; i >0 ; i-- ) {
                             System.out.println(" Seg: " + i );
                             Thread.sleep(1000);
                       }
               } catch( InterruptedException e ) { }
               System.out.println("Saliendo del main");
      }
}

Ambos hilos esperan utilizando el método sleep() de la clase Thread; thDemo tres segundos, y main cinco segundos. Java utilizará los tres segundos de thDemo para ir esperando los tres primeros segundos del hilo main.

Por lo tanto la salida por pantalla al ejecutar el programa es:

prompt> java ThreadDemo

Seg: 5

Seg: 4

Seg: 3

Saliendo del hilo hijo

Seg: 2

Seg: 1

Saliendo del hilo main

C. Sincronización de threads

Durante la ejecución de un programa, muchas veces varios procesos han de realizar tareas de una forma sincronizada, actuando en un determinado orden. Para ello en Java se utilizan la palabra reservada syncronized, en la declaración de los procesos con este tipo de características.

Los procesos declarados como syncronized mediante la utilización de excepciones, y de las funciones wait() y notifiy(), respectivamente esperarán a que otro proceso acabe antes de continuar su ejecución.

A continuación se va a ir viendo cómo implementar el clásico problema de exclusión mutua conocido como el problema del productor/consumidor, en el que dos procesos han de acceder a una cola común, en la que el proceso productor inserta elementos en la pila, y el proceso consumidor ha de ir consumiendo los elementos en la pila, cada vez que sean insertados:

class ColaSincronizada {

      int n;
      boolean bandera = false;

      synchronized int obten() {

              if ( !bandera )
                     try wait(); catch( InterruptedException e );
              System.out.println( "Obtenido: " + n );
              bandera = false;
              notify();
              return n;
       }

        synchronized void coloca( int paramN ) {
              if ( bandera )
                    try wait(); catch( InterruptedException e );
               n = paramN;
               bandera =true;
               System.out.println( "Colocado: " + n );
               notify();
        }
}

class Productor implements Runnable {

           ColaSincronizada colaProductor;
           Productor( ColaSincronizada paramCola ) {
                    colaProductor = paramCola;
                    new Thread( this, "Producer" ).start();
           }

           public void run() {
                    int i = 0;
                    while ( true ) // Bucle infinito
                             colaProductor.coloca( i++ );
           }
}

class Consumidor implements Runnable {
            ColaSincronizada colaConsumidor;
            Consumidor( ColaSincronizada paramCola ) {
                      colaConsumidor = paramCola;
                      new Thread( this, "Consumidor" ).start();
            }

            public void run() {
                      while ( true ) // Bucle infinito
                             colaConsumidor.obten( );
            }
}

public static void main( String args[] ) {

            ColaSincronizada colaLocal = new  ColaSincronizada();
            new Productor( colaLocal );
            new Consumidor( colaLocal );
}

La salida del programa será:

Colocado: 1

Obtenido: 1

Colocado: 2

Obtenido: 2

Colocado: 3

Obtenido: 3

. . .

D. Y mucho más

La utilización de programación concurrente y de los hilos de Java con toda su potencia va mucho más allá de los objetivos de este tutorial. Lo que aquí se ha visto es simplemente una introducción para que el lector sea consciente de cuál es la potencia de este tipo de programación.

La utilización de los threads se extiende con métodos para que el programador controle la alternancia de los hilos. Estos métodos son:

suspend(); Bloquea temporalmente la ejecución de un hilo.
resume(); Activa un hilo bloqueado.
stop(); Finaliza la ejecución de un hilo.

Los paquetes son el mecanismo por el que Java permite agrupar clases, interfaces, excepciones y constantes. De esta forma, se agrupan conjuntos de estructuras de datos y de clases con algún tipo de relación en común.

Con la idea de mantener la reutilización y facilidad de uso de los paquetes desarrollados es conveniente que las clases e interfaces contenidas en los mismos tengan cierta relación funcional. De esta manera los desarrolladores ya tendrán una idea de lo que están buscando y fácilmente sabrán qué pueden encontrar dentro de un paquete.

Creación de un paquete

a.) Declaración

Para declarar un paquete se utiliza la sentencia package seguida del nombre del paquete que estemos creando:

package NombrePaquete;

La estructura que ha de seguir un fichero fuente en Java es:

• Una única sentencia de paquete (opcional).
• Las sentencias de importación deseadas (opcional).
• La declaración de una (y sólo una) clase pública (public).
• Las clases privadas del paquete (opcional).
• Por lo tanto la sentencia de declaración de paquete ha de ser la primera en un archivo fuente Java.

b.) Nomenclatura

Para que los nombres de paquete puedan ser fácilmente reutilizados en toda una compañía o incluso en todo el mundo es conveniente darles nombres únicos. Esto puede ser una tarea realmente tediosa dentro de una gran empresa, y absolutamente imposible dentro de la comunidad de Internet.

Por eso se propone asignar como paquetes y subpaquetes el nombre de dominio dentro de Internet. Se verá un ejemplo para un dominio que se llamase japon.magic.com, un nombre apropiado sería com.magic.japon.paquete.

c.) Subpaquetes

Cada paquete puede tener a su vez paquetes con contenidos parecidos, de forma que un programador probablemente estará interesado en organizar sus paquetes de forma jerárquica. Para eso se definen los subpaquetes.

Para crear un subpaquete bastará con almacenar el paquete hijo en un directorio Paquete/Subpaquete.

Así una clase dentro de un subpaquete como Paquete.Subpaquete.clase estará codificada en el fichero Paquete/Subpaquete.java.

El JDK define una variable de entorno denominada CLASSPATH que gestiona las rutas en las que el JDK busca los subpaquetes. El directorio actual suele estar siempre incluido en la variable de entorno CLASSPATH.

Uso de un paquete

Con el fin de importar paquetes ya desarrollados se utiliza la sentencia import seguida del nombre de paquete o paquetes a importar.

Se pueden importar todos los elementos de un paquete o sólo algunos.

Para importar todas las clases e interfaces de un paquete se utiliza el metacaracter *:

import PaquetePrueba.*;

También existe la posibilidad de que se deseen importar sólo algunas de las clases de un cierto paquete o subpaquete:

import Paquete.Subpaquete1.Subpaquete2.Clase1;

Para acceder a los elementos de un paquete, no es necesario importar explícitamente el paquete en que aparecen, sino que basta con referenciar el elemento tras una especificación completa de la ruta de paquetes y subpaquetes en que se encuentra.

Paquete.Subpaquetes1.Subpaquete2.Clase_o_Interfaz.elemento

En la API de Java se incluyen un conjunto de paquetes ya desarrollados que se pueden incluir en cualquier aplicación (o applet) Java que se desarrolle.

Ámbito de los elementos de un paquete

Al introducir el concepto de paquete, surge la duda de cómo proteger los elementos de una clase, qué visibilidad presentan respecto al resto de elementos del paquete, respecto a los de otros paquetes…

Ya en la herencia se vieron los identificadores de visibilidad public (visible a todas las clases), private (no visible más que para la propia clase), y protected (visible a clases hijas).

Por defecto se considera los elementos (clases, variables y métodos) de un mismo paquete como visibles entre ellos (supliendo las denominadas clases amigas de C++).

Todas las reglas explicadas en este apartado son igualmente válidas para las interfaces Java.

A. Introducción

Las interfaces Java son expresiones puras de diseño. Se trata de auténticas conceptualizaciones no implementadas que sirven de guía para definir un determinado concepto (clase) y lo que debe hacer, pero sin desarrollar un mecanismo de solución.

Se trata de declarar métodos abstractos y constantes que posteriormente puedan ser implementados de diferentes maneras según las necesidades de un programa.

Por ejemplo una misma interfaz podría ser implementada en una versión de prueba de manera poco óptima, y ser acelerada convenientemente en la versión definitiva tras conocer más a fondo el problema.

B. Declaración

Para declarar una interfaz se utiliza la sentencia interface, de la misma manera que se usa la sentencia class:

interface MiInterfaz {

     int CONSTANTE = 100;

     int metodoAbstracto( int parametro );

}

Se observa en la declaración que las variables adoptan la declaración en mayúsculas, pues en realidad actuarán como constantes final. En ningún caso estas variables actuarán como variables de instancia.

Por su parte, los métodos tras su declaración presentan un punto y coma, en lugar de su cuerpo entre llaves. Son métodos abstractos, por tanto, métodos sin implementación

C. Implementación de una interfaz

Como ya se ha visto, las interfaces carecen de funcionalidad por no estar implementados sus métodos, por lo que se necesita algún mecanismo para dar cuerpo a sus métodos.

La palabra reservada implements utilizada en la declaración de una clase indica que la clase implementa la interfaz, es decir, que asume las constantes de la interfaz, y codifica sus métodos:

class ImplementaInterfaz implements MiInterfaz{

       int multiplicando=CONSTANTE;

       int metodoAbstracto( int parametro ){

                  return ( parametro * multiplicando );

       }

}

En este ejemplo se observa que han de codificarse todos los métodos que determina la interfaz (metodoAbstracto()), y la validez de las constantes (CONSTANTE) que define la interfaz durante toda la declaración de la clase.

Una interfaz no puede implementar otra interfaz, aunque sí extenderla (extends) ampliándola.

D. Herencia múltiple

Java es un lenguaje que incorpora herencia simple de implementación pero que puede aportar herencia múltiple de interfaz. Esto posibilita la herencia múltiple en el diseño de los programas Java.

Una interfaz puede heredar de más de una interfaz antecesora.

interface InterfazMultiple extends Interfaz1,Interfaz2{ }

Una clase no puede tener más que una clase antecesora, pero puede implementar más de una interfaz:

class MiClase extends SuPadre implements Interfaz1,Interfaz2{ }

El ejemplo típico de herencia múltiple es el que se presenta con la herencia en diamante:

Para poder llevar a cabo un esquema como el anterior en Java es necesario que las clases A, B y C de la figura sean interfaces, y que la clase D sea una clase (que recibe la herencia múltiple):

interface A{ }

interface B extends A{ }

interface C extends A{ }

class D implements B,C{ }

E. Colisiones en la herencia múltiple

En una herencia múltiple, los identificadores de algunos métodos o atributos pueden coincidir en la clase que hereda, si dos de las interfaces padres tienen algún método o atributo que coincida en nombre. A esto se le llama colisión.

Esto se dará cuando las clases padre (en el ejemplo anterior B y C) tienen un atributo o método que se llame igual. Java resuelve el problema estableciendo una serie de reglas.

Para la colisión de nombres de atributos, se obliga a especificar a qué interfaz base pertenecen al utilizarlos.

Para la colisión de nombres en métodos:

• Si tienen el mismo nombre y diferentes parámetros: se produce sobrecarga de métodos permitiendo que existan varias maneras de llamar al mismo.
• Si sólo cambia el valor devuelto: se da un error de compilación, indicando que no se pueden implementar los dos.
• Si coinciden en su declaración: se elimina uno de los dos, con lo que sólo queda uno.

F. Envolturas de los tipos simples

Los tipos de datos de Java no forman parte de la jerarquía de objetos. Sin embargo a veces es necesario crear una representación como objeto de alguno de los tipos de datos simples de Java.

La API de Java contiene un conjunto de interfaces especiales para modificar el comportamiento de los tipos de datos simple. A estas interfaces se las conoce como envolturas de tipo simple.

Todas ellas son hijas de la clase abstracta Number y son:

• Double: Da soporte al tipo double.
• Float: Da soporte al tipo float.
• Integer: Da soporte a los tipos int, short y byte.
• Long: Da soporte al tipo long.
• Character: Envoltura del tipo char.
• Boolean: Envoltorio al tipo boolean.