This course teaches you how to create desktop and web-based applications using Java Swing, Java's built-in user interface toolkit. Each tutorial is fairly self-contained; but we'll also build two complete applications step by step along the way, so you can choose either to work through the whole course or to dip in and out.
Among other things we'll look at nearly all Swing widgets, we'll take a look at JDBC for database access, the graphics API, model-view-controller (MVC) architecture, serialization for saving data, the listener-event model and even basic animation.
When you finish the course, you'll be an advanced Swing developer, capable of creating complex and scalable Swing GUI applications.
This is an overview both of the course and of user interface programming in Java. I'll also show you some useful resources that will help you write great programs, including where to find free software to create your program with (both by hand and visually) and where to find useful documentation.
How to create a minimal "Hello World" Swing application in Java. In this tutorial we'll create an application that just pops up a window with a title.
How to add components to your main window. One of the hardest things about Swing programming is dealing with layout managers. This tutorial begins a gentle introduction to using layout managers to layout your components in a resize-friendly way.
How to make stuff happen when you click buttons!
How to divide your application up into separate self-contained components by subclassing other classes -- in this case, the JPanel class.
How to create a simple panel-based toolbar. In this tutorial we build on our knowledge of creating custom components to add a toolbar with two buttons.
How to cause something to happen in one component in response to something that happens in another component. In this tutorial we look at setting a listener on your custom component and we begin to look at MVC (Model-View-Controller) architecture.
How to improve a basic custom "listener" by using interfaces to eliminate tight coupling between your components. In this tutorial I'll show you how to make your inter-component communication clean and scalable using some standard Java techniques.
How to change the sizes of your components.
Setting your components' borders.
Using the JTextField and JLabel classes to add text fields (one line text entry controls) and labels to your application.
How to tame the ferocious GridBagLayout to flexibly add your controls to panels and windows in such a way that they will still look great even if you resize your forms. Unveiling the mysteries of anchors, weights, insets and fills; in this tutorial you'll learn very powerful techniques used by many professional developers to design in-house and commercial Swing applications.
Using your own EventObject derived class to transmit information from one component to another. This tutorial also covers basic form handling; getting text from text fields in response to button clicks.
List boxes allow you to select items from a list. Also in this tutorial, a bit more about MVC architecture.
How to unhook the text visible in list boxes from the underlying data, so that you can safely change the text in text boxes without messing up your functionality. This technique also makes it easier to interface with databases.
How to use the handy JComboBox widget. Combo boxes are drop-down list boxes that can also optionally allow you to edit them directly, hence the name combo box -- they are sort of like a combination of a list box and a text field.
How to use the JCheckBox class to add checkboxes to your forms.
How to use radio buttons, those little round controls that allow you to choose between small numbers of exclusive options.
How to create menus for your applications. Almost every true GUI needs a menu, or else the user will feel lost. Menus are fairly easy to implement too.
How to create menu items that you can check and uncheck, like a checkbox. In this tutorial we'll also add a bit of code that shows and hides a form panel.
You can use mnemonics and accelerators to make your menus and other items more keyboard accessible, both for expert users who happen to like shortcuts and for people who don't like to, or can't, use the mouse.
How to create dialogs that let you browse to a file location, so that you can open or save a file. File Choosers give you a lot of functionality for free and, in their most basic form, are very easy to use.
How to add filters to your file chooser dialogs, so that the user can choose from particular types of files, for example (but not necessarily) having particular extensions.
In this tutorial we'll take a brief detour from Swing to look at structuring your application by create a data model package, separate from your GUI (Graphical User Interface) code.
The controller bit of MVC architecture is the bit that contains all the stuff that's left after you've finished creating that data bit (the model) and the view bit (the user interface). There isn't a whole lot of "business logic" in our sample application, but in this tutorial we'll create a placeholder controller anyway.
Creating tables in Swing. The powerful JTable component can help you create simple spreadsheet-like applications with relatively little code.
Serialization is an easy way to implement saving and loading in your Swing application. Whether you're writing a business-oriented desktop application or a game, serialization makes saving and loading as easy as pie. For that reason I decided to cover it in this tutorial series, even though it's not part of Swing.
Learn how to create those little menus that appear when you right-click on things.
If you're using a JTable, you might want to be able to select table rows, for instance so that you can delete rows from a popup menu in response to a right mouse click. In this tutorial we look at selecting table rows.
How to delete rows from tables. There's just one little gotcha here, which is that deleting a row from a model doesn't automatically refresh the table. We'll look at how to fix that here. Also in this tutorial, how to protect a list from modification and when to use LinkedList.
Find out how to create dialog boxes. While message boxes are enough for many simple situations, if you want to put your own controls in a dialog box, you need the JDialog class. Dialog boxes are often used to allow the user to customise program settings, but you can use them for all kinds of things.
The JSpinner class allows you to create a little control for entering numbers, complete with up/down buttons for incrementing and decrementing the value. Also in this tutorial, a tip for positioning dialogs and more GridBagLayout examples.
How to create one of those password fields that allow you to enter passwords, but don't show the characters while you're typing them --- just dots or asterisks or something instead.
Preferences allow you to save small amounts of data between runs of your application; for example, form settings, window state, registration details and so on. Preferences are extremely easy to use and take all the work out of saving state and settings.
This tutorial discusses some techniques for using layouts and panels to make your forms and dialogs look nicer. Even if you're using a visual designer, you might find the techniques here useful to know.
This is a tutorial on connecting to a database in Java; I'll use MySQL in this tutorial, but the same ideas work with Oracle, Sqlite and others. JDBC isn't part of Swing, but so many people who write Swing programs want to connect to a database that I thought I'd cover it briefly in this tutorial series. NB: You'll need to install a database on your own machine, or somewhere accessible to you, if you want to run the code covered in this part of the tutorial. Of course you'll need to change the settings as appropriate for your database too.
In this tutorial we'll look at the simple case of retrieving a count from a SQL database.
A tutorial on saving a Java object's fields to a database.
This tutorial adds to our JDBC code by drawing on what we've already seen to update database rows.
This tutorial completes our database code by creating code that loads multiple rows from a database and uses the data to instantiate the corresponding data objects.
This tutorial brings together our database code with our GUI code, implementing save and refresh buttons on the toolbar.
Want to disconnect from a database when your application closes? Or maybe you want to clean up resources, or ask the user if he or she really wants to quit? You need to intercept the window closing event.
So far we've been working with a rough-and-ready panel-based toolbar, but in this tutorial we'll look at the JToolbar class, which allows you to create draggable toolbars with nice-looking graphical toolbar buttons. We'll also look at tooltips.
Many applications have main windows that contain separate resizeable areas with draggable borders. In this tutorial we look at how to create such areas, using JSplitPane
If you want to be able to switch between different views using tabs, or you want to let the user open multiple sub-windows, tabbed panes are a good option. In this tutorial I show you how to use a tabbed pane to create two separate "views" in your application.
Trees let you view hierarchical entities, for instance the folders on your hard drive. The JTree class is one of the most complex Swing components, but sometimes only a tree will really do the trick. In this tutorial we look at
Learn how to detect when someone clicks one of the nodes in your JTree.
In the last tutorial we saw how to retrieve the text from tree nodes. In this tutorial we look at how to separate the text the user sees from the data that you bring back when the node is selected.
The JTree class allows you to use custom icons for your tree nodes. In this tutorial, we'll see how to do just that.
In this tutorial we'll look at using a custom tree cell renderer, which displays tree leaves as checkboxes. You can use the same techniques to render your tree nodes in whatever way you like.
Want to use checkboxes or other editors to edit values in tree leaf nodes? This is the tutorial for you. We'll explore techniques that will allow you to use any kind of custom editor in a JTree, using checkboxes as a particular example. Using custom editors in trees is one of the more complex things you can do in Swing, but we'll break it down into methodical steps, and hopefully you'll have no problem developing your own tree node editors.
We're not going to look at anything Swing-specific in this tutorial; but to support more Swing stuff in future tutorials, we're going to take a bit of a detour to implement a fake message server using standard Java.
Although you can use standard multithreading techniques in Swing (see http://www.caveofprogramming.com for free tutorials on multithreading), there is also a specialised SwingWorker class for doing multithreading in Swing that removes some of the drawbacks with using the standard variety in a GUI program. In particular, the SwingWorker done() and process() methods allow you to update the GUI directly, something which can't be done from a conventional thread. I'll show you how to use SwingWorker in this tutorial.
Dialogs in GUI systems can be modal (prevent you from doing anything else until they are closed) or non-modal. We've already seen some simple modal dialogs in the form of message boxes with JOptionPane, but in this tutorial we'll look at creating your own, arbitrarily complex modal dialogs.
Progress bars are an important tool for giving feedback to your user. Most users would prefer that a task takes a longer time but indicates its progress, than a shorter time with no feedback. They are also pretty simple to use, the main complication being the business of getting feedback from your background task --- which we covered in the tutorial on multithreading.
If you want to distribute your application, you probably want to create a runnable jar file. Then you can send the file to your users, who can deploy it by (with a bit of luck) clicking on it. It's also possible to use a tool such as JSmooth to wrap the jar in a .exe for Windows, which will automatically download the JRE if necessary. In this tutorial we cover generating a runnable jar from within Eclipse.
This is just a quick tutorial on adding text to progress bars (such as "loading 85% ...."), which is a nice extra touch.
In this tutorial we'll implement the cancel button on our progress dialog, making it cancel the SwingWorker background thread.
Setting the cursor to a wait cursor is another great way of giving progress feedback to the user. We'll see how to set the cursor to any one of a number of predefined cursors in this tutorial.
Want to divide your application into multiple resizeable areas, just like Eclipse? Learn how to do it in this tutorial.
Sometimes you want your application to do something when the user clicks a tab in a JTabbedPane. This tutorial covers adding change listeners to tab controls to detect when the active tab is changed. We'll also look at another JList example.
You can render the items in a JList control in whatever way you want. Here we look at an example of a custom list renderer. Ours will be pretty simple, but you can put panels or JComponents of an arbitrary degree of fanciness in your lists if you want to. Note: if you want your list to have editable entries, you'll probably want to use a JTable with one column instead.
Sometimes you want to know immediately when a user selects an item in a JList, rather than just getting the selection in response to a submit button being clicked. Getting the list selection right away is as simple as adding a kind of listener to your JList.
Swing components that display text have a setFont() method which you can use to change the font. We'll look at how to change the font in this tutorial using "logical fonts"; fonts where you specify the general type of font you want, and Swing chooses the actual particular font for you.
Sometimes you want to load your own file; perhaps one you've found on the Internet somewhere. In this tutorial we'll look at how to load and set your own custom fonts.
This is just a quick video explaining how we can retrieve the values from the database preferences dialog and use them to configure the database connection.
If you've implemented your own table model, you'll need to do just a little work to make your JTable editable. This tutorial shows you how.
If your JTable stores a boolean value, getting it to use a checkbox to display the value is very simple; all we need to do is inform the table via the table model what class of object its working with.
If you want to use a combo box or some other component in a table cell, you need a custom table cell renderer. We look at how to do it in this tutorial, using a combo box to render an enum type as an example.
Note: slight correction to this tutorial -- if you want to set a renderer for a table column (rather than a data class), you need to get the column via the column model: table.getColumnModel().getColumn(index).setCellRenderer(cellRenderer)
Previously we've seen how to draw table cells using a custom renderer, but if you want to be able to actually change the values in your table cells using a custom control, you need to set a custom editor on your table column or data class. We'll see how to do that in this tutorial, using combo boxes in table cells as an example.
Yes, it's true, you can create Java programs that run in web pages, just like a Flash application. In this tutorial we'll look at creating a Swing-based applet. You can use pretty much all the stuff we've seen so far in your Swing applets; desktop Swing vs. applet Swing is largely identical.
Sometimes you want to create your own custom components that actually draw themselves, rather than just, say, acting as containers for other components. You can draw your own components from scratch using the Java graphics API, creating anything from tiny custom buttons to entire game screens. In this tutorial we'll start to put together a component that allows you to play a simple game, but the principles we'll see here apply just as well to creating any kind of owner-drawn custom component.
Although we cover drawing stuff from scratch using shapes in these tutorials, you can also use the same techniques to draw loaded images with the graphics API (rather than shapes), allowing you to set an image as a background for a component. And of course you can also draw lines using the line "shape".
In this tutorial we'll learn how to draw some shapes using the Swing graphics API. We'll also look at how to smooth your drawing.
In this tutorial we'll look at the simplest way to deploy an applet, by writing a little bit of HTML that embeds your Java program, downloading it from a URL or from your local file system.
If you want to have a recurring task of short duration in your Swing program, you need to use a timer. Timers can be used in many situations where otherwise you'd have to resort to complex multithreading. The only catch is that Swing timers run code in the main Swing thread, so they're not suitable for long-running tasks --- unless you use them in conjunction with threads. In this tutorial I'm going to use a timer to refresh the screen at regular intervals, implementing a simple form of animation.
If you want to write games or simulations or any kind of animated program in Swing, this is the tutorial for you. We'll build on the timer code and basic graphics code that we've seen in the last few tutorials to create a simple animation, which we'll refine in subsequent tutorials.
Double buffering is a common animation technique that helps to make your animations smoother. Here we'll look at how to do it in Swing.
Learn how to detect mouse clicks and mouse motion. In this tutorial we'll get the position of the mouse so that we can move a "bat" around the screen. That's bat as in cricket, not bat as in vampire.
In this tutorial we'll look at how to make the cursor invisible, which you might want to do if you're writing a game for example. The technique we'll look at here will also suffice if you want to set the cursor to an image, since we'll hide the cursor by just setting it to a transparent blank image.
Sometimes you want to take action when the user resizes one of your components. In the case of our little animation, we want to resize the back buffer when the animation component is resized. We'll look at how to do it in this tutorial.
In this tutorial we'll look at a visual design plugin that can sometimes save you time and make it easier to design the visual aspect of your Swing applications. I'll briefly discuss Netbeans and we'll move on to the excellent free Window Builder Pro plugin for Eclipse, which lets you switch between your code and the design view.
If you want to skip from one "screen" in your application to another, or for example you want a "wizard" dialog in which part of the dialog switches between different forms, you need the excellent CardLayout class.
In this tutorial we'll complete our animated applet by making the bat hit the ball. To do that, we'll look at how you can find out if one shape intersects another; we'll also touch on how you figure out if a particular shape has been clicked.
This zip file contains the most important bits of source code for the applications we've created in these tutorials. In particular, you'll find here the applet source code, the finished desktop application source code, and the source code for an early version of the desktop application, back when it still consisted of little more than a text pane and a primitive toolbar.
If there's anything I've missed out, feel free to get in touch.
After working as a software developer and contractor for over 14 years for a whole bunch of companies including CSC, Proquest, SPSS and AT&T in the UK and Netherlands, I decided to work full-time as a private software trainer. I now live in the beautiful city of Budapest, Hungary, from where I run the website Cave of Programming.