Java Swing Graphics Basics
In this lesson we introduce graphics in Java.
Obviously GUIs are
graphics, so what are we doing now
that's different? Well, in the GUI programming we've done so
far, the GUI components (e.g. JButton, JLabel, JFrame, ...)
have drawn themselves. Now our code
will do the
drawing. However, the mechanism for drawing is actually the
same, whether it's done by API code or by our own code.
In Java's Swing library, all drawing is done by
callback methods. In otherwords, a
JComponent-extending class that
wants itself drawn overrides the JComponent method
protected void paintComponent(Graphics g);
and the Event Dispatch Thread will call that method whenever
it deems that the component needs to be drawn. When would
A system event, like a window being resized, uncovered,
etc. could cause the Event Dispatch Thread to call
Some code in your program might call your component's
repaint() method, which will cause the Event Dispatch
Thread to, at its earliest convenience, call your
componenet's paintComponent method.
Some code in your program might call repaint() on a
componenet that contains your componenet, which will cause the Event Dispatch
Thread to, at its earliest convenience, call that
container's paintComponenet method, which will in turn
call the paintComponent methods of the components it
Graphics g parameter to paintComponent is the
thing you use to do the actual drawing. It has methods for
drawing rectangles, ellipses, ... , text and images.
According to the above, all we have to do to draw on a
componenet is to override its paintComponent method. So
... let's do that!
In this example, the only thing that's new is that we've
overridden this "paintComponenet" method that we were
previously unaware of. Notice that we call
super.paintComponent(g) first. That paints the button in the
usual fashion, then we go and paint our stuff on top of it.
Graphic2D and the awfulness of backwards compatibility
Now I'm going to throw a wrench into the works. At some point
Java improved its graphics API, but it didn't want to get rid of
the earlier stuff (for backwards compatibility reasons), so
... they derived a new class Graphic2D from Graphics, and the
argument paintComponent gets sent is actually of that new type.
However, you have to cast g to Graphics2D explicitly.
For us, the nice feature of Graphics2D is that there are methods
void draw(Shape s);
void fill(Shape s);
that give you outlined or filled-in versions of any object
derived from class Shape. And, of course, the API has
Shape-derived objects for rectangles and ellipses and lines and more
exotic things as well.
Here's the exact same program as before, but done with
Some of the many different graphics operations
Of course you wouldn't normally draw over a JButton, as we did
in the previous examples. You can draw on any JComponent. If
you just want a blank space to draw on, you can just extend
the base JComponent class. In the example below, we define a
DrawArea in this way, and we show off some of the many things
you can do with Java graphics. (Note: we use the file
Animation and mouse events
This last example is given to you with no real explanation. You
should, in fact, be able to follow it. The gist is this:
animation is nothing more than having a thread that changes
something about your scene, and calls repaint() periodically to
draw the new version of the scene.