Lab 4: Interfaces and Swing

Your goal this week is to expand on your understanding of the Swing API as well as to hammer home the fundamental tools for working with Java objects.

Here's a small screenshot of what your new program might look like:

More explicitly, you must provide:

A 10 x 10 grid of buttons that are initialized in state "A". You may indicate state "A" by a text label (e.g. "wow" in the picture) but we recommend using a small, colorful image, such as a red ball or a green square.
Any button in the above grid, when clicked, should respond by flipping from its current state to the "other" state, state "B". Likewise, please indicate state B via a different image or label.
At the bottom or side of your window, provide a special button called "step" that, when clicked, inverts the state of all 100 buttons.
Add a listener such that when the user clicks on the close window button, the window closes and the Java VM exits back to the shell.

Sounds easy enough, right?

Java language issues

To read more about creating arrays in Java, check out this page. Be sure to note that when you create an array of references-to-objects, that's all you get: an array of references to objects, none of which actually refer to real objects yet! You must construct each individual one with a new statement.
You'll need to understand what it means when a class implements an interface.
You'll need to understand inner classes, particularly anonymous inner classes.
You'll need to understand how to register an ActionListener with a component to be able to listen for mouse clicks.

Design advice

Object-oriented languages provide many ways to design programs that achieve the same goals. Some of these designs are good and some aren't. In this and future labs we'll be supplying some advice on design. These are not hard-and-fast rules, just suggestions, but if followed you will have an easier time with the assignments (and hopefully start to develop your design sense as well).

Call the class that includes the main method Lab4.
Try to put as little functionality as you can in the main method for the Lab4 class. Instead, create an instance of Lab4 inside the main method and put the functionality inside non-static methods of Lab4. This is good practice, because it means that you can create multiple instances of Lab4; this isn't really important here but in general it's very important, so it's a good habit to get into. In addition, don't use static data unless there is a good reason to.
Don't have Lab4 inherit from any other class (e.g. GUI (Graphical User Interface) classes); instead, make the GUI classes you need fields of Lab4 and initialize them in your constructor. This is called "composition"; we say the Lab4 class "has-a" GUI object. Inheritance implies that the Lab4 class "is-a" GUI object, which is the wrong way to think about it.
Consider using a default BorderLayout as your JFrame's content pane's layout manager. You can add a borderless, invisible JPanel container object to the NORTH of the content pane and your special "step" button to the SOUTH. You can then set a different, more applicable layout manager on your inner JPanel and add your grid of 100 buttons to it. What layout manager, you ask? Hint: you are Laying Out a Grid...
Add a WindowListener to the main frame which calls the exit function when the close button of the window is clicked. There are other ways to make the close button work but this is good practice in using Listener classes. Use an anonymous inner class to create the WindowListener. NOTE: It's OK (in fact it's advisable) to use a WindowAdapter instead of a WindowListener. A WindowAdapter is an implementation of WindowListener with empty methods for each method. If you make an anonymous inner class from WindowAdapter and add the methods you want to implement, you don't have to supply the other methods.
Create a subclass of JButton that has two states, each of which has its own corresponding icon. Each instance should have its own ActionListener that invokes a method that toggles the state from one state to the other. In your Lab4 class create a two-dimensional array of your button objects.
Don't reference local variables of a method inside anonymous inner classes (which you should be using to implement Listeners). Java forces you to declare such variables final, which is unnecessarily restrictive anyway. For this assignment, you can do everything you need to do inside anonymous inner classes by calling methods.

Extra credit:

Add a title to your window.
Replace the Java icon in the top left with a cool one. This may be impossible, depending on what window manager you're using.
Accept one integer, n, as a command line parameter. Create an n by n grid instead of a fixed, 10 by 10 one.
Each time the "step" button is clicked, treat the grid as a bitmap of states and determine a closest-character-match to an uppercase letter in the English alphabet.