Java Swing (GUI) Programming: From Beginner to Expert
- 14 hours on-demand video
- 2 articles
- 4 downloadable resources
- Full lifetime access
- Access on mobile and TV
- Certificate of Completion
Get your team access to 4,000+ top Udemy courses anytime, anywhere.Try Udemy for Business
- Learn how to write GUI (graphical user interface) applications in Java
- Understand the Java Swing framework
- Discover how to create database 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.
- The "Hello World" application
- Using Eclipse
- The JFrame class
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.
- BorderLayout and introducing layout managers
- Customising JFrame with your own derived class
How to make stuff happen when you click buttons!
- ActionListener: adding listeners to buttons
- Anonymous classes as listeners
- Adding text to text areas
How to divide your application up into separate self-contained components by subclassing other classes -- in this case, the JPanel class.
- Custom Components
- Scroll bars with JScrollPane
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.
- Creating simple toolbars
- FlowLayout for laying out components horizontally
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.
- Creating listeners for custom components
- Beginning MVC
- Disadvantages of making your components tightly coupled
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.
- Custom event listeners
- Using interfaces to eliminate tight coupling
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.
- The GridBagLayout and GridBagConstraints classes
- Creating forms
- The Insets class
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.
- The EventObject class
- Getting the text from text fields
- Implementing your own event handlers
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 combo boxes
- The JComboBox class
- The DefaultComboBoxModel class
- Making combo boxes editable
- A few small tips and tricks with GridBagLayout
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.
- The JCheckBoxMenuItem class
- Adding ActionListeners to menu items
- Some notes on using anonymous classes
- Showing and hiding panels
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.
- What are mnemonics and accelerators?
- Adding mnemonics to menus, buttons and form fields
- Setting accelerators for menu items
- The KeyEvent and ActionEvent classes
- The JOptionPane class
- Confirm and Message option dialogs
- The setMinimumSize() method
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.
- Some MVC tips
- Working with data and packages in Java
- Creating a simple data model
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.
- Some tips on MVC architecture
- Creating a controller
Creating tables in Swing. The powerful JTable component can help you create simple spreadsheet-like applications with relatively little code.
- The JTable class
- Implementing table models and AbstractTableModel
- How to update your table when the model changes
- Adding column headers to your tables
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.
- Saving and Loading objects to and from files
- The Serializable interface
- ObjectOutputStream and ObjectInputStream
- Type erasure in Java
- Converting arrays to and from Lists
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.
- Selecting rows in tables
- Finding the row at a particular point
- Querying tables to find out which rows are selected
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.
- Deleting table rows
- Creating unmodifiable lists
- When to use LinkedLists rather than ArrayLists
- Another listener-event example
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.
- Creating dialogs with the JDialog class
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.
- Entering numbers in forms
- The JSpinner and SpinnerNumberModel classes
- Positioning dialogs relative to parent windows
- More using GridBagLayout for positioning form controls
- Making dialogs go away on clicking OK or Cancel
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.
- The Preferences class
- Another example of communicating between objects using the event-listener model
- Saving dialog form data using preferences
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.
- Using panels to arrange forms
- Line Borders
- Combining layouts
- Right-aligning FlowLayout
- Sizing buttons
- More GridBagLayout examples
- A note on spanning rows and columns in GridBagLayout (via gridwidth and gridheight)
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.
- JDBC basics
- Connecting to a database
- Using external APIs in Eclipse (by including jar files)
- Organising a class that connects to a database
In this tutorial we'll look at the simple case of retrieving a count from a SQL database.
- Getting a count of rows from a database
- The PreparedStatement and ResultSet classes
- Working with prepared statements
- Protecting against weird characters and SQL injection attacks
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.
- Instantiating objects using information from a database
- More on the ResultSet class
- Retrieving data via column names
- Calling one constructor from another in Java
- Loading enum types from strings
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.
- Disconnecting from databases
- Stopping the window exiting automatically when the close widget is clicked
- Intercepting the Window Closing event
- The WindowAdapter class
- Stop Swing throwing a weird stack trace on quitting by running the garbage collector manually
- A nicer way to quit your Swing application than using System.exit(0)
- Firing a Window Closing event manually
- Loading images from packages using the class loader
- URLs and the getResource() method
- The ImageIcon class
- Where to find a great free source of icons
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.
- The JToolbar class
- Making your toolbar draggable
- Adding tooltips to buttons
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
- The JSplitPane class
- Changing the size of split panes programmatically
- Adding "one touch expandable" buttons to your split pane.
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.
- The JTabbedPane class
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
- Creating trees
- The JTree and DefaultMutableTreeNode classes
- Building up tree branch-leaf hierarchies
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.
- Custom tree cell renderers
- The TreeCellRenderer interface
- Displaying tree leaf nodes using checkboxes
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.
- Using custom editors in JTrees
- The TreeCellEditor interface
- The AbstractCellEditor class
- Listening to tree cell editor events
- The TreeCellEditor class
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.
- An example of a Map of Lists: a TreeMap containing ArrayLists
- An example of using a Set (TreeSet)
- Make a container class iterable using the Iterable and Iterator interfaces
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.
- Multithreading in Swing: running tasks in the background
- The SwingWorker class
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.
- Creating modal dialogs
- The JDialog class modal constructor
- Using SwingUtilities invokeLater to schedule code to run on the event dispatch thread
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.
- Progress bars
- Setting the position of your dialogue relative to its parent window
- The JProgressBar class
- Another FlowLayout example
- Using the pack() method
- Indeterminate vs. determinate progress bars
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.
- Creating runnable jars
- Run configurations in Eclipse
In this tutorial we'll implement the cancel button on our progress dialog, making it cancel the SwingWorker background thread.
- Cancelling threads
- Another example of a listener
- Adding a cancel button to your progress dialog
- Intercepting dialog closing
Want to divide your application into multiple resizeable areas, just like Eclipse? Learn how to do it in this tutorial.
- Nesting multiple split panes
- More on the JSplitPane class
- Setting minimum dimensions on controls within split panes
- Setting resize weights on JSplitPanes
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.
- Using ChangeListener to listen to tab selection events
- Finding out which tab is active
- 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.
- Custom list renderers
- The ListCellRenderer interface
- Setting background colors on panels and labels
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.
- Detecting selections in JLists
- The ListSelectionListener interface
- Setting the text in a text area
- Programmatically selecting an item in a list
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.
- Setting the font
- Using logical fonts
- Sans-serif, serif and monospaced font types
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.
- Displaying checkboxes in tables
- Working with data types in a table model
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.
- Creating custom renderers for table cells
- Rendering a table column with a combo box
- Getting all possible values of an enumeration
- Setting the height of table rows
- Giving an enumeration user-friendly text values
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.
- Creating custom editors for table cells
- Setting combo boxes as the editors in a table column
- The TableCellEditor interface
- Using AbstractCellEditor as the basis of your table cell editor
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.
- Creating applets: browser-based Java programs
- The JApplet class
- Understanding the applet lifecycle
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".
- Creating owner-drawn custom components
- How Swing paints components
- Selecting a suitable parent class for your component
- Drawing filled rectangles
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.
- The Swing Timer class
- The start and stop applet methods
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.
- Basic animation
- Triggering component repaints to redraw the screen
- How to make a "ball" bounce around your window
- Getting the width and height of your component
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.
- Hiding the cursor
- Setting the cursor to an image
- Creating custom cursors using the Toolkit
- The KeyListener interface
- The KeyboardFocusManager class
- Component key listeners vs. global key listeners
- Handling arrow keys
- Making components focusable
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.
- Listening for component resizing
- The ComponentListener interface
- The ComponentAdapter class
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.
- Visually designing Swing programs
- Installing Window Builder Pro
- The advantages and disadvantages of Netbeans
- Pros and cons of visual designers
- Creating a simple panel with Window Builder Pro
- Some advantages of SWT over Swing
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.
- Switching between different panels in your application
- The CardLayout class
- The content pane: what is it?
- A note on setting the background color of JFrame
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.
- Detecting when one shape intersects another
- Detecting when a mouse is clicked on a particular shape
- How to find when a point lies within a particular shape
- Some final words about the course
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.
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.
- Java beginners who are OK with learning new stuff rapidly
- Fluent Java programmers who want to learn desktop programming in Java