## 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 and Description
    --- | ---
    `class` | `Applet` An applet is a small program that is intended not to be run on its own, but rather to be embedded inside another application.

  - ### Uses of MenuContainer in java.awt

    Classes in java.awt that implement MenuContainer
    Modifier and Type | Class and 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 and Description
    --- | ---
    `MenuContainer` | MenuComponent.`getParent()` Returns the parent container for this menu component.
    `MenuContainer` | PopupMenu.`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 and 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` An extended version of `java.applet.Applet` that adds support for the JFC/Swing component architecture.
    `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 and 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 and 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`

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

    Classes in javax.swing.plaf.metal that implement MenuContainer
    Modifier and Type | Class and Description
    --- | ---
    `class` | `MetalComboBoxButton` JButton subclass to help out MetalComboBoxUI
    `class` | `MetalComboBoxUI.MetalComboPopup` Deprecated. As of Java 2 platform v1.4.
    `protected class` | `MetalFileChooserUI.FileRenderer`
    `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 and 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 and 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 and 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.

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, 2017, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.