Java application - working with data
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
11 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Java application - working with data to your Wishlist.

Add to Wishlist

Java application - working with data

Design an application using Model, View, Control approach and the event notification model
0.0 (0 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
11 students enrolled
Created by John McNeil
Last updated 6/2017
English
Current price: $10 Original price: $45 Discount: 78% off
5 hours left at this price!
30-Day Money-Back Guarantee
Includes:
  • 7.5 hours on-demand video
  • 25 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • The course demonstrates a method of managing data and reflecting data changes in the GUI using a Model/View/Control technique that you can apply to your own applications
  • Design an object structure to hold application data
  • Provide a means of managing a collection of data items, add, edit, remove as well as locate a specific item
  • Link the data to the User Interface and provide an interface to add, edit and delete data items
  • Use a Tree object to select a specific data item and have the Tree undated to reflect changes in the data collection
  • Save and load the collection of data to file so you don’t lose your work
  • Provide a mechanism to clear out an existing set of data and start a new
  • Provide a means to Open, Save and Sava As the collection of data
  • You will make extensive use of the event listeners to be informed of events and changes within the program
  • You will learn how to create events and fire off events to notify other parts of your application of changes
View Curriculum
Requirements
  • Knowledge of the Java programming language
  • A Windows based PC to get the most out of the course
  • You will need to download and install Eclipse IDE. You can use another IDE or the Java commande line compiler but the course demonstrates using Eclipse
  • Java Run Time Environment (JRE) or Java Developer Kit (JDK) Standard Edition
  • A few other freely available tools such as Log4J and JGoodies Forms
Description

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: -

  • Teach you how to pass an exam
  • How to get the next killer job in an IT company
  • Or claim to teach you complete Java. 

 

This course is all about: -

  • How to make your code do something. 
  • How to link your data to your user interface so when something changes in your data it is reflected on the display. 
  • It’s about how to put together a display with components the allow you to manage your data. 
  • And it’s about how to save and load that information between sessions. 

 

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.

Who is the target audience?
  • This course is aimed at people who have are interested in writing Java programs
  • You will ideally be programming as a hobby or for leisure and looking to solve practical problems
  • You should be familiar with creating basic Swing based applications
  • This course is aimed at people who are interested in building desktop applications in Java
  • Ideally you should have completed a Java basic course or are cross training from a language like C or C++ to Java
  • You should be familiar with creating basic Swing based applications
Students Who Viewed This Course Also Viewed
Curriculum For This Course
67 Lectures
07:27:40
+
Getting started
2 Lectures 11:38

Setting up our Java project in the Eclipse IDE and then importing the base code from which we will develop our application.

Setting up your development environment
07:52
+
Data modelling
7 Lectures 31:12

Introduces how we will build our data model class which will form the corner stone of our application.

Introduction to data modelling
00:49

Covers creating the base class for our data model and adding our data items to the class.

Adding data fields to the data model
04:37

Adds code to access the data items using Get and Set methods inline with the JavaBeans specification.

Adding methods to access the data
05:11

Setting up the constructor method to initialise our data items when creating a new object.

Creating a constructor for the data model
03:35

Adding code to notify other parts of the program when our data changes. Adds FirePropertyChange events to our data items.

Notifying other objects of changes to the data
07:05

Overriding the toString() method to provide a means or writing the data out to file.

Writing out the the data
03:28

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.

Using the data model
06:27
+
Reading and Writing data to disk
5 Lectures 29:01

Outlines how we will save our data between sessions by writing the data to file in XML.

Introduction to reading and writing data to disk
01:14

Creating our class to convert our data from the object to XML and write this to a file.

Writing data to file
07:21

Adding a method to our XML read/write class to allow us to read in XML data for our data object.

Read data from file
05:04

Making use of our write to file method from within the application.

Calling the write method
07:10

Reading data from file when starting up our application.

Calling the read method
08:12
+
Data Presentation
6 Lectures 42:33

Creating the class and display fields to display our ship data.

Creating the display fields
06:43

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.

Setup the display panel
10:26

Preparing to connect the data model object to the display panel using JGoodies Binding.

Binding model data to a value holder
07:13

Completing the connection between our data model and the display panel fields.

Linking the model to the display
04:46

Adding the panel fields to the the JPanel so they appear in order and with their labels.

Adding display fields to the panel
06:17

Adding the display panel to our application and use it to display data from one of the ships in our fleet.

Displaying data in the application
07:08
+
Managing a collection of ships
5 Lectures 41:00

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.

Preview 07:19

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.

Adding and removing ships from our Fleet
05:59

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.

Reading and writing our fleet to disk
07:56

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.

Loading up the fleet on startup
09:56

In this video we look at writing our fleet to file when the application is closing down.

Using the fleet class
09:50
+
Navigating through the Fleet
6 Lectures 39:14

Introduces how we manage our fleet of ships using a new controller class. 

Preview 01:48

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.

How the Controller class works
12:31

Adding methods to the controller to allow navigation from ship to ship.

Creating controller class
06:17

Creates the code to allow the first and last ships in the fleet to be retrieved.

First and Last ships
04:22

Adding methods to the controller to navigate to previous and next ships in the fleet.

Previous and Next ships
03:31

Adding the edit method to the controller and integrating the controller into the application.

Adding edit to the controller
10:45
+
Adding the Button bar
12 Lectures 01:27:59

Outlines how the button bar will work, providing an understanding of what the code will need to achieve.

Button bar overview
04:56

Creating the Action button bar
05:46

Enabling and disabling buttons
06:25

Wiring up the Button bar
05:17

Firing change events
06:55

Adding the controller to the application
03:16

Introduction to building the edit ship dialog class.  This lecture describes how the dialog is build, what it does and how this is achieved.

Introduction to the edit dialog
07:11

Add the code for the Edit Dialog class to allow the adding and editing of ship details.

Coding the Edit Dialog class
12:02

Add the Edit dialog window into the application so it can be used to add new ship details to the fleet.

Adding edit dialog to the application
07:40

Use the edit dialog window to alter data and have these changes reflected in the user interface.

Editing ship details
07:03

Create a delete dialog window and add into the application.  Wire up the delete button to allow the deletion of data.

Deleting ship details
18:19

Enable previous and next buttons to display the various data items.

Moving through data items
03:09
+
Adding Fleet Navigation
6 Lectures 42:25

Explains and shows how we will add our new navigation to the application.

Application Split Window Introduction
01:45

Adds code to change the main window for the application into a split pane.

Split Window code
07:08

Create the JTree model event handling code and abstract model that implements JTree model interface.

Creating the JTree Model
10:31

Building up the JTree Model
08:18

Implements the code for the JTree model interface.

Implementing JTree model interface
09:02

Add the JTree model into the application and test with some sample data.

Add Tree Model into the application
05:41
+
Making or JTree Dynamic
5 Lectures 33:25

Introduces how the JTree will reflect changes to the application data.

Setting out how the dynamic tree works
02:22

Hiding and displaying ship data based on selection.

Hiding and showing ship data
12:30

Links the JTree to the controller so that the correct ship details are displayed based on the selection of the JTree.

Linking JTree to the data display
07:17

Provides a mechanism to allow the JTree to update when new ships are added to the fleet.

JTree updating when data added
07:09

Updates the JTree when ships are deleted from the fleet or the ship name is changed.

Updating JTree when data deleted and changed.
04:07
+
Finishing Off
13 Lectures 01:29:13

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

The finishing touches
02:22

Adds code so the fleet is displayed grouped by class or type

Changing JTree Grouping
10:11

Building the presentation model for Fleet Name dialog
06:54

Changing the fleet name
14:26

Add code to save the data to file.

Implementing Save
03:05

Add code to clear out any existing fleet data and create a new empty fleet.

Implementing Open
11:17

Adding code to implement creating a new fleet.

Implementing New option
03:59

Creating a new class, ExternalFile, to hold the file name for our data.

Knowing where to save
05:30

Adding our new ExternalFile class into our code.

Adding ExternalFile to our Controller
04:05

Modify the existing code used to save and load data so that it now makes use of the new ExternalFile class.

Modify data output classes to use Filename
06:10

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.

Add Fleet Change Events
06:40

Complete the menu action listener code for the Save As menu item.

Save As Menu action listener
06:15

Enabling Save option
08:19
About the Instructor
John McNeil
4.0 Average rating
18 Reviews
1,251 Students
2 Courses
Designing and developing applications

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.