anonymous class turned into inner class

The button is not anonymous, but the action listener is. Specifically:

btnClear.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent arg0) {
        model.resetComponents();
        model.repaint();
    }
});

Here you are invoking the method, addActionListener, and passing as the argument, an implementation of ActionListener. The key here is that this implementation is an anonymous class that implements the interface inline.

Remember, ActionListener is an interface, and interfaces cannot contain actual implementation. Instead, what is happening, is a new class is being declared (without a name) that implements ActionListener. That interface defines one method, actionPerformed, which is the actual handler for the button -- it calls resetComponents and repaint. It is possible to turn this into a new normal class that actually has a name, continues to implement ActionListener, by implementing actionPerformed.

Indeed, there's no anonymous class there. One can imagine transformations running the other way, e.g. new Resettable()....

Well ButtonPanel is non-standard as far as I see so every answer will be hard without further information, but I can give some default answers ;-)

"does my button code even have an anonymous class in it?" No it doesn't. A anonymous class is often created if you want to a instance of a class that implements a specific interface.

A non GUI example would be Comparator. You want to compare an array after a specific criteria - you could create a extra class for this, but you'll use it only once anyhow and there's no real reuseability to speak of. So we'll just create an anonymous class that implements the Comparator interface:

    Comparator<Integer> c = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1 - o2;
        }
    };

Nothing special about that - note that your anonymous class can access outside variables, but they're copied when creating the object. To avoid confusion this means that local variables have to be final.

--- edited as question was updated ---

btnClear.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                model.resetComponents();
                model.repaint();
            }
        });

contains an anonymous class extended off of ActionListener

You need that code to read something like

btnClear.addActionListener(new MyInnerClass());

If you do that with everything working 100% the same, I'd say you did it!

--- original post follows --- The question is worded in such a way that I might understand it; but, I'm not sure.

One hint is that it asked for an inner class. That means that the solution expects you to write an inner class:

public class ControlsPanel extends Panel implements Resettable {

    // must have an inner class
    class SomeButtonModel (or SomeButtonPanel) {
       // code for inner class.
    }

}

Note that if you find an abstract class (or interface) which is instantiated in your code by specifying the missing functions in an initializer block, you've probably found the "anonymous" class. That means your inner class should extend that particular class, and you should rework the problem to use your inner class instead of the anonymous construction.

As usual, the main problem is initially understanding the question asked, once that is done, the rest is just work.

An example of using an anonymous class would be implementing the ActionListener interface "on the fly" so-to-speak without defining a separate class (i.e. a class with a name and therefore not anonymous). For example:

JButton jb = new JButton("click me");
jb.addActionListener(new ActionListener() {
     public void actionPerformed(ActionEvent e) {
          // do stuff
     }
});

The "new ActionListener()" class is anonymous cuz it doesn't have a name.

To create an ActionListener as an inner class inside an outer class (called OuterClass), you would say something like:

public class OuterClass {
    public OuterClass() {
        JButton jb = new JButton("click me");
        jb.addActionListener(new MyActionListener());
    }

    private class MyActionListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
          // do stuff
        }
    } // end inner class

} // end outer class

Now instead of an anonymous class you have a named inner class, namely "MyActionListener."

Hope that helps

-Ed