Java Swing (GUI) Programming: From Beginner to Expert | Discount Coupon for Udemy Course
Learn how to create desktop and Internet GUI Java programs and take your Java programming to the next level. | Discount Coupon for Udemy Course
bestseller- 14 hours hours of on-demand video
- 2 article
- Full lifetime access
- Access on mobile and TV
- Certificate of completion
- 3 additional resources
- Learn how to write GUI (graphical user interface) applications in Java
- Understand the Java Swing framework
- Discover how to create database applications
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. Who this course is for:Java beginners who are OK with learning new stuff rapidlyFluent Java programmers who want to learn desktop programming in Java
Course Content:
Sections are minimized for better readability, click the section title to view the course content
- Introduction: About the Course, Plus Some Useful Resources06:41
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.
- Creating a Basic Swing Application07:04
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
- Adding Components: Layouts, Buttons and Text Areas08:10
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
- JButton
- JTextArea
- Customising JFrame with your own derived class
- Responding to Button Clicks04:17
How to make stuff happen when you click buttons!
- ActionListener: adding listeners to buttons
- Anonymous classes as listeners
- Adding text to text areas
- Custom Components07:30
How to divide your application up into separate self-contained components by subclassing other classes -- in this case, the JPanel class.
- JPanel
- Custom Components
- Scroll bars with JScrollPane
- Simple Toolbars06:25
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
Note: in a later tutorial we'll cover the JToolbar class; this tutorial covers a technique for creating a simple toolbar-like panel, illustrating the useful FlowLayout. - Communication Between Components10:36
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
- Listeners and Events: Using Interfaces to Cleanly Separate Components11:38
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
- Setting Component Sizes05:10
How to change the sizes of your components.
- Preferred Size
- The Dimension class
- setPreferredSize() vs. setSize()
- How layout managers handle component sizing
- Setting Borders03:18
Setting your components' borders.
- The BorderFactory and Border classes
- Titled borders
- Empty borders
- Etched borders
- Compound borders
- Text Fields and Labels04:04
Using the JTextField and JLabel classes to add text fields (one line text entry controls) and labels to your application.
- JTextField
- JLabel
- JTextField
- Laying Out Controls with GridBagLayout16:09
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
- Custom Events and Form Submission20:46
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
- List Boxes10:04
List boxes allow you to select items from a list. Also in this tutorial, a bit more about MVC architecture.
- The JList class
- The DefaultListModel class
- Working With List Box Data09:43
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.
- Working with list box model data
- Combo Boxes12:37
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
- Checkboxes09:44
How to use the JCheckBox class to add checkboxes to your forms.
- The JCheckBox class
- Enabling and disabling form fields
- Radio Buttons09:47
How to use radio buttons, those little round controls that allow you to choose between small numbers of exclusive options.
- The JRadioButton class
- The ButtonGroup class
- Action commands
- Menus09:57
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.
- Creating menus
- The JMenuBar, JMenu and JMenuItem classes
- Using Checkboxes in Menus06:24
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
- Mnemonics and Accelerators10:15
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
- Message Boxes11:29You know message boxes? Those little messages that pop up asking you if you really want to do something or other, or warning you about something? This tutorial is about those. In Swing, message boxes are implemented via the JOptionPane class. Also in this tutorial; how to set minimum sizes for components.
- The JOptionPane class
- Confirm and Message option dialogs
- The setMinimumSize() method
- Open/Save File Dialogs06:31
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.
- Using File Choosers
- The JFileChooser class
- Filtering File Choosers07:57
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.
- Filtering JFileChooser
- The FileFilter class
- How to get the file extension from the file name
- Model-View-Controller: Creating a Data Model13:53
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
- Model-View-Controller: Creating a Controller15:07
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 Tables21:13
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: Saving Objects to Files16:32
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
- Popup Menus07:28
Learn how to create those little menus that appear when you right-click on things.
- The JPopupMenu class
- Intercepting mouse clicks
- Introduction to mouse listeners and mouse events
- The MouseAdapter class
- A note on those pesky serialization id warnings in Eclipse
- Selecting Rows in Tables05:10
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
- Deleting Rows in Tables11:15
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
- Dialogs05:38
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
- Spinners: Specialised Controls for Entering Numbers12:02
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
- Password Fields07:16
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.
- The JPasswordField class
- Converting arrays of characters to String objects
- Saving Program Data: Preferences12:58
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
- Arranging and Designing Dialogs and Forms20:58
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)
- JDBC: Connecting to a SQL Database11:15
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
- JDBC: Retrieving Values from Databases12:34
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
- JDBC: Saving to a Database13:02
A tutorial on saving a Java object's fields to a database.
- Inserting database rows
- Using PreparedStatement to do an insert
- Converting enum values to strings
- JDBC: Updating Databases06:11
This tutorial adds to our JDBC code by drawing on what we've already seen to update database rows.
- Updating database rows
- More on prepared statements
- JDBC: Loading Data from Databases15:25
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
- Wiring in the Database Code: Bringing It All Together17:24
This tutorial brings together our database code with our GUI code, implementing save and refresh buttons on the toolbar.
- Wiring in the database code
- Using Eclipse to refactor code
- Intercepting the Window Closing Event09:01
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
- Using Images and Icons09:28Want to set icons on your buttons or labels? This tutorial covers loading images and icons and setting them on buttons. You can also set icons on labels using the same technique -- in fact images will display even large images if you want. And of course, you can set an icon on your main JFrame using a similar technique (check out the ImageIcon getImage() and JFrame setIconImage() methods).
- 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
- Draggable Toolbars: Using the JToolbar class04:55
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
- Split Panes: Creating Resizeable Separate Areas07:36
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.
- Tabs: Using Tabbed Panes03:11
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
- Tree Views Using JTree09:48
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
- Tree Selection Events04:50
Learn how to detect when someone clicks one of the nodes in your JTree.
- JTree selection events
- Making your tree single-selection only
- The TreeSelectionListener interface
- Associating Data With Tree Nodes08:20
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.
- JTree user objects
- Tree Node Icons07:27
The JTree class allows you to use custom icons for your tree nodes. In this tutorial, we'll see how to do just that.
- Using custom tree node icons
- The DefaultTreeCellRenderer class
- Custom Tree Cell Renderers: Using Checkboxes in Trees20:48
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
- Custom Tree Cell Editors: Editing Tree Nodes Using Checkboxes26:06
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
- Detecting Tree Node Editor Changes05:48If you've implemented your own tree cell editor along the lines of the code we looked at in the last tutorial, you'll want to know how to tell when your tree nodes have been edited. We'll look at that in this tutorial.
- Listening to tree cell editor events
- The TreeCellEditor class
- A Simulated Message Server20:59
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
- Multithreading in Swing: The SwingWorker class11:48
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
- Multithreading in Swing: running tasks in the background
- Modal Dialogs08:06
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 Bars15:29
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
- Distributing Your Application: Runnable Jars07:52
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
- Adding Text to Progress Bars04:21
This is just a quick tutorial on adding text to progress bars (such as "loading 85% ...."), which is a nice extra touch.
- Adding text to progress bars with setStringPainted() and setString()
- Formatting a percentage with String.format()
- Cancelling SwingWorker Threads13:33
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
- InterruptedExceptions
- Setting the Cursor02:48
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.
- Setting the cursor
- The Cursor class
- Multiple Nested Split Panes09:36
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
- Responding to Tab Selections06:15
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
- Custom List Renderers13:11
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
- Responding to List Selections05:55
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
- Changing the Font Using Logical Fonts04:58
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
- Loading Font Files08:19
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.
- Setting physical fonts
- More info on the Font class
- Creating derived fonts
- Configuring the Database Connection01:35
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.
- Editable Tables08:22
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.
- Setting values in table models
- More on AbstractTableModel
- Using Checkboxes in Table Cells06:44
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
- Custom Table Cell Renderers10:20
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)
- Using Custom Editors in Table Cells07:13
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
- About Applets and the Following Section06:49
- Applets: Creating a Simple Swing Program that Runs in a Webpage04:52
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
- Drawing Custom Components09:11
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
- Drawing Shapes: Exploring the Graphics API07:54
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.
- The Ellipse2D and RoundRectangle2D classes
- Turning on anti-aliasing to smooth your drawing
- Deploying Applets11:49
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.
- Deploying applets using HTML
- How to deploy applets on the Internet
- Timers: Using the Swing Timer Class05:05
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
- Basic Animation10:52
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
- Smoothing Your Animations With Double Buffering05:59
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.
- Double buffering
- The BufferedImage class
- Drawing images using the graphics API
- Mouse Listeners05:47
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.
- Mouse listeners
- Mouse motion listeners
- The MouseAdapter class
- Hiding the Cursor03:22
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
- Key Listeners06:32In this tutorial we'll look at how to detect key presses using key listeners. We'll add a "global" key listener here, but I also discuss briefly how to add key listeners to specific components
- The KeyListener interface
- The KeyboardFocusManager class
- Component key listeners vs. global key listeners
- Handling arrow keys
- Making components focusable
- The KeyListener interface
- Detecting Component Resizing02:33
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
- Using Visual Designers: The Free Window Builder Pro Plugin17:16
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
- CardLayout: Switching Between Completely Different Views05:53
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
- Detecting Collisions Between Shapes05:23
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
- Turning an Applet into a Desktop App10:19
- Setting the Look and Feel07:37
- Source Code - Complete Projects75.2 kB
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.
- Projects -- The Source Code Projects You See in the Tutorials00:02
- "Swing Test" Database00:08
JOIN OUR WHATSAPP GROUP TO GET LATEST COUPON AS SOON AS UPDATED
JOIN WHATSAPPJOIN OUR TELEGRAM CHANNEL TO GET LATEST COUPON
JOIN TELEGRAMJOIN OUR FACEBOOK GROUP TO GET LATEST COUPON
JOIN FACEBOOKFree Online Tools And Converters for your use
URL Encoder
Input a string of text or a URL and encode the entered string
Try itURL Decoder
Input an encoded string of text or a URL and decode the entered string
Try itColor Contrast Checker (WCAG)
Calculate the color contrast ration for your website (WCAG)
Try itXML Formatter
Paste or upload an XML and have it formatted to a beautiful XML format
Try itURL Slug Generator
Convert any title or sentence into a variety of slugs for your pages URL
Try itE-Signature
Draw an e-signature or type a signature for your online signature
Try it