Of course! CardLayout is a powerful and useful layout manager in Java Swing. It allows you to treat several components as a stack of cards, where only one component is visible at a time.

This is perfect for creating wizards, tabbed interfaces without using JTabbedPane, or any UI where you want to switch between different views or panels.

Here's a comprehensive guide to CardLayout, covering its concepts, how to use it, and a complete, runnable example.

Core Concepts

Think of a CardLayout like a deck of playing cards or a Rolodex. You have a series of "cards" (components, usually JPanels), and you can only see the one on top.

Key Characteristics:

• Stack-based: Components are added in a specific order. The first component you add is the "bottom" card, and the last one is the "top" card.
• Single Visibility: Only one component (the "first" or "current" card) is visible at any given time.
• Navigation: You can programmatically show the first, last, next, previous, or a specific card by its name.
• Container: The CardLayout is usually applied to a JPanel that acts as the container for all the other "card" panels.

How to Use CardLayout

Using CardLayout involves three main steps:

Step 1: Create the Container and the Layout Manager

First, create a JPanel to hold your cards and create a CardLayout object.

// 1. Create the container panel
JPanel cardPanel = new JPanel();
// 2. Create the CardLayout manager
CardLayout cardLayout = new CardLayout();
// 3. Set the layout manager for the container
cardPanel.setLayout(cardLayout);

Step 2: Create and Add the "Cards"

Each "card" is typically a JPanel that can contain any other Swing components (buttons, labels, text fields, etc.). Add each of these card panels to the main container using the add() method.

Crucially, you must provide a String name for each card when you add it. This name is the key you'll use later to show a specific card.

// Create the individual card panels
JPanel card1 = new JPanel();
card1.add(new JLabel("This is the First Card"));
card1.setBackground(Color.CYAN);
JPanel card2 = new JPanel();
card2.add(new JLabel("This is the Second Card"));
card2.setBackground(Color.MAGENTA);
JPanel card3 = new JPanel();
card3.add(new JLabel("This is the Third Card"));
card3.setBackground(Color.YELLOW);
// Add the cards to the container with a unique name for each
cardPanel.add(card1, "FIRST_CARD");  // "FIRST_CARD" is the name/key
cardPanel.add(card2, "SECOND_CARD"); // "SECOND_CARD" is the name/key
cardPanel.add(card3, "THIRD_CARD");  // "THIRD_CARD" is the name/key

Step 3: Navigate Between the Cards

To show a different card, you call the appropriate method on the CardLayout object. You must also call revalidate() and repaint() on the container panel after changing the card to ensure the UI updates correctly.

// To show the card with the name "SECOND_CARD"
cardLayout.show(cardPanel, "SECOND_CARD");
// You can also use these methods:
cardLayout.first(cardPanel);    // Shows the first card added
cardLayout.last(cardPanel);     // Shows the last card added
cardLayout.next(cardPanel);     // Shows the next card in the stack
cardLayout.previous(cardPanel); // Shows the previous card in the stack

Complete Runnable Example

This example creates a window with a CardLayout. At the top, there's a JButton for each card. Clicking a button will display the corresponding card below.

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class CardLayoutDemo {
    public static void main(String[] args) {
        // Create the main window
        JFrame frame = new JFrame("CardLayout Demo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);
        frame.setLocationRelativeTo(null); // Center the window
        // 1. Create the container panel and the CardLayout
        JPanel cardPanel = new JPanel();
        CardLayout cardLayout = new CardLayout();
        cardPanel.setLayout(cardLayout);
        // 2. Create the individual "cards"
        JPanel card1 = new JPanel();
        card1.add(new JLabel("Card 1: Welcome Screen"));
        card1.setBackground(Color.PINK);
        JPanel card2 = new JPanel();
        card2.add(new JLabel("Card 2: User Profile"));
        card2.setBackground(Color.LIGHT_GRAY);
        JPanel card3 = new JPanel();
        card3.add(new JLabel("Card 3: Settings"));
        card3.setBackground(Color.GREEN);
        // Add the cards to the container with a unique name
        cardPanel.add(card1, "WELCOME");
        cardPanel.add(card2, "PROFILE");
        cardPanel.add(card3, "SETTINGS");
        // 3. Create a button panel to navigate between cards
        JPanel buttonPanel = new JPanel();
        JButton button1 = new JButton("Show Welcome");
        JButton button2 = new JButton("Show Profile");
        JButton button3 = new JButton("Show Settings");
        // Add ActionListener to each button
        button1.addActionListener(e -> cardLayout.show(cardPanel, "WELCOME"));
        button2.addActionListener(e -> cardLayout.show(cardPanel, "PROFILE"));
        button3.addActionListener(e -> cardLayout.show(cardPanel, "SETTINGS"));
        buttonPanel.add(button1);
        buttonPanel.add(button2);
        buttonPanel.add(button3);
        // Add the panels to the main frame's content pane
        frame.getContentPane().add(buttonPanel, BorderLayout.NORTH);
        frame.getContentPane().add(cardPanel, BorderLayout.CENTER);
        // Make the window visible
        frame.setVisible(true);
    }
}

How to Run:

1. Save the code as CardLayoutDemo.java.
2. Compile it: javac CardLayoutDemo.java
3. Run it: java CardLayoutDemo

You will see a window with three buttons at the top. Clicking them will switch the visible panel below.

Important CardLayout Methods

Here are the most important methods you'll use:

When to Use CardLayout

CardLayout is ideal for:

• Wizards: A classic multi-step installation or configuration process.
• Tabbed Interfaces: While JTabbedPane is more common, CardLayout gives you more control over the appearance and behavior of the "tabs."
• Settings/Options Panels: Showing different categories of settings (e.g., General, Advanced, Network).
• Game Screens: Switching between a main menu, the game screen, a pause screen, and a game-over screen.

Comparison with JTabbedPane

For most standard tabbed interfaces, JTabbedPane is the easier and more idiomatic choice. Use CardLayout when you need more flexibility and control over the UI.