This course focuses on how to pull together an application that allows the program user to create information, store and manage that information in a user interface.
This course doesn’t: -
This course is all about: -
This course is perfect for those of you that want to put your Java programming knowledge to practical use. Those of you who want to bring your own ideas to life and are looking for a template to follow and ideas to apply.
This course is aimed at the hobbyist the enthusiast because to complete this course you will need to be a jack of all trades and not a master of one. You will build the data model, the front end, the event model and the code to store the data, all of this you will have to code!
So if you feel up to the challenge to walk through building a desktop application to model, display and manage data then sign up and come on the journey with us.
Introduces how we will build our data model class which will form the corner stone of our application.
Covers creating the base class for our data model and adding our data items to the class.
Adds code to access the data items using Get and Set methods inline with the JavaBeans specification.
Setting up the constructor method to initialise our data items when creating a new object.
Adding code to notify other parts of the program when our data changes. Adds FirePropertyChange events to our data items.
Overriding the toString() method to provide a means or writing the data out to file.
You will learn how to take your newly created class that holds your data and add it into you application and test the basic features work.
Outlines how we will save our data between sessions by writing the data to file in XML.
Creating our class to convert our data from the object to XML and write this to a file.
Adding a method to our XML read/write class to allow us to read in XML data for our data object.
Making use of our write to file method from within the application.
Reading data from file when starting up our application.
Creating the class and display fields to display our ship data.
Creating the constructor and a method to access the display panel containing all the display fields. Includes using the JGoodies form builder to control the layout of objects.
Preparing to connect the data model object to the display panel using JGoodies Binding.
Completing the connection between our data model and the display panel fields.
Adding the panel fields to the the JPanel so they appear in order and with their labels.
Adding the display panel to our application and use it to display data from one of the ships in our fleet.
Describes our approach to managing a fleet of ship and how we will join the previous sections together using the fleet class. We create our basic fleet class and add in the properties for the class.
Adds methods to our fleet class. We will provide a means to allow us to change the name of the fleet. The ability to add and remove ships to and from our fleet are also provided. We will need to get the first ship in the fleet so a method to get the first ship in our fleet is developed. The ability to get the whole fleet of ships is also provided which we will use later to alter our reading and writing data to file.
Here we modify our existing read and write data to file code so that we can now read and write the whole fleet in and out of our application. Here we create a new class called the fleet loader which makes use of the previous reading and writing classes but allows us to handle a fleet of ships.
Now we have a means of reading and writing a fleet to file we will now change our application to make use of this change. The application now loads a fleet file if found, otherwise the default ship is created and added to a new fleet.
In this video we look at writing our fleet to file when the application is closing down.
Introduces how we manage our fleet of ships using a new controller class.
Outlines how we will build the controller class to allow us to navigate through our fleet of ships and manage adding and removing ships to the fleet. The controller class also ensures the as we move through the fleet of ships the display panel presents information on the currently selected ship.
Adding methods to the controller to allow navigation from ship to ship.
Creates the code to allow the first and last ships in the fleet to be retrieved.
Adding methods to the controller to navigate to previous and next ships in the fleet.
Adding the edit method to the controller and integrating the controller into the application.
Outlines how the button bar will work, providing an understanding of what the code will need to achieve.
Introduction to building the edit ship dialog class. This lecture describes how the dialog is build, what it does and how this is achieved.
Add the code for the Edit Dialog class to allow the adding and editing of ship details.
Add the Edit dialog window into the application so it can be used to add new ship details to the fleet.
Use the edit dialog window to alter data and have these changes reflected in the user interface.
Create a delete dialog window and add into the application. Wire up the delete button to allow the deletion of data.
Enable previous and next buttons to display the various data items.
Explains and shows how we will add our new navigation to the application.
Adds code to change the main window for the application into a split pane.
Create the JTree model event handling code and abstract model that implements JTree model interface.
Implements the code for the JTree model interface.
Add the JTree model into the application and test with some sample data.
Introduces how the JTree will reflect changes to the application data.
Hiding and displaying ship data based on selection.
Links the JTree to the controller so that the correct ship details are displayed based on the selection of the JTree.
Provides a mechanism to allow the JTree to update when new ships are added to the fleet.
Updates the JTree when ships are deleted from the fleet or the ship name is changed.
This lesson describes what is covered in this section of videos:
organise ships by ship class or type
rename the fleet
create a new fleet
open a saved fleet
save a fleet as a new file
save an existing fleet
Adds code so the fleet is displayed grouped by class or type
Add code to save the data to file.
Add code to clear out any existing fleet data and create a new empty fleet.
Adding code to implement creating a new fleet.
Creating a new class, ExternalFile, to hold the file name for our data.
Adding our new ExternalFile class into our code.
Modify the existing code used to save and load data so that it now makes use of the new ExternalFile class.
Add change listener code to the controller so that it is notified of changes to the fleet. Change the Fleet so that it notifies listeners when fleet data changes.
Complete the menu action listener code for the Save As menu item.
From my days as a teenager my personal interest has been in graphics, particularly the 3D world. However my professional life has been spent dealing with business issues and particularly the management and flow of information.
I have spent over 15 years designing and developing applications for business and for fun. I have worked with C, C++, Java, as well as a host of scripting languages and developed client/server, interactive web sites, web services and enterprise java solutions.
After years of designing solutions on various platforms I now spend my time sharing my knowledge and experience with others within the business arena so that they may develop their full potential. I prefer to use real world examples to demonstrate points where possible so much of my teaching is through doing.