CardLayout is a special layout manager for creating the effect of a "stack" of components. Instead of arranging all of the container's components, it displays only one at a time. You might use this kind of layout to implement a custom-tabbed panel of some kind. In fact, there's probably little reason to use this layout given the Swing JTabbedPane component, described in . We include it here mainly for completeness. To add a component to a CardLayout, use a two-argument version of the container's add( ) method; the extra argument is an arbitrary string that serves as the card's name:

 add("netconfigscreen", myComponent);

To bring a particular card to the top of the stack, call the CardLayout's show( ) method with two arguments: the parent Container and the name of the card you want to show. There are also methodsfirst( ), last( ), next( ), and previous( ) for working with the stack of cards. These are all CardLayout instance methods. To invoke them, you need a reference to the CardLayout object itself, not to the container it manages. Each method takes a single argument: the parent Container. Here's an example:

 import java.awt.*;
 import java.awt.event.*;
 import javax.swing.*;
 public class Card extends JPanel {
 CardLayout cards = new CardLayout( );
 public Card( ) {
 ActionListener listener = new ActionListener( ) {
 public void actionPerformed(ActionEvent e) {;
 JButton button;
 button = new JButton("one");
 add(button, "one");
 button = new JButton("two");
 add(button, "two");
 button = new JButton("three");
 add(button, "three");
 public static void main(String[] args) {
 JFrame frame = new JFrame("Card");
 frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
 frame.setSize(200, 200);
 frame.setLocation(200, 200);
 frame.setContentPane(new Card( ));

We add three buttons to the layout and cycle through them as they are pressed. An anonymous inner class serves as an action listener for each button; it simply calls CardLayout's next( ) method whenever a button is pressed. Card.this refers to the Card object, which is the container in this case. In a more realistic example, we would build a group of panels, each of which might implement some part of a complex user interface and add those panels to the layout. Each panel would have its own layout manager. The panels would be resized to fill the entire area available (i.e., the area of the Container they are in), and their individual layout managers would arrange their internal components.