REPÚBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA EDUCACIÓN UNIVERSITARIA

INSTITUTO UNIVERSITARIO TECNOLÓGICO “ANTONIO RICAURTE”

CAGUA - EDO. ARAGUA

Aplicaciones bajo Ambiente Gráfico de JAVA-Swing

Docente: Sorellys Sánchez Autor: Gustavo Herrera

Sección: 749 CIV: 30.081.806

Cagua, julio de 2022

 AWT y SWING en JAVA

AWT y Swing son dos de las bibliotecas disponibles en el paquete estándar de Java
para la creación de interfaces gráficas de usuario. AWT descansa sobre el SO para la creación
de los componentes gráficos. Swing abstrae el SO y proporciona su propia colección de
componentes gráficos. Dicho en otras palabras, es una API para crear aplicaciones GUI en
Java. Este es un marco dependiente de la plataforma, es decir, los componentes de
la GUI de AWT no son los mismos en todas las plataformas.

Dependiendo de la interfaz original de la plataforma, la apariencia de los componentes

AWT también cambia. Java AWT crea componentes llamando a subrutinas desde plataformas
nativas. Por lo tanto, una aplicación GUI de AWT se verá como el sistema operativo
Windows cuando se ejecute en Windows y se verá como el sistema operativo Mac cuando
se ejecute en Mac, etc.

Esto muestra la dependencia de la plataforma de las aplicaciones resumidas del kit de

herramientas de Windows. Debido a su naturaleza dependiente de la plataforma y con
muchos componentes, hoy en día rara vez se usa en las aplicaciones Java. Además, también
hay marcos más nuevos como Swing que son livianos e independientes de la plataforma.

Por otro lado, Swing es una biblioteca de gráficos para Java. Incluye elementos
de interfaz de usuario para GUI, como cuadros de texto, botones, listas desplegables y tablas.
Swing contiene componentes más flexibles y robustos que AWT. Swing proporciona los
mismos componentes básicos del kit de herramientas de Windows y también componentes
más avanzados como árbol, panel de pestañas, etc.

Componentes y Eventos

AWT incluye todos los componentes de AWT que estaban presentes en la versión 1.1.2
del JDK y aquellos que se han incorporado en:

 Java 2D: Es un conjunto de clases gráficas bajo licencia de IBM/Taligent, que todavía
está en construcción
  Accesibilidad: Proporciona clases para facilitar el uso de ordenadores y tecnología
informática a disminuidos, como lupas de pantalla, y cosas así
 Arrastrar y Soltar (Drag and Drop): Son clases en las que se soporta Glasgow, que es la
nueva generación de los JavaBeans
 Swing: Esta es la parte más importante y avanzada. Fue construido con Netscape y
proporciona una serie de componentes bien definidos y descritos de tal manera que su
presentación visual es independiente de la plataforma en la que se ejecuta el applet o la
aplicación que utiliza estas clases. Swing simplemente extiende AWT agregando un
conjunto de componentes, JComponents y sus clases de soporte. Hay muchos
componentes de Swing similares a AWT, algunos de los cuales comparten la
arquitectura Model-View-Controller (MVC), aunque Swing también proporciona otros
elementos de interfaz de usuario nuevos, como árboles, pestañas y más.
 La estructura básica del AWT: Se basa en Componentes y Contenedores. Estos últimos
contienen Componentes posicionados a su respecto y son Componentes a su vez, de
forma que los eventos pueden tratarse tanto en Contenedores como en Componentes,
corriendo por cuenta del programador (todavía no hay herramientas de composición
visual) el encaje de todas las piezas, así como la seguridad de tratamiento de los
eventos adecuados.

Menús

Los menús siempre están en el centro de la aplicación, ya que son el medio por el cual
el usuario interactúa con la aplicación. La diferencia entre una aplicación útil y una
completamente molesta está en la organización de las listas, pero aquí las reglas para diseñar
un buen árbol de listas no están claras. Hay muchos libros sobre ergonomía y cómo interactúa
el usuario. Lo cierto es que por todos los que defienden una idea, tiene que haber alguien más
que defienda la contraria. Todavía no hay acuerdo para crear un estándar, se publica una guía
de estilo diferente con cada administrador de Windows.

En Java, la jerarquía de clases involucradas en la creación y manipulación de listas

aparece en la siguiente lista: java.lang.Object

MenuShorcut
 java.awt.MenuComponent

java.awt.MenuBar

java.awt.MenuItem

java.awt.Menu

java.awt.CheckboxMenuItem

java.awt.PopMenu

 MenuComponent: Es la superclase de todos los Componentes relacionados con menús.

 MenuShortcut: Representa el acelerador de teclado, o la combinación de teclas rápidas,
para acceder a un MenuItem.
 MenuItem: Representa una opción en un menú.
 Menu: Es un Componente de una barra de menú.
 MenuBar: Encapsula el concepto de una barra de menú en un Frame.
 PopupMenu: Implementa un menú que puede ser presentado dinámicamente dentro de
un Componente.
 CheckboxMenuItem: Genera una caja de selección que representa una opción en un
menú.

En SWING los menús están formados por los siguientes componentes, estos componentes
permiten vincular opciones de menú en nuestras ventanas, tipo menú principal, como por
ejemplo el conocido Inicio, Archivo, Edición etc.

 JMenuBar: Permite vincular una barra de menús.

 JMenu: Permite vincular botones o enlaces que al ser pulsados despliegan un menú
principal.
 JMenuItem: Botón u opción que se encuentra en un menú.
 JCheckBoxMenuItem: Elemento del menú como opciones de checkbox.
 JRadioButtonMenuItem: Elemento del menú como botón de selección.
 JPopupMenu: Opciones de menús emergentes.
 Layout

Los layout managers o administrador de diseño, en traducción literal, ayuda a

personalizar los diferentes elementos que desea combinar en un panel, es decir, define cómo
deben verse los elementos cuando se colocan en un contenedor, y controla automáticamente el
tamaño y posición (tema).

Sin embargo, Java brinda la capacidad de desarrollar nuestra interfaz de forma dinámica
mediante el uso del administrador de diseño o administrador de componentes, para ayudar a
adaptar los diferentes componentes que queremos combinar en un solo componente
incorporados a un panel, es decir, determina su forma cuando se coloca en el contenedor,
controla automáticamente el tamaño y la posición (layout). Para ello, Java dispone de varios
tipos de layout manager, a saber:

 FlowLayout
 BorderLayout
 CardLayout
 GridLayout
 GridBagLayout
 BoxLayout
 OverlayLayout
 CustomLayout

Por otro lado en Swing cuando hacemos ventanas, la clase que decide cómo se reparten los
botones (Y demás controles) dentro de la ventana se llama Layout. Esta clase es la que decide
en qué posición van los botones y demás componentes, si van alineados, en forma de matriz,
cuáles se hacen grandes al agrandar la ventana, etc.

Con un layout adecuado, el método pack() de la ventana hará que coja el tamaño necesario
para que se vea todo lo que tiene dentro.

ventana.pack();
 Formularios

La ventana de diseño en Java es una herramienta útil que permite diseñar formularios
en java de forma relativamente sencilla, dentro del entorno sólo queda añadir componentes al
formulario como las etiquetas que marcan las opciones, los botones con los que se van a
realizar las acciones dentro de Java, los cuadros de textos donde se coloca el contenido que
comunica directamente el tema del sitio, de igual forma es posible cambiar sus propiedades
según los intereses del desarrollador web y de lo que se quiera lograr con el proyecto.

Ejemplo que muestra cómo crear formularios utilizando múltiples paneles (JPanels), unos
dentro de otros.

package formularios; panelex = new JPanel();

import java.awt.*; nombre = new JLabel();

import java.awt.event.*; apellidos = new JLabel();

import javax.swing.*; telefono = new JLabel();

public class Formulario { dni = new JLabel();

JFrame frame; text1 = new JTextField();

JPanel paneliz,panelde,panelab,panelar,panelex; text2 = new JTextField();

JLabel nombre,apellidos,telefono,dni; text3 = new JTextField();

JTextField text1,text2,text3,text4; text4 = new JTextField();

JButton boton1,boton2; boton1 = new JButton();

PanelBD(){ boton2 = new JButton();

frame = new JFrame(); frame.setTitle("Formulario");

paneliz = new JPanel(); frame.setLayout(new FlowLayout());

panelde = new JPanel();

frame.setDefaultCloseOperation(JFrame.EXIT_ON
panelab = new JPanel();
_CLOSE);

panelar = new JPanel();

frame.setVisible(true);
 frame.setResizable(false); panelab.setPreferredSize(new
Dimension(200,50));
frame.setSize(300,170);
panelab.add(boton1);
nombre.setText("Nombre");
panelab.add(boton2);
apellidos.setText("Apellidos");
panelex.setLayout(new GridLayout(2,0));
telefono.setText("Telefono");
panelex.add(panelar);
dni.setText("DNI");
panelex.add(panelab);
boton1.setText("Aceptar");
frame.add(panelex);
boton2.setText("Cancelar");
}
paneliz.setLayout(new GridLayout(4,0));
public static void main(String[] args) {
paneliz.add(nombre);
Formulario pa = new Formulario();
paneliz.add(apellidos);
}
paneliz.add(telefono);

paneliz.add(dni);

panelde.setLayout(new GridLayout(4,0));

panelde.add(text1);

panelde.add(text2);

panelde.add(text3);

panelde.add(text4);

panelar.setLayout(new GridLayout(1,1));

panelar.setPreferredSize(new
Dimension(250,100));

panelar.add(paneliz);

panelar.add(panelde);

panelab.setLayout(new FlowLayout());
 Applets

Un applet es una pequeña aplicación Java, la cual está disponible en un servidor

web del cual nos la descargamos y ejecutamos dentro de una página web. Algunas de
sus características son:

 Tamaño pequeño, esto es debido a que se requiere su descarga a través de la red.

Aunque existen applets de gran tamaño.
 Uso de interfaces gráficos, utiliza las clases AWT y Swing, las cuales dotan a la
interface del applet de una gran versatilidad y operabilidad para el usuario.

La definición de los applets se encuentra dentro de la librería. Java.applet, la cual

deberemos de importar para poder utilizarla. Además, necesitaremos de la librería
java.awt que es la que gestionará los recursos gráficos que se incluyan dentro del
applet. La librería java.applet cuenta con una clase abstracta Applet, de la que
deberemos de heredar en la clase principal de nuestra aplicación.

import java.applet.*;

public class miApplet extends Applet {

//variables y métodos

En nuestro primer applet, lógicamente, deberemos de codificar la aplicación que

nos muestre la cadena de texto “Hola Mundo”. Veamos el código:

import java.awt.*;

import java.applet.*;

public class MiApplet extends Applet {

 public void paint (Graphics g) {

g.drawString("Hola Mundo",30,30);

Gráficos, Texto e Imágenes

Java proporciona la clase Graphics, que le permite dibujar elipses, cuadrados,

líneas, mostrar texto y muchos otros métodos de dibujo. Para cualquier programador,
la comprensión de la clase de gráficos es esencial antes de sumergirse en el dibujo en
Java. La clase Graphics proporciona el entorno de trabajo para cualquier operación
gráfica que se realice dentro del AWT.

Para poder pintar, el programa necesita un contexto de gráficos válido, que

está representado por una instancia de la clase de gráficos. Pero esta clase no se puede
instanciar directamente; Entonces necesitamos crear un componente y pasarlo al
programa como un argumento para el método paint().

El único argumento del método paint() es un objeto de esta clase. La clase

Graphics contiene métodos que admiten tres tipos de operaciones gráficas:

1) Dibujo de primitivas gráficas,

2) Dibujo de texto,
3) Presentación de imágenes en formatos *.gif y *.jpeg.

Además, la clase Graphics conserva el contexto de los gráficos: el área de dibujo

actual, los colores de fondo y de primer plano, la fuente con todas sus propiedades,
etc. Los cubos están en la esquina superior izquierda. Las coordenadas siempre se
miden en píxeles.
 Swing también introduce nuevos componentes dentro de la manipulación de
textos. Así la clase JTextArea actúa como sustituto de la clase TextArea del AWT, la
clase JTextField sustituye TextField del AWT y se incorporan las clases
JPasswordField que viene a ser equivalente al uso de JTextField junto con el método
setEchoChar(), y la clase JTextPane que permite que se presente el texto con
diferentes fuentes de caracteres, colores, tamaños, etc.

Las propiedades del texto renderizado se modifican a través de estilos. El estilo es un

conjunto de características como FontSize, ForegroundColor, isBold, isItalic, etc. Las
constantes se manipulan como muestra la siguiente línea:

StyleConstants.setForeground( estilo,Color.red )

El componente JTextPane, que permite estos cambios, siempre tiene un estilo

predeterminado como plantilla, DefaultStyleDocument. En la siguiente figura, la
primera línea se escribe tan pronto como se inicia el programa, es decir, con el estilo
predeterminado de la aplicación, y las siguientes líneas se ingresan cambiando el
estilo para que coincida con el color del texto.

Por último, los objetos Graphics pueden mostrar imágenes a través del
método:

drawImage( Image img,int x,int y,ImageObserver observador );

Hay que tener en cuenta que el método drawImage() necesita un objeto Image
y un objeto ImageObserver. Podemos cargar una imagen desde un fichero de dibujo
(actualmente sólo se soportan formatos GIF y JPEG) con el método getImage():

Image img = getImage( getDocumentBase(),"fichero.gif" );

La forma de invocar al método getImage() es indicando un URL donde se

encuentre el fichero que contiene la imagen que queremos presentar y el nombre de
ese fichero:
getImage( URL directorioImagen,String ficheroImagen );

Animaciones

La animación es divertida en muchos sentidos. Las imágenes valen más que

mil palabras y los videos son más útiles. La animación es esencial para presentar o
representar un concepto en particular. Además, la animación, o cómo se crean las
animaciones en Java, muestra las muchas formas en que el lenguaje produce gráficos.

La animación se puede hacer de una manera muy simple. El método paint()

está definido para dibujar algo diferente de lo que se pintó antes cada vez que se
llama. Sin embargo, tenga en cuenta que el programador no llama a este método
directamente.

*El programador llama al método sleet

El hilo que se usa para el bucle con la espera es el hilo del main:

package chuidiang.ejemplos;

import java.awt.dimension; /**

import java.awt.graphics; * ejemplo de ventana con unas rayas

moviendose.

*
import javax.swing.jframe;
* @author chuidiang
import javax.swing.jpanel;
*
import javax.swing.windowconstants;
*/
public class pruebamovimiento extends jpanel // creacion y visualizacion de la
ventana
{
jframe v = new jframe();
/** coordenadas x1,y1 y x2,y2 de
los extremos de pruebamovimiento panel = new
pruebamovimiento();
* la raya.
v.getcontentpane().add(panel);
*/
v.pack();
public int x1 = 0;

public int y1 = 0; v.setdefaultcloseoperation(windowconstants.e

xit_on_close);
public int x2 = 100;

v.setvisible(true);
public int y2 = 100;

// bucle para cambiar las coordenadas de

/**
los puntos

* presenta una ventana con el panel

while (true)
dentro. en la ventana

{
* una diagonal cambia de vertices cada
segundo. if (panel.y1 == 0)

* @param args panel.y1 = 100;

*/ else

public static void main(string[] args) panel.y1 = 0;

{
 if (panel.y2 == 0) e.printstacktrace();

panel.y2 = 100; }

else }

panel.y2 = 0; }

// se provoca el repintado del panel. /**

// la llamada a repaint() hará que java * dibuja la diagonal de x1,y1 a x2,y2

llame al metodo
*
// paint() que hemos redefinido.
* @param g
panel.repaint();
*/

public void paint(graphics g)

// retardo de un segundo (1000
milisegundos) {

try super.paint(g);

{ g.drawline(x1, y1, x2, y2);

thread.sleep(1000); }

catch (interruptedexception e) /**

{ * devuelve un tamaño preferido para hacer

que la ventana tenga
 * tamaño 100x100 pixels public dimension getpreferredsize()

* {

* @return dimension de 100x100 pixels. return new dimension(100, 100);

*/ }

Threads

El Thread o subproceso es un flujo único de control de programa. A veces se

denomina contexto de ejecución porque cada subproceso debe tener sus propios
recursos, como un contador de programa y una pila de ejecución, como su propio
contexto de ejecución. Sin embargo, cada subproceso del programa aún comparte
muchos recursos, como espacio de memoria y archivos abiertos.

Thread Paralelas y Concurrentes

Cuando dos threads corren en paralelo, ambas están siendo corridas al mismo
tiempo en diferentes CPUs. Dos thread concurrentes están en progreso, o intentando
de obtener tiempo de ejecución de la CPU al mismo tiempo, pero no necesariamente
están corriendo en forma simultánea en dos CPUs diferentes.

Ejemplo: Programa de thread única:

En el programa WithoutThread.java, el método run() en la clase

NoThreadPseudoIO es creado para simular una operación de IO de 10 segundos. El
programa primero simulará una operación de IO.

Métodos del Programa de Thread única:

El método showElapsedTime() imprime el tiempo en segundos desde que el

programa partió, junto con el mensaje del usuario. El método currentTimeMillis() de
la clase System del paquete java.lang retorna un entero que corresponde a la
diferencia de tiempo en milisegundos desde la hora 00:00:00 GMT on January 1,
1970. a la actual.

Ejemplo: Programa Multithreded (multihilo):

El programa multithreaded WithThread.java declara la clase para simular IO

como una subclase de la clase Thread. Después que la thread es creada, el programa
multihilos (multithreaded) usa el método start() de la clase Thread para hacer partir la
operación de IO. El método start() a su vez llama a run() de la subclase.