public interface Action extends ActionListener
Action interface provides a useful extension to the
 ActionListener
 interface in cases where the same functionality may be accessed by
 several controls.
 
 In addition to the actionPerformed method defined by the
 ActionListener interface, this interface allows the
 application to define, in a single place:
 
 This interface can be added to an existing class or used to create an
 adapter (typically, by subclassing AbstractAction).
 The Action object
 can then be added to multiple Action-aware containers
 and connected to Action-capable
 components. The GUI controls can then be activated or
 deactivated all at once by invoking the Action object's
 setEnabled method.
 
 Note that Action implementations tend to be more expensive
 in terms of storage than a typical ActionListener,
 which does not offer the benefits of centralized control of
 functionality and broadcast of property changes.  For this reason,
 you should take care to only use Actions where their benefits
 are desired, and use simple ActionListeners elsewhere.
 
 
Action
 Many of Swing's components have an Action property.  When
 an Action is set on a component, the following things
 happen:
 
Action is added as an ActionListener to
     the component.
 Action.
 PropertyChangeListener on the
     Action so that the component can change its properties
     to reflect changes in the Action's properties.
 
 The following table describes the properties used by
 Swing components that support Actions.
 In the table, button refers to any
 AbstractButton subclass, which includes not only
 JButton but also classes such as
 JMenuItem. Unless otherwise stated, a
 null property value in an Action (or a
 Action that is null) results in the
 button's corresponding property being set to null.
 
| Component Property | Components | Action Key | Notes | 
|---|---|---|---|
| enabled | All | The isEnabledmethod | |
| toolTipText | All | SHORT_DESCRIPTION | |
| actionCommand | All | ACTION_COMMAND_KEY | |
| mnemonic | All buttons | MNEMONIC_KEY | A nullvalue orActionresults in the
          button'smnemonicproperty being set to'\0'. | 
| text | All buttons | NAME | If you do not want the text of the button to mirror that
          of the Action, set the propertyhideActionTexttotrue.  IfhideActionTextistrue, setting theActionchanges the text of the button tonulland any changes toNAMEare ignored.hideActionTextis useful for
          tool bar buttons that typically only show anIcon.JToolBar.add(Action)sets the property totrueif theActionhas a
          non-nullvalue forLARGE_ICON_KEYorSMALL_ICON. | 
| displayedMnemonicIndex | All buttons | DISPLAYED_MNEMONIC_INDEX_KEY | If the value of DISPLAYED_MNEMONIC_INDEX_KEYis
          beyond the bounds of the text, it is ignored.  WhensetActionis called, if the value from theActionisnull, the displayed
          mnemonic index is not updated.  In any subsequent changes toDISPLAYED_MNEMONIC_INDEX_KEY,nullis treated as -1. | 
| icon | All buttons except of JCheckBox,JToggleButtonandJRadioButton. | either LARGE_ICON_KEYorSMALL_ICON | The JMenuItemsubclasses only useSMALL_ICON.  All other buttons will useLARGE_ICON_KEY; if the value isnullthey
         useSMALL_ICON. | 
| accelerator | All JMenuItemsubclasses, with the exception ofJMenu. | ACCELERATOR_KEY | |
| selected | JToggleButton,JCheckBox,JRadioButton,JCheckBoxMenuItemandJRadioButtonMenuItem | SELECTED_KEY | Components that honor this property only use
          the value if it is non-null. For example, if
          you set anActionthat has anullvalue forSELECTED_KEYon aJToggleButton, theJToggleButtonwill not update it's selected state in
          any way. Similarly, any time theJToggleButton's
          selected state changes it will only set the value back on
          theActionif theActionhas anon-nullvalue forSELECTED_KEY.Components that honor this property keep their selected state in sync with this property. When the same Actionis used
          with multiple components, all the components keep their selected
          state in sync with this property. Mutually exclusive
          buttons, such asJToggleButtons in aButtonGroup,
          force only one of the buttons to be selected. As such, do not
          use the sameActionthat defines a value for theSELECTED_KEYproperty with multiple mutually
          exclusive buttons. | 
 JPopupMenu, JToolBar and JMenu
 all provide convenience methods for creating a component and setting the
 Action on the corresponding component.  Refer to each of
 these classes for more information.
 
 Action uses PropertyChangeListener to
 inform listeners the Action has changed.  The beans
 specification indicates that a null property name can
 be used to indicate multiple values have changed.  By default Swing
 components that take an Action do not handle such a
 change.  To indicate that Swing should treat null
 according to the beans specification set the system property
 swing.actions.reconfigureOnNull to the String
 value true.
AbstractAction| Modifier and Type | Field | Description | 
|---|---|---|
| static String | ACCELERATOR_KEY | The key used for storing a  KeyStroketo be used as the
 accelerator for the action. | 
| static String | ACTION_COMMAND_KEY | The key used to determine the command  Stringfor theActionEventthat will be created when anActionis going to be notified as the result of
 residing in aKeymapassociated with aJComponent. | 
| static String | DEFAULT | Not currently used. | 
| static String | DISPLAYED_MNEMONIC_INDEX_KEY | The key used for storing an  Integerthat corresponds
 to the index in the text (identified by theNAMEproperty) that the decoration for a mnemonic should be rendered at. | 
| static String | LARGE_ICON_KEY | The key used for storing an  Icon. | 
| static String | LONG_DESCRIPTION | The key used for storing a longer  Stringdescription for the action, could be used for context-sensitive help. | 
| static String | MNEMONIC_KEY | The key used for storing an  Integerthat corresponds to
 one of theKeyEventkey codes. | 
| static String | NAME | The key used for storing the  Stringname
 for the action, used for a menu or button. | 
| static String | SELECTED_KEY | The key used for storing a  Booleanthat corresponds
 to the selected state. | 
| static String | SHORT_DESCRIPTION | The key used for storing a short  Stringdescription for the action, used for tooltip text. | 
| static String | SMALL_ICON | The key used for storing a small  Icon, such
 asImageIcon. | 
| Modifier and Type | Method | Description | 
|---|---|---|
| void | addPropertyChangeListener(PropertyChangeListener listener) | Adds a  PropertyChangelistener. | 
| Object | getValue(String key) | Gets one of this object's properties
 using the associated key. | 
| boolean | isEnabled() | Returns the enabled state of the  Action. | 
| void | putValue(String key,
        Object value) | Sets one of this object's properties
 using the associated key. | 
| void | removePropertyChangeListener(PropertyChangeListener listener) | Removes a  PropertyChangelistener. | 
| void | setEnabled(boolean b) | Sets the enabled state of the  Action. | 
actionPerformedstatic final String DEFAULT
static final String NAME
String name
 for the action, used for a menu or button.static final String SHORT_DESCRIPTION
String
 description for the action, used for tooltip text.static final String LONG_DESCRIPTION
String
 description for the action, could be used for context-sensitive help.static final String SMALL_ICON
Icon, such
 as ImageIcon.  This is typically used with
 menus such as JMenuItem.
 
 If the same Action is used with menus and buttons you'll
 typically specify both a SMALL_ICON and a
 LARGE_ICON_KEY.  The menu will use the
 SMALL_ICON and the button will use the
 LARGE_ICON_KEY.
static final String ACTION_COMMAND_KEY
String for the
 ActionEvent that will be created when an
 Action is going to be notified as the result of
 residing in a Keymap associated with a
 JComponent.static final String ACCELERATOR_KEY
KeyStroke to be used as the
 accelerator for the action.static final String MNEMONIC_KEY
Integer that corresponds to
 one of the KeyEvent key codes.  The value is
 commonly used to specify a mnemonic.  For example:
 myAction.putValue(Action.MNEMONIC_KEY, KeyEvent.VK_A)
 sets the mnemonic of myAction to 'a', while
 myAction.putValue(Action.MNEMONIC_KEY, KeyEvent.getExtendedKeyCodeForChar('?'))
 sets the mnemonic of myAction to Cyrillic letter "Ef".static final String SELECTED_KEY
Boolean that corresponds
 to the selected state.  This is typically used only for components
 that have a meaningful selection state.  For example,
 JRadioButton and JCheckBox make use of
 this but instances of JMenu don't.
 
 This property differs from the others in that it is both read
 by the component and set by the component.  For example,
 if an Action is attached to a JCheckBox
 the selected state of the JCheckBox will be set from
 that of the Action.  If the user clicks on the
 JCheckBox the selected state of the JCheckBox
 and the Action will both be updated.
 
 Note: the value of this field is prefixed with 'Swing' to
 avoid possible collisions with existing Actions.
static final String DISPLAYED_MNEMONIC_INDEX_KEY
Integer that corresponds
 to the index in the text (identified by the NAME
 property) that the decoration for a mnemonic should be rendered at.  If
 the value of this property is greater than or equal to the length of
 the text, it will treated as -1.
 
 Note: the value of this field is prefixed with 'Swing' to
 avoid possible collisions with existing Actions.
AbstractButton.setDisplayedMnemonicIndex(int), 
Constant Field Valuesstatic final String LARGE_ICON_KEY
Icon.  This is typically
 used by buttons, such as JButton and
 JToggleButton.
 
 If the same Action is used with menus and buttons you'll
 typically specify both a SMALL_ICON and a
 LARGE_ICON_KEY.  The menu will use the
 SMALL_ICON and the button the LARGE_ICON_KEY.
 
 Note: the value of this field is prefixed with 'Swing' to
 avoid possible collisions with existing Actions.
void putValue(String key, Object value)
PropertyChangeEvent is sent
 to listeners.key - a String containing the keyvalue - an Object valuevoid setEnabled(boolean b)
Action.  When enabled,
 any component associated with this object is active and
 able to fire this object's actionPerformed method.
 If the value has changed, a PropertyChangeEvent is sent
 to listeners.b - true to enable this Action, false to disable itboolean isEnabled()
Action. When enabled,
 any component associated with this object is active and
 able to fire this object's actionPerformed method.Action is enabledvoid addPropertyChangeListener(PropertyChangeListener listener)
PropertyChange listener. Containers and attached
 components use these methods to register interest in this
 Action object. When its enabled state or other property
 changes, the registered listeners are informed of the change.listener - a PropertyChangeListener objectvoid removePropertyChangeListener(PropertyChangeListener listener)
PropertyChange listener.listener - a PropertyChangeListener objectaddPropertyChangeListener(java.beans.PropertyChangeListener) Submit a bug or feature 
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
 Copyright © 1993, 2025, Oracle and/or its affiliates.  All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.