Swing es un kit de herramientas de widget de GUI para Java . [1] Es parte de Oracle 's Java Foundation Classes (JFC) - una API para proporcionar una interfaz gráfica de usuario (GUI) para programas Java.
Swing fue desarrollado para proporcionar un conjunto más sofisticado de componentes GUI que el anterior Abstract Window Toolkit (AWT) . Swing proporciona una apariencia que emula la apariencia de varias plataformas, y también admite una apariencia conectable que permite que las aplicaciones tengan una apariencia y sensación que no están relacionadas con la plataforma subyacente. Tiene componentes más potentes y flexibles que AWT. Además de los componentes familiares como botones, casillas de verificación y etiquetas, Swing proporciona varios componentes avanzados como paneles con pestañas, paneles de desplazamiento, árboles, tablas y listas. [2]
A diferencia de los componentes de AWT, los componentes de Swing no se implementan mediante un código específico de la plataforma. En cambio, están escritos completamente en Java y, por lo tanto, son independientes de la plataforma.
En diciembre de 2008, Sun Microsystems (el predecesor de Oracle) lanzó el marco basado en CSS / FXML que pretendía ser el sucesor de Swing, llamado JavaFX . [3]
Historia
Los Foundation Classes de Internet (CFI) eran una biblioteca de gráficos para Java desarrollado originalmente por Netscape Communications Corporation y lanzado por primera vez el 16 de diciembre de 1996. El 2 de abril de 1997, Sun Microsystems y Netscape Communications Corporation ha anunciado su intención de incorporar la IFC con otras tecnologías a forman las clases fundamentales de Java . [4] Las "Clases Fundamentales de Java" fueron posteriormente renombradas como "Swing".
Swing introdujo un mecanismo que permitía modificar la apariencia de cada componente de una aplicación sin realizar cambios sustanciales en el código de la aplicación. La introducción de soporte para una apariencia y sensación conectables permite que los componentes de Swing emulen la apariencia de los componentes nativos mientras aún conservan los beneficios de la independencia de la plataforma. Distribuido originalmente como una biblioteca descargable por separado, Swing se ha incluido como parte de Java Standard Edition desde la versión 1.2. [5] Las clases y componentes de Swing están contenidos en la jerarquía de javax.swing
paquetes .
El desarrollo del sucesor de Swing, JavaFX , comenzó en 2005 y se presentó oficialmente dos años más tarde en JavaOne 2007. [6] JavaFX fue de código abierto en 2011 y, en 2012, se convirtió en parte de la descarga de Oracle JDK. JavaFX está reemplazando a Swing debido a varias ventajas, que incluyen ser más liviano, tener estilo CSS , controles de diseño elegantes y el uso de FXML y Scene Builder. [7] En 2018, JavaFX se hizo parte de OpenJDK bajo el proyecto OpenJFX para aumentar el ritmo de su desarrollo. [8]
Los miembros del equipo de Java Client responsable de Swing incluían a Jeff Dinkins (gerente), Georges Saab, [9] Jim Graham, Rick Levenson, Tim Prinzing, Jonni Kanerva, Jeannette Hung, Tom Ball y Amy Fowler (líder técnico). [10]
Arquitectura
Swing es un marco de GUI de " modelo-vista-controlador " independiente de la plataforma para Java, que sigue un modelo de programación de un solo subproceso . [11] Además, este marco proporciona una capa de abstracción entre la estructura del código y la presentación gráfica de una GUI basada en Swing.
Cimientos
Swing es independiente de la plataforma porque está completamente escrito en Java. La documentación completa para todas las clases de Swing se puede encontrar en la Guía de API de Java para la Versión 6 o la Especificación de API de Java Platform Standard Edition 8 para la Versión 8.
Extensible
Swing es una arquitectura altamente modular, que permite "conectar" varias implementaciones personalizadas de interfaces de marco específicas: los usuarios pueden proporcionar sus propias implementaciones personalizadas de estos componentes para anular las implementaciones predeterminadas utilizando el mecanismo de herencia de Java a través de javax.swing.LookAndFeel
.
Swing es un marco basado en componentes , cuyos componentes se derivan en última instancia de la javax.swing.JComponent
clase. Los objetos Swing activan eventos de forma asincrónica, tienen propiedades vinculadas y responden a un conjunto documentado de métodos específicos del componente. Los componentes Swing son componentes JavaBeans , que cumplen con la especificación JavaBeans .
Configurable
La gran dependencia de Swing de los mecanismos de ejecución y los patrones de composición indirectos le permite responder en tiempo de ejecución a cambios fundamentales en su configuración. Por ejemplo, una aplicación basada en Swing es capaz de intercambiar en caliente su interfaz de usuario durante el tiempo de ejecución. Además, los usuarios pueden proporcionar su propia implementación de apariencia, lo que permite cambios uniformes en la apariencia de las aplicaciones Swing existentes sin ningún cambio programático en el código de la aplicación.
- Interfaz de usuario ligera
El alto nivel de flexibilidad de Swing se refleja en su capacidad inherente para anular los controles GUI del sistema operativo (SO) nativo del host para mostrarse a sí mismo. Swing "pinta" sus controles utilizando las API 2D de Java, en lugar de llamar a un juego de herramientas de interfaz de usuario nativo. Por lo tanto, un componente de Swing no tiene un componente de GUI de SO nativo correspondiente y es libre de renderizarse de cualquier manera que sea posible con las GUI de gráficos subyacentes.
Sin embargo, en su esencia, cada componente de Swing se basa en un contenedor AWT , ya que el contenedor (de Swing) se JComponent
extiende (AWT). Esto permite que Swing se conecte al marco de gestión de la GUI del sistema operativo host, incluidas las asignaciones cruciales de dispositivos / pantallas y las interacciones del usuario, como las pulsaciones de teclas o los movimientos del mouse. Swing simplemente "transpone" su propia semántica (independiente del sistema operativo) sobre los componentes subyacentes (específicos del sistema operativo). Entonces, por ejemplo, cada componente de Swing pinta su interpretación en el dispositivo gráfico en respuesta a una llamada a component.paint (), que se define en (AWT) Container. Pero a diferencia de los componentes AWT, que delegaron la pintura a su widget "pesado" nativo del sistema operativo, los componentes Swing son responsables de su propia representación.
Esta transposición y desacoplamiento no es meramente visual, y se extiende a la administración y aplicación de Swing de su propia semántica independiente del sistema operativo para eventos disparados dentro de sus jerarquías de contención de componentes. En términos generales, la arquitectura Swing delega la tarea de mapear los diversos sabores de la semántica de la GUI del sistema operativo en un patrón simple, pero generalizado, para el contenedor AWT. Sobre la base de esa plataforma generalizada, establece su propia semántica GUI rica y compleja en la forma del JComponent
modelo.
Acoplado libremente y MVC
La biblioteca Swing hace un uso intensivo del patrón de diseño del software modelo-vista-controlador , [12] que conceptualmente desacopla los datos que se ven de los controles de la interfaz de usuario a través de los cuales se ven. Debido a esto, la mayoría de los componentes de Swing tienen modelos asociados (que se especifican en términos de interfaces Java ), y los programadores pueden usar varias implementaciones predeterminadas o proporcionar las suyas propias. El marco proporciona implementaciones predeterminadas de interfaces modelo para todos sus componentes concretos. El uso típico del marco Swing no requiere la creación de modelos personalizados, ya que el marco proporciona un conjunto de implementaciones predeterminadas que están asociadas de manera transparente, por defecto, con la clase secundaria correspondiente en la biblioteca Swing. En general, solo los componentes complejos, como tablas, árboles y, a veces, listas, pueden requerir implementaciones de modelos personalizados alrededor de las estructuras de datos específicas de la aplicación. Para tener una buena idea del potencial que hace posible la arquitectura Swing, considere la situación hipotética en la que los modelos personalizados para tablas y listas son envoltorios sobre los servicios DAO y / o EJB .JComponent
Por lo general, los objetos del modelo de componente Swing son responsables de proporcionar una interfaz concisa que define los eventos activados y propiedades accesibles para el modelo de datos (conceptual) para que lo utilice el JComponent asociado. Dado que el patrón MVC general es un patrón de relación de objeto colaborativo débilmente acoplado, el modelo proporciona los medios programáticos para adjuntar detectores de eventos al objeto del modelo de datos. Por lo general, estos eventos se centran en el modelo (por ejemplo, un evento de "fila insertada" en un modelo de tabla) y la especialización JComponent los asigna a un evento significativo para el componente GUI.
Por ejemplo, JTable
tiene un modelo llamado TableModel
que describe una interfaz de cómo una tabla accedería a los datos tabulares. Una implementación predeterminada de esto opera en una matriz bidimensional .
El componente de vista de un Swing JComponent es el objeto utilizado para representar gráficamente el control de la GUI conceptual. Una distinción de Swing, como marco de GUI, es su dependencia de los controles de GUI representados mediante programación (a diferencia del uso de los controles de GUI del sistema operativo host nativo). Antes de Java 6 Update 10 , esta distinción era una fuente de complicaciones al mezclar controles AWT, que usan controles nativos, con controles Swing en una GUI (consulte Mezcla de componentes AWT y Swing ).
Finalmente, en términos de composición visual y administración, Swing favorece los diseños relativos (que especifican las relaciones posicionales entre los componentes) en contraposición a los diseños absolutos (que especifican la ubicación exacta y el tamaño de los componentes). Este sesgo hacia el ordenamiento visual "fluido" se debe a sus orígenes en el entorno operativo del subprograma que enmarcó el diseño y desarrollo del juego de herramientas GUI de Java original. (Conceptualmente, esta vista de la gestión del diseño es bastante similar a la que informa la representación del contenido HTML en los navegadores y aborda el mismo conjunto de preocupaciones que motivaron la primera).
Relación con AWT
Desde las primeras versiones de Java, una parte del Abstract Window Toolkit (AWT) ha proporcionado API independientes de la plataforma para los componentes de la interfaz de usuario. En AWT, cada componente es renderizado y controlado por un componente de pares nativo específico del sistema de ventanas subyacente.
Por el contrario, los componentes de Swing a menudo se describen como livianos porque no requieren la asignación de recursos nativos en el kit de herramientas de ventanas del sistema operativo. Los componentes de AWT se denominan componentes de peso pesado . [13]
Gran parte de la API de Swing es generalmente una extensión complementaria del AWT en lugar de un reemplazo directo. De hecho, cada interfaz ligera oscilación existe en última instancia dentro de un componente de peso pesado AWT porque todos los componentes de nivel superior de Swing ( JApplet
, JDialog
, JFrame
, y JWindow
) se extienden un contenedor de nivel superior AWT. Antes de Java 6 Update 10 , generalmente se desaconsejaba el uso de componentes ligeros y pesados dentro de la misma ventana debido a incompatibilidades de orden Z. Sin embargo, las versiones posteriores de Java han solucionado estos problemas, y los componentes Swing y AWT ahora se pueden usar en una GUI sin problemas de orden Z.
Java 2D , otra parte de JFC, proporciona la funcionalidad de renderizado principal que utiliza Swing para dibujar sus componentes ligeros .
Relación con SWT
El kit de herramientas de widget estándar (SWT) es un kit de herramientas de la competencia desarrollado originalmente por IBM y ahora mantenido por la comunidad de Eclipse . La implementación de SWT tiene más en común con los componentes pesados de AWT. Esto confiere beneficios como una fidelidad más precisa con el kit de herramientas de ventanas nativas subyacentes, a costa de una mayor exposición a la plataforma nativa en el modelo de programación.
Ha habido un gran debate y especulación sobre el rendimiento de SWT frente a Swing; algunos insinuaron que la fuerte dependencia de SWT en JNI lo haría más lento cuando el componente GUI y Java necesitan comunicar datos, pero más rápido en la representación cuando el modelo de datos se ha cargado en la GUI, pero esto no se ha confirmado de ninguna manera. [14] Un conjunto bastante completo de puntos de referencia en 2005 llegó a la conclusión de que ni Swing ni SWT superaron claramente al otro en el caso general. [15]
Ejemplos de
Hola Mundo
Esta aplicación de ejemplo de Swing crea una ventana única con "¡Hola, mundo!" adentro:
// Hola.java (Java SE 5) import javax.swing. * ;La clase pública Hola extiende JFrame { Hola público () { super ( "hola" ); esto . setDefaultCloseOperation ( WindowConstants . EXIT_ON_CLOSE ); esto . add ( new JLabel ( "¡Hola, mundo!" )); esto . paquete (); esto . setVisible ( verdadero ); } public static void main ( final String [] args ) { new Hello (); } }
El primero import
incluye todas las clases e interfaces públicas del javax.swing
paquete.
La Hello
clase extends
la JFrame
clase; la JFrame
clase implementa una ventana con una barra de título y un control cercano .
El Hello()
constructor inicializa el marco llamando primero al constructor de la superclase, pasando el parámetro "hello"
, que se usa como título de la ventana. Luego llama al setDefaultCloseOperation(int)
método heredado de JFrame
para establecer la operación predeterminada cuando se selecciona el control de cierre en la barra de título WindowConstants.EXIT_ON_CLOSE
; esto hace JFrame
que se elimine cuando el marco está cerrado (en lugar de simplemente oculto), lo que permite que la máquina virtual Java para salir y el programa para terminar. A continuación, JLabel
se crea un para la cadena "¡Hola, mundo!" y se llama al add(Component)
método heredado de la Container
superclase para agregar la etiqueta al marco. El pack()
método heredado de la Window
superclase se llama para dimensionar la ventana y diseñar su contenido.
La main()
máquina virtual Java llama al método cuando se inicia el programa. Se crea la instancia de un nuevo Hello
marco y hace que se visualiza mediante una llamada al setVisible(boolean)
método heredado de la Component
superclase con el parámetro booleano true
. Una vez que se muestra el marco, salir del main
método no hace que el programa termine porque el subproceso de despacho de eventos AWT permanece activo hasta que se eliminan todas las ventanas de nivel superior de Swing.
Ventana con botón
El siguiente es un programa bastante simple basado en Swing. Muestra una ventana (a JFrame
) que contiene una etiqueta y un botón.
import java.awt.FlowLayout ; import javax.swing.JButton ; import javax.swing.JFrame ; import javax.swing.JLabel ; import javax.swing.WindowConstants ; import javax.swing.SwingUtilities ; La clase pública SwingExample implementa Runnable { @Override public void run () { // Crea la ventana JFrame f = new JFrame ( "¡Hola ,! " ); // Establece el comportamiento para cuando la ventana está cerrada f . setDefaultCloseOperation ( WindowConstants . EXIT_ON_CLOSE ); // Agregue un administrador de diseño para que el botón no se coloque encima de la etiqueta f . setLayout ( nuevo FlowLayout ()); // Agrega una etiqueta y un botón f . add ( new JLabel ( "¡Hola, mundo!" )); f . add ( new JButton ( "¡ Presióname !" )); // Organizar los componentes dentro de la ventana f . paquete (); // Por defecto, la ventana no es visible. Hazlo visible. f . setVisible ( verdadero ); } public static void main ( String [] args ) { SwingExample se = new SwingExample (); // Programa la aplicación para que se ejecute en el momento correcto en la cola de eventos. SwingUtilities . invokeLater ( se ); }}
Observe cómo todas las instancias y el manejo de los componentes de Swing se realizan mediante la creación de una instancia de la clase, que implementa la interfaz Runnable. Esto luego se ejecuta en el subproceso de envío de eventos mediante el uso del método SwingUtilities.invokeLater(Runnable)
), creado en el método principal (consulte Swing y seguridad de subprocesos ). Aunque el código de Swing se puede ejecutar sin usar esta técnica (por ejemplo, al no implementar Runnable y mover todos los comandos del método de ejecución al método principal), se considera de buena forma, ya que Swing no es seguro para subprocesos , lo que significa que La invocación de recursos de varios subprocesos puede provocar interferencias de subprocesos y errores de coherencia de la memoria. [dieciséis]
Otro ejemplo
En este ejemplo, dejemos que javax.swing.JFrame sea una superclase y agreguemos nuestros propios widgets (en este caso, un JButton).
import javax.swing.JFrame ; import javax.swing.JButton ; import javax.swing.JOptionPane ; import javax.swing.SwingUtilities ;import java.awt.event.ActionListener ; import java.awt.event.ActionEvent ;público clase de muestra se extiende JFrame { privada definitiva JButton b = nuevo JButton (); Muestra pública () { super (); esto . setTitle ( "HelloApp" ); esto . getContentPane (). setLayout ( nulo ); esto . setBounds ( 100 , 100 , 180 , 140 ); esto . agregar ( makeButton ()); esto . setVisible ( verdadero ); esto . setDefaultCloseOperation ( EXIT_ON_CLOSE ); }private JButton makeButton () { b . setText ( "¡Haz clic en mí!" ); b . setBounds ( 40 , 40 , 100 , 30 ); b . addActionListener ( new ActionListener () { public void actionPerformed ( ActionEvent e ) { JOptionPane . showMessageDialog ( b , "¡Hola mundo!" ); } }); volver b ; }public static void main ( String [] args ) { // El hilo de despacho de eventos debe ejecutar las llamadas Swing. SwingUtilities . invokeAndWait (() -> nueva Muestra ()); } }
El diseño se establece en nulo usando el Container.setLayout(LayoutManager)
método ya que JFrame usa java.awt.BorderLayout como su administrador de diseño predeterminado. Con BorderLayout, todo lo que se agrega al contenedor se coloca en el centro y se estira para acomodar cualquier otro widget. Por supuesto, la mayoría de las aplicaciones GUI del mundo real preferirían usar un administrador de diseño en lugar de colocar todo en coordenadas absolutas. [17]
Ver también
- swingLabs : extensiones de Swing que podrían incluirse en Swing en el futuro.
- Kit de herramientas de widgets estándar : un kit de herramientas de widgets de terceros mantenido por Eclipse Foundation .
- JavaFX : una plataforma de software para crear y entregar aplicaciones de escritorio , así como aplicaciones de Internet enriquecidas que pueden ejecutarse en una amplia variedad de dispositivos, que está destinada a ser la sucesora de Swing. JavaFX es actualmente parte de OpenJDK , bajo el proyecto OpenJFX . [18]
Referencias
Citas
- ^ "¿Qué es Java Swing? - Definición de Techopedia" . Techopedia Inc . Consultado el 3 de noviembre de 2018 .
- ^ Yap, Chee (30 de abril de 2003). "TUTORIAL GUI JAVA SWING" . Universidad de Nueva York (NYU) . Consultado el 3 de noviembre de 2018 .
- ^ "Desarrollo de una aplicación GUI básica usando JavaFX en Eclipse" .
- ^ "Sun y Netscape para desarrollar conjuntamente Java Foundation Classes" . Corporación de comunicaciones de Netscape . 1997-04-02. Archivado desde el original el 9 de mayo de 2012 . Consultado el 8 de agosto de 2011 .
- ^ "SUN ENTREGA LA PRÓXIMA VERSIÓN DE LA PLATAFORMA JAVA" . Sun Microsystems . Agosto de 2007. Archivado desde el original el 16 de agosto de 2007 . Consultado el 8 de enero de 2012 .
Las clases de Java Foundation son ahora el núcleo de la plataforma Java 2 e incluyen: el conjunto de componentes GUI de Project Swing, arrastrar y soltar, API Java 2D que proporciona nuevas capacidades de gráficos 2D y AWT, así como soporte de impresión, la interfaz de apariencia y sensación de Java , Una nueva API de accesibilidad
CS1 maint: URL no apta ( enlace ) - ^ "Actualización de JDK 11: JavaFX se desacoplará del JDK" .
- ^ "Desarrollo de una aplicación GUI básica usando JavaFX en Eclipse" .
- ^ Smith, Donald (7 de marzo de 2018). "El futuro de JavaFX y otras actualizaciones de la hoja de ruta del cliente Java" .
- ^ Zakhour, Sharon. "¿Por qué se llama swing?" . El blog de tutoriales de Java . Consultado el 24 de septiembre de 2020 .
- ^ John, Yu. “Los clientes ricos emergen como alternativas para las aplicaciones web” . ComputerWorld . Consultado el 24 de septiembre de 2020 .
- ^ Zukowski, John (21 de agosto de 2007). "Swing threading y el subproceso de despacho de eventos" . JavaWorld . Consultado el 26 de julio de 2020 .
- ^ Fowler, Amy. "Una descripción general de la arquitectura de swing" . Sun Microsystems . Consultado el 26 de julio de 2020 .
- ^ Zakhour, Sharon; Petrov, Anthony (abril de 2010). "Mezcla de componentes ligeros y pesados" . Oracle . Consultado el 26 de julio de 2020 .
- ^ Strenn, Stephen (3 de marzo de 2006). "Rendimiento Swing vs SWT - Eche un vistazo a las pilas de llamadas" . Javalobby . Archivado desde el original el 17 de septiembre de 2017.
- ^ Žagar, Klemen; Križnar, Igor (3 de marzo de 2006). "Comparación de rendimiento SWT Vs. Swing" (PDF) (1.4 ed.). Cosylab. Archivado desde el original (PDF) el 26 de mayo de 2015.
Es difícil dar una regla empírica en la que SWT supere al swing, o viceversa. En algunos entornos (por ejemplo, Windows), SWT es un ganador. En otros (Linux, VMware con Windows), Swing y su optimización de redibujado superan significativamente a SWT. Las diferencias en el desempeño son significativas: los factores de 2 y más son comunes, en cualquier dirección.
- ^ http://docs.oracle.com/javase/tutorial/uiswing/concurrency/dispatch.html El hilo de envío de eventos
- ^ Eckel, Bruce (2006). Pensando en Java (PDF) (4 ed.). Prentice Hall. pag. 942. ISBN 978-0131872486. Archivado desde el original (PDF) el 14 de mayo de 2016 . Consultado el 13 de mayo de 2016 .
- ^ "Inicio del desarrollador JavaFX" . www.oracle.com .
Fuentes
- Matthew Robinson, Pavel Vorobiev: Swing, segunda edición , Manning, ISBN 1-930110-88-X
- David M. Geary : Java gráfico 2, Volumen 2: Swing , Prentice Hall, ISBN 0-13-079667-0
- John Zukowski: La guía definitiva de Java Swing, tercera edición , Apress, ISBN 1-59059-447-9
- James Elliott, Robert Eckstein , Marc Loy , David Wood, Brian Cole: Java Swing , O'Reilly, ISBN 0-596-00408-7
- Kathy Walrath , Mary Campione , Alison Huml , Sharon Zakhour : The JFC Swing Tutorial: A Guide to Constructing GUIs , Addison-Wesley Professional, ISBN 0-201-91467-0
- Joshua Marinacci , Chris Adamson: Hacks de swing , O'Reilly, ISBN 0-596-00907-0
- Ivan Portyankin , Swing, Effective User Interfaces (Ruso) ., 2ª Ed., 2010, Moscú, "Lory", ISBN 5-469-00005-2
enlaces externos
- La documentación de la API de Swing