GUI design in Java Swing
Variable names. Imagine yourself a couple of months from now on, when you look back at the code. Will you remember without looking at the variable declaration what gnb is short for? I suggest you use longer variable names so that you even won't have to try to remember it. getNameBtn would be a better name, and it's still not too long. Using closeBtn instead of cb is also better. cb could just as well mean clearbright or something else totally irrelevant.
You seem to use setBounds to set the exact layout positions in pixels for your components. This is not recommended as this will not be flexible for resizing the windows. Instead use a proper LayoutManager such as BorderLayout and add some margins to make your buttons be placed approximately where they belong and still be flexible for if someone wants to resize the window. (Trust me, this can be more important than you think).
You seem to extend a lot of JButtons and other things. Technically, what's different between a CloseButton and a GetNameButton? The only differences are their positions, labels and I suppose there will be a difference in what happens when you click them. All these things are properties, it does not warrant extension of the original class. Instead you can use a public static method that creates a JButton with the initialized properties of a "close-button" or a "get-name-button". (The same goes for NameLabel, it does not need to extend JLabel)

Here's code for such a public static method:

public static JButton createGetNameButton() {
    JButton btn = new JButton();
    btn.setText("Show Name");
    btn.setBounds(20,100,120,20);
    return btn;
}

jliv902 has a good point in his comment of putting common features into a base class for your panels. However, think about whether or not you really should extend them or not. Personally I think that extending a JPanel or a JFrame is more OK than extending a button, but I want you to know that there are even reasons for why a JFrame shouldn't be extended. Instead of extending, consider this:

public class MyJPanelContainer implements ActionListener {
    private final JPanel panel;
    public MyJPanelContainer() {
        this.panel = new JPanel();
        // code to setup the panel the way you want it
        someComponent.addActionListener(this);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        // ...
    }
    public JPanel getPanel() { 
        // Technically, in another approach, you might not even need this getter, but that's a whole other story.
        return this.panel;
    }
}


If you would write a class like that, it will encapsulate the JPanel and thus hide several methods. The easiest effect to describe for using this approach is that it will drastically decrease the number of visible elements when you press Ctrl + Space, which will make it easier to see the method you are looking for.