Oyentes de GUI de Java sin AWT

Soy un desarrollador de Java principiante, aprendiendo solo de los tutoriales de Internet. Estoy aprendiendo aplicaciones GUI de pantalla completa. Ayer me dijeron que no debería usar AWT en mis programas porque está desactualizado. Ya conozco los componentes livianos y pesados, el principal problema son los oyentes del mouse y el teclado. ¿Por qué AWT está desactualizado? ¿Cómo hacer un programa sin AWT (agregar oyentes a JComponents, etc.) (qué tipo de cosas Swing pueden reemplazar al AWT)?

Está malinterpretando la información que se le proporcionó. Debe evitar el uso de componentes Swing con componentes AWT . Está bien usar Swing con la estructura de escucha de AWT, los administradores de diseño, etc. y, de hecho, es imposible no hacerlo.

Ha habido algunas buenas respuestas, pero me gustaría cubrir un aspecto ligeramente diferente. Cosas que ofrece Swing más allá de AWT.

Componentes

Swing admite documentos con estilo en JEditorPane& JTextPane& hasta cierto punto utilizando HTML en algunos otros JComponents. AWT no admite documentos con estilo en ningún componente.

AWT no proporciona una estructura basada en árboles como JTree, ni una estructura tabular como JTable, ni una versión de JToolBar.

AWT no tiene equivalente (que pueda encontrar o recordar) para JColorChooser& none para la clase de utilidad simple - JOptionPane.

Oyentes

Como se mencionó en un comentario, vea los más de 20 oyentes adicionales / alternativos en el javax.swing.eventpaquete.

Look & Feel enchufable

Los componentes de swing se pueden configurar para un aspecto y una sensación particulares en tiempo de ejecución, incluido un PLAF nativo.

Vea las capturas de pantalla en el Ejemplo de diseño anidado para ver algunos ejemplos más.

Diseños

Además de la gran cantidad de diseños de AWT, Swing proporciona:

1. BoxLayout
2. GroupLayout
3. OverlayLayout
4. ScrollPaneLayout
5. SpringLayout
6. ViewportLayout

Otro

• Atajos de teclado. Consulte Cómo utilizar las combinaciones de teclas para obtener más detalles.
• UndoManager para deshacer / rehacer en documentos editables.
• Doble búfer incorporado para evitar el parpadeo al volver a pintar.
• SwingWorker para GUI sensibles.

Probablemente haya mucho más que me perdí en esa breve descripción, pero la conclusión es que Swing es un conjunto de herramientas de GUI más nuevo y más habilitado.

Swing se basa y depende en gran medida de las clases del AWT.

Swing de Java utiliza ActionListeners, que son parte del paquete AWT. Si desea utilizar swing, debe utilizar alguna forma de AWT ActionListener. Así son las cosas. No sugiero usar Java en absoluto para guis complejos, pero tampoco diría que AWT está desactualizado, ya que no hay un reemplazo directo. Por lo tanto, siga adelante y use AWT.

Como alternativa, podrías buscar en JOGL, pero eso es más si estás intentando crear algo orientado al juego.

Este es un pequeño ejemplo que puede demostrar el uso del paquete javax.swing.Action . También debe consultar el documento java para el paquete javax.swing.event . Creo que lo está encontrando. . .

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JToolBar;

class SysOutHelloAction extends AbstractAction {
    private static final Icon printIcon = new ImageIcon("Print.gif");

    SysOutHelloAction() {
        super("Print", printIcon);
        putValue(Action.SHORT_DESCRIPTION, "Hello, World");
    }

    public void actionPerformed(ActionEvent actionEvent) {
        System.out.println("Hello, World");
    }
}

public class SwingActionTester {
    public static void main(String args[]) {
        JFrame frame = new JFrame("Action Sample");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        final Action printAction = new SysOutHelloAction();
        JMenuBar menuBar = new JMenuBar();
        JMenu menu = new JMenu("File");
        menuBar.add(menu);
        menu.add(new JMenuItem(printAction));
        JToolBar toolbar = new JToolBar();
        toolbar.add(new JButton(printAction));
        JButton enableButton = new JButton("Enable");
        ActionListener enableActionListener = new ActionListener() {
            public void actionPerformed(ActionEvent actionEvent) {
                printAction.setEnabled(true);
            }
        };
        enableButton.addActionListener(enableActionListener);
        JButton disableButton = new JButton("Disable");
        ActionListener disableActionListener = new ActionListener() {
            public void actionPerformed(ActionEvent actionEvent) {
                printAction.setEnabled(false);
            }
        };
        disableButton.addActionListener(disableActionListener);
        JButton relabelButton = new JButton("Relabel");
        ActionListener relabelActionListener = new ActionListener() {
            public void actionPerformed(ActionEvent actionEvent) {
                printAction.putValue(Action.NAME, "Changed Action Value");
            }
        };
        relabelButton.addActionListener(relabelActionListener);
        JPanel buttonPanel = new JPanel();
        buttonPanel.add(enableButton);
        buttonPanel.add(disableButton);
        buttonPanel.add(relabelButton);
        frame.setJMenuBar(menuBar);
        frame.add(toolbar, BorderLayout.SOUTH);
        frame.add(buttonPanel, BorderLayout.NORTH);
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

Tienes razón. Tanto Java AWT como Java Spring están obsoletos. Utilice JavaFX en su lugar.
Y, como comentario, estoy frustrado con Java, que se suponía que era "escribir una vez y ejecutarlo en todas partes", cuando ahora resulta que "debe seguir reescribiendo su aplicación cada tres meses" porque las nuevas versiones de Java rompen el código anterior, y los paquetes nuevos reemplazan a los antiguos.