## Uses of Interface
java.awt.MenuContainer

- Packages that use MenuContainer
  Package | Description
  --- | ---
  java.applet | Provides the classes necessary to create an applet and the classes an applet uses to communicate with its applet context.
  java.awt | Contains all of the classes for creating user interfaces and for painting graphics and images.
  javax.swing | Provides a set of "lightweight" (all-Java language) components that, to the maximum degree possible, work the same on all platforms.
  javax.swing.colorchooser | Contains classes and interfaces used by the `JColorChooser` component.
  javax.swing.plaf.basic | Provides user interface objects built according to the Basic look and feel.
  javax.swing.plaf.metal | Provides user interface objects built according to the Java look and feel (once codenamed Metal), which is the default look and feel.
  javax.swing.table | Provides classes and interfaces for dealing with `javax.swing.JTable`.
  javax.swing.text | Provides classes and interfaces that deal with editable and noneditable text components.
  javax.swing.tree | Provides classes and interfaces for dealing with `javax.swing.JTree`.

- - ### Uses of MenuContainer in java.applet

    Classes in java.applet that implement MenuContainer
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `Applet` | Deprecated. The Applet API is deprecated, no replacement.

  - ### Uses of MenuContainer in java.awt

    Classes in java.awt that implement MenuContainer
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `Button` | This class creates a labeled button.
    `class` | `Canvas` | A `Canvas` component represents a blank rectangular area of the screen onto which the application can draw or from which the application can trap input events from the user.
    `class` | `Checkbox` | A check box is a graphical component that can be in either an "on" (`true`) or "off" (`false`) state.
    `class` | `Choice` | The `Choice` class presents a pop-up menu of choices.
    `class` | `Component` | A component is an object having a graphical representation that can be displayed on the screen and that can interact with the user.
    `class` | `Container` | A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT components.
    `class` | `Dialog` | A Dialog is a top-level window with a title and a border that is typically used to take some form of input from the user.
    `class` | `FileDialog` | The `FileDialog` class displays a dialog window from which the user can select a file.
    `class` | `Frame` | A `Frame` is a top-level window with a title and a border.
    `class` | `Label` | A `Label` object is a component for placing text in a container.
    `class` | `List` | The `List` component presents the user with a scrolling list of text items.
    `class` | `Menu` | A `Menu` object is a pull-down menu component that is deployed from a menu bar.
    `class` | `MenuBar` | The `MenuBar` class encapsulates the platform's concept of a menu bar bound to a frame.
    `class` | `Panel` | `Panel` is the simplest container class.
    `class` | `PopupMenu` | A class that implements a menu which can be dynamically popped up at a specified position within a component.
    `class` | `Scrollbar` | The `Scrollbar` class embodies a scroll bar, a familiar user-interface object.
    `class` | `ScrollPane` | A container class which implements automatic horizontal and/or vertical scrolling for a single child component.
    `class` | `TextArea` | A `TextArea` object is a multi-line region that displays text.
    `class` | `TextComponent` | The `TextComponent` class is the superclass of any component that allows the editing of some text.
    `class` | `TextField` | A `TextField` object is a text component that allows for the editing of a single line of text.
    `class` | `Window` | A `Window` object is a top-level window with no borders and no menubar.

    Methods in java.awt that return MenuContainer
    Modifier and Type | Method | Description
    --- | --- | ---
    `MenuContainer` | MenuComponent.`getParent()` | Returns the parent container for this menu component.

  - ### Uses of MenuContainer in javax.swing

    Classes in javax.swing that implement MenuContainer
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `AbstractButton` | Defines common behaviors for buttons and menu items.
    `class` | `Box` | A lightweight container that uses a BoxLayout object as its layout manager.
    `static class` | `Box.Filler` | An implementation of a lightweight component that participates in layout but has no view.
    `class` | `CellRendererPane` | This class is inserted in between cell renderers and the components that use them.
    `class` | `DefaultListCellRenderer` | Renders an item in a list.
    `static class` | `DefaultListCellRenderer.UIResource` | A subclass of DefaultListCellRenderer that implements UIResource.
    `class` | `JApplet` | Deprecated. The Applet API is deprecated, no replacement.
    `class` | `JButton` | An implementation of a "push" button.
    `class` | `JCheckBox` | An implementation of a check box -- an item that can be selected or deselected, and which displays its state to the user.
    `class` | `JCheckBoxMenuItem` | A menu item that can be selected or deselected.
    `class` | `JColorChooser` | `JColorChooser` provides a pane of controls designed to allow a user to manipulate and select a color.
    `class` | `JComboBox<E>` | A component that combines a button or editable field and a drop-down list.
    `class` | `JComponent` | The base class for all Swing components except top-level containers.
    `class` | `JDesktopPane` | A container used to create a multiple-document interface or a virtual desktop.
    `class` | `JDialog` | The main class for creating a dialog window.
    `class` | `JEditorPane` | A text component to edit various kinds of content.
    `class` | `JFileChooser` | `JFileChooser` provides a simple mechanism for the user to choose a file.
    `class` | `JFormattedTextField` | `JFormattedTextField` extends `JTextField` adding support for formatting arbitrary values, as well as retrieving a particular object once the user has edited the text.
    `class` | `JFrame` | An extended version of `java.awt.Frame` that adds support for the JFC/Swing component architecture.
    `class` | `JInternalFrame` | A lightweight object that provides many of the features of a native frame, including dragging, closing, becoming an icon, resizing, title display, and support for a menu bar.
    `static class` | `JInternalFrame.JDesktopIcon` | This component represents an iconified version of a `JInternalFrame`.
    `class` | `JLabel` | A display area for a short text string or an image, or both.
    `class` | `JLayer<V extends Component>` | `JLayer` is a universal decorator for Swing components which enables you to implement various advanced painting effects as well as receive notifications of all `AWTEvent`s generated within its borders.
    `class` | `JLayeredPane` | `JLayeredPane` adds depth to a JFC/Swing container, allowing components to overlap each other when needed.
    `class` | `JList<E>` | A component that displays a list of objects and allows the user to select one or more items.
    `class` | `JMenu` | An implementation of a menu -- a popup window containing `JMenuItem`s that is displayed when the user selects an item on the `JMenuBar`.
    `class` | `JMenuBar` | An implementation of a menu bar.
    `class` | `JMenuItem` | An implementation of an item in a menu.
    `class` | `JOptionPane` | `JOptionPane` makes it easy to pop up a standard dialog box that prompts users for a value or informs them of something.
    `class` | `JPanel` | `JPanel` is a generic lightweight container.
    `class` | `JPasswordField` | `JPasswordField` is a lightweight component that allows the editing of a single line of text where the view indicates something was typed, but does not show the original characters.
    `class` | `JPopupMenu` | An implementation of a popup menu -- a small window that pops up and displays a series of choices.
    `static class` | `JPopupMenu.Separator` | A popup menu-specific separator.
    `class` | `JProgressBar` | A component that visually displays the progress of some task.
    `class` | `JRadioButton` | An implementation of a radio button -- an item that can be selected or deselected, and which displays its state to the user.
    `class` | `JRadioButtonMenuItem` | An implementation of a radio button menu item.
    `class` | `JRootPane` | A lightweight container used behind the scenes by `JFrame`, `JDialog`, `JWindow`, `JApplet`, and `JInternalFrame`.
    `class` | `JScrollBar` | An implementation of a scrollbar.
    `class` | `JScrollPane` | Provides a scrollable view of a lightweight component.
    `protected class` | `JScrollPane.ScrollBar` | By default `JScrollPane` creates scrollbars that are instances of this class.
    `class` | `JSeparator` | `JSeparator` provides a general purpose component for implementing divider lines - most commonly used as a divider between menu items that breaks them up into logical groupings.
    `class` | `JSlider` | A component that lets the user graphically select a value by sliding a knob within a bounded interval.
    `class` | `JSpinner` | A single line input field that lets the user select a number or an object value from an ordered sequence.
    `static class` | `JSpinner.DateEditor` | An editor for a `JSpinner` whose model is a `SpinnerDateModel`.
    `static class` | `JSpinner.DefaultEditor` | A simple base class for more specialized editors that displays a read-only view of the model's current value with a `JFormattedTextField`.
    `static class` | `JSpinner.ListEditor` | An editor for a `JSpinner` whose model is a `SpinnerListModel`.
    `static class` | `JSpinner.NumberEditor` | An editor for a `JSpinner` whose model is a `SpinnerNumberModel`.
    `class` | `JSplitPane` | `JSplitPane` is used to divide two (and only two) `Component`s.
    `class` | `JTabbedPane` | A component that lets the user switch between a group of components by clicking on a tab with a given title and/or icon.
    `class` | `JTable` | The `JTable` is used to display and edit regular two-dimensional tables of cells.
    `class` | `JTextArea` | A `JTextArea` is a multi-line area that displays plain text.
    `class` | `JTextField` | `JTextField` is a lightweight component that allows the editing of a single line of text.
    `class` | `JTextPane` | A text component that can be marked up with attributes that are represented graphically.
    `class` | `JToggleButton` | An implementation of a two-state button.
    `class` | `JToolBar` | `JToolBar` provides a component that is useful for displaying commonly used `Action`s or controls.
    `static class` | `JToolBar.Separator` | A toolbar-specific separator.
    `class` | `JToolTip` | Used to display a "Tip" for a Component.
    `class` | `JTree` | A control that displays a set of hierarchical data as an outline.
    `class` | `JViewport` | The "viewport" or "porthole" through which you see the underlying information.
    `class` | `JWindow` | A `JWindow` is a container that can be displayed anywhere on the user's desktop.

  - ### Uses of MenuContainer in javax.swing.colorchooser

    Classes in javax.swing.colorchooser that implement MenuContainer
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `AbstractColorChooserPanel` | This is the abstract superclass for color choosers.

  - ### Uses of MenuContainer in javax.swing.plaf.basic

    Classes in javax.swing.plaf.basic that implement MenuContainer
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `BasicArrowButton` | JButton object that draws a scaled Arrow in one of the cardinal directions.
    `class` | `BasicComboBoxRenderer` | ComboBox renderer
    `static class` | `BasicComboBoxRenderer.UIResource` | A subclass of BasicComboBoxRenderer that implements UIResource.
    `class` | `BasicComboPopup` | This is a basic implementation of the `ComboPopup` interface.
    `class` | `BasicInternalFrameTitlePane` | The class that manages a basic title bar
    `class` | `BasicInternalFrameTitlePane.SystemMenuBar` | This class should be treated as a "protected" inner class.
    `class` | `BasicSplitPaneDivider` | Divider used by BasicSplitPaneUI.
    `protected class` | `BasicToolBarUI.DragWindow` | The window which appears during dragging the `JToolBar`.

  - ### Uses of MenuContainer in javax.swing.plaf.metal

    Classes in javax.swing.plaf.metal that implement MenuContainer
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `MetalComboBoxButton` | JButton subclass to help out MetalComboBoxUI
    `class` | `MetalComboBoxUI.MetalComboPopup` | Deprecated. As of Java 2 platform v1.4.
    `protected class` | `MetalFileChooserUI.FileRenderer` | Deprecated. As of JDK version 9.
    `class` | `MetalFileChooserUI.FilterComboBoxRenderer` | Render different type sizes and styles.
    `class` | `MetalInternalFrameTitlePane` | Class that manages a JLF title bar
    `class` | `MetalScrollButton` | JButton object for Metal scrollbar arrows.

  - ### Uses of MenuContainer in javax.swing.table

    Classes in javax.swing.table that implement MenuContainer
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `DefaultTableCellRenderer` | The standard class for rendering (displaying) individual cells in a `JTable`.
    `static class` | `DefaultTableCellRenderer.UIResource` | A subclass of `DefaultTableCellRenderer` that implements `UIResource`.
    `class` | `JTableHeader` | This is the object which manages the header of the `JTable`.

  - ### Uses of MenuContainer in javax.swing.text

    Classes in javax.swing.text that implement MenuContainer
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `JTextComponent` | `JTextComponent` is the base class for swing text components.

  - ### Uses of MenuContainer in javax.swing.tree

    Classes in javax.swing.tree that implement MenuContainer
    Modifier and Type | Class | Description
    --- | --- | ---
    `class` | `DefaultTreeCellEditor.DefaultTextField` | `TextField` used when no editor is supplied.
    `class` | `DefaultTreeCellEditor.EditorContainer` | Container responsible for placing the `editingComponent`.
    `class` | `DefaultTreeCellRenderer` | Displays an entry in a tree.