1300 888 724 8.30am to 5:30pm AEST (Mon-Fri) info@dynamicwebtraining.com.au

Java Application Development Course

(5.00 out of 5) 1 Student Reviews

About the Course

This 3-day Java Advanced course will take you step by step through developing code to use regular expressions to search for strings and utilise streams. Students will learn how lambda expressions work to deal more efficiently with collections, and use patterns to write 'best of breed' applications. You will also learn how to read and write data to files and databases. Most importantly we will cover improving the performance of your code through threads and related technologies, spending time on making sure you understand what thread safety is, and how to avoid the common problems that threads present.

Who should do this course?

This course is designed for students who want to develop complete Java-based solutions, with the focus on using built-in functionality that enables you to write multi-threaded code that also interacts with external resources and utilities. It is also ideal for anyone who needs to develop a GUI applications or is interested in applying patterns to ensure their code follows best practices.


Participants should have completed the Java for Beginners and Intermediate course or have equivalent skills, including, have a good understanding of Java syntax, coding structure, object-oriented programming and familiarity with using IDE’s, preferably NetBeans or Eclipse

Course Details

  • $1980 incl GST
  • Duration: 3 Days
  • Max. Class Size: 10
  • Avg. Class Size: 5
  • Study Mode: In Class Live Online
  • Level: Advanced
  • Times: 9.00am to 5.00pm approx
  • Download Course PDF
  • Enquire Book Now
    Pay later

Online Live - Course Dates

  • Online Live Class Dates

    Book Now
    16 - 18 Dec 20 Wed - Fri
    08 - 10 Mar 21 Mon - Wed
    09 - 11 Jun 21 Wed - Fri
    23 - 25 Aug 21 Mon - Wed
    24 - 26 Nov 21 Wed - Fri
  • To inquire about Live Online Classes, please

    Call 1300 888 724

In-Class - Course Dates

  • Sydney Class Dates

    Book Now

    Level 11, 32 Walker Street, North Sydney , NSW 2060

    27 - 29 Jan 21 Wed - Fri
    03 - 05 Mar 21 Wed - Fri
    21 - 23 Apr 21 Wed - Fri
    31 May - 02 Jun 21 Mon - Wed
    19 - 21 Jul 21 Mon - Wed
    01 - 03 Sep 21 Wed - Fri
  • Melbourne Class Dates

    Level 12, 379 Collins Street, Melbourne , VIC 3000

    Classes scheduled on demand in Melbourne

    Please Join our waitlist and we'll notify you when a new class is scheduled or contact us to disucss your training needs.

  • Brisbane Class Dates

    Level 6, 371 Queen Street, Brisbane , QLD 4000

    Classes scheduled on demand in Brisbane

    Please Join our waitlist and we'll notify you when a new class is scheduled or contact us to disucss your training needs.

  • Canberra Class Dates

    Level 4, 54 Marcus Clarke Street, Canberra , ACT 2601

    Classes scheduled on demand in Canberra

    Please Join our waitlist and we'll notify you when a new class is scheduled or contact us to disucss your training needs.

  • Adelaide Class Dates

    19 Young Street, Adelaide , SA 5000

    Classes scheduled on demand in Adelaide

    Please Join our waitlist and we'll notify you when a new class is scheduled or contact us to disucss your training needs.

  • Perth Class Dates

    Level 1, 140 St Georges Terrace, Perth , WA 6000

    Classes scheduled on demand in Perth

    Please Join our waitlist and we'll notify you when a new class is scheduled or contact us to disucss your training needs.

Course Units

Expand full topic list

Unit 1: Introducing the Course

  • About This Course
  • Checking Understanding
  • Understanding Java as a Platform

See more

Unit 2: Using Regular Expressions

  • Introducing Regular Expressions
  • Defining Regular Expressions
  • Understanding How Regular Expressions Work with Java
  • Investigating a Simple Example
  • Defining a Pattern
  • Understanding the Syntax
  • Looking at Examples
  • Writing Code
  • Working with Pre-Built Patterns
  • Looking at Quantifiers
  • Looking at Greediness
  • Working with Boundary Markers
  • Working with Groups
  • Looking at Other Useful Methods

See more

Unit 3: Introducing IO

  • Understanding a Stream
  • Selecting the Right Class
  • Selecting a Class Based on Input and Output
  • Selecting a Class Based on Stream Content
  • Selecting a Class Based on the Type of Destination or Source
  • Acting on Streams
  • Buffering a Stream
  • Filtering a Stream
  • Transforming a Stream
  • Putting It All Together - Example
  • Dealing with Exceptions in Io
  • Closing the Stream
  • Looking at Typical Exceptions
  • Using the Finally Clause
  • Putting It Together - Try Catch Example
  • Try with Resources
  • Understanding Auto-Closable
  • Reading and Writing to or from the Console
  • Writing to Screen
  • Reading from Keyboard
  • Understanding Channels
  • Investigating Serialisation
  • Defining Serialisation
  • Understanding the Restrictions
  • Understanding How Serialisation Works
  • Defining Transient Fields
  • Customising Reading
  • Customising Writing
  • Reading into a Different Object
  • Reading into a New Version of an Object
  • Using SerialVersionId
  • Overriding SerialVersionId

See more

Unit 4: Working with Files

  • Introducing the New File Io
  • Learning the Advantages
  • Finding the Classes
  • Avoiding Confusion
  • Looking at the New Classes
  • Understanding the Path Class
  • Understanding the Files Class
  • Understanding the Paths Class
  • Using the Path and Paths Classes
  • Creating a New Path
  • Comparing Relative and Absolute Paths
  • Using the Basic Methods
  • Removing Redundancies
  • Defining Sub-Paths
  • Resolving Paths
  • Relativising Paths
  • Dealing with Symbolic Links
  • Using the Files Class
  • Looking at Available Operations
  • Checking for Existence
  • Creating Files
  • Deleting Files
  • Copying Files
  • Copying Streams to Files
  • Listing Directory Contents
  • Using Streams from the New File Io
  • Working with File Properties

See more

Unit 5: Understanding Threads

  • Introducing Threads
  • Understanding What a Thread Is
  • Understanding the Advantages of Threads
  • Understanding the Disadvantages of Threads
  • Looking at a Simple Example
  • Making Classes Runnable
  • Creating a Thread
  • Starting a Thread
  • Stopping a Thread
  • Understanding the Issues
  • Stopping a Thread Explicitly
  • Using Interrupt
  • Using Sleep
  • Understanding Thread Safety
  • Looking at a Simple Example
  • Looking at the Problems with Shared Data
  • Defining Thread Safety
  • Looking at Examples of Safe Threads
  • Looking at Examples of Unsafe Threads
  • Synchronising Methods
  • Understanding the Advantages
  • Looking at a Code Example
  • Understanding Disadvantages
  • Synchronising Blocks
  • Understanding Advantages
  • Looking at a Code Example
  • Introducing Locks
  • Understanding Deadlock
  • Looking at an Example of Potential Deadlock
  • Understanding How Deadlock Happens
  • Looking at a Simple Solution
  • Other Methods of a Thread

See more

Unit 6: Using the Concurrency Package

  • Investigating Locks
  • Implementing Atomic Operations
  • Using Thread Safe Collections
  • Introducing Synchronisers
  • Investigating Types of Synchronisers
  • Understanding the Cyclic Barrier Synchroniser
  • Using the Cyclic Barrier Synchroniser
  • Using the Executor Service
  • Understanding the Executor Service
  • Understanding the Runnable Interface
  • Returning Results from Callable Tasks
  • Understanding the Future Class
  • Fetching the Returned Results
  • Understanding Callable Tasks
  • Shutting Down Executor Services
  • Using Fork and Join
  • Looking at Code Without Parallelism
  • Adding Parallelism to Code
  • Breaking the Task Up
  • Understanding Work Stealing
  • Drawing a Conclusion
  • Investigating an Example of Fork and Join
  • Looking at a Single Thread Example
  • Understanding the Big Picture
  • Understanding Recursive Jobs
  • Understanding the RecursiveTask Class
  • Understanding the RecursiveAction Class
  • Splitting Tasks
  • Putting It Together

See more

Unit 7: Manipulating Collections Using Streams

  • Introducing Pipelines
  • Understanding Pipelines
  • Understanding the Advantages of Pipelines
  • Converting a Collection to a Stream
  • Using the Stream to Filter a Collection
  • Using the for Each Method of the Stream
  • Converting a Stream to a Collection
  • Understanding the Nature of a Pipeline
  • Revisiting Lambda Expressions
  • Saving and Re-Using Lambda Expressions
  • Referencing Methods in a Lambda Expression
  • Referencing Instance Methods
  • Referencing Constructors
  • Referencing Static Methods
  • Referencing Methods from the API
  • Looking at Other Classes in the Streams Package
  • Introducing Other Operations on a Stream
  • Chaining Methods
  • Understanding the Optional Class
  • Investigating Intermediate Operations
  • Understanding the Filter Operation
  • Understanding the Map Operation
  • Understanding the Peek Operation
  • Understanding the FlatMap Operation
  • Investigating an Example of the FlatMap Operation
  • Investigating Terminal Operations
  • Using ForEach
  • Using Collect
  • Using Numerical Operations
  • Using Other Non-Numerical Operations
  • Investigating Short Circuit Terminal Operations
  • Looking at Search Operations
  • Looking at Lazy Operations
  • Drawing Conclusions
  • Looking at the Old Way
  • Looking at the New Way
  • Breaking the New Way into Its Parts
  • Comparing the New and Old Ways

See more

Unit 8: Advanced Manipulation of Collections Using Streams

  • Sorting
  • Looking at Example Output
  • Investigating Available Operations
  • Using Your Own Comparator
  • Using Lambda Expressions
  • Adding Additional Sorts
  • Reversing the Order
  • Putting It All Together
  • Collecting
  • Looking at Example Output
  • Using the Collect Operation
  • Investigating the Collector Class
  • Averaging
  • Grouping
  • Joining
  • Partitioning
  • Putting It All Together
  • Parallelising
  • Modifying Existing Definitions
  • Starting from Scratch
  • Understanding Determinism
  • Investigating Non-Deterministic Operations
  • Looking at an Example of Stateful Operations
  • Rewriting Code to Be Stateless
  • Using Reduction
  • Revisiting Fork and Join
  • Understanding Reduction
  • Looking at an Example
  • Defining Non-Associative Functions
  • Understanding Why They Cause a Problem
  • Looking at an Example
  • Breaking Down the Processing
  • Illustrating Parallelism in Streams
  • Considering When to Use Reduction

See more

Unit 9: Developing an Application with Java Database Connectivity (JDBC)

  • Introducing JDBC
  • Understanding JDBC
  • Looking at the Classes Used in JDBC
  • Understanding the Purpose of Each Class
  • Investigating Alternative to JDBC
  • Introducing JDBC Drivers
  • Understanding JDBC Divers
  • Picking a JDBC Driver
  • Locating Your JDBC Driver
  • Understanding the URL Syntax
  • Investigating Result Sets
  • Understanding Result Sets
  • Populating a Result Set
  • Fetching Data from a Result Set
  • Looping Through a Result Set
  • Getting Meta Data from Result Set.
  • Setting Fetch Size
  • Understanding the RowSet Class
  • Handling JDBC Exceptions
  • Understanding the SQLException Class
  • Handling SQL Exceptions
  • Closing Resources
  • Using Try with Resources
  • Writing Other SQL Statements in JDBC
  • Using ExecuteUpdate
  • Using Execute
  • Using Parameters
  • Calling Stored Procedures
  • Investigating Transactions
  • Defining a Transaction
  • Understanding Transactions
  • Looking at Code Without a Transaction
  • Looking at Code with a Transaction
  • Understanding Default Behaviour
  • Explicitly Controlling Transactions

See more

Unit 10: Patterns

  • Introducing Patterns
  • Understanding Patterns
  • Observing Patterns
  • Describing Patterns
  • Understanding the Dry Principle
  • Understanding Where Patterns Came from
  • Getting More Information
  • Investigating the Singleton Pattern
  • Understanding the Concept
  • Using the Pattern
  • Coding the Pattern
  • Investigating the Factory Pattern
  • Understanding the Concept
  • Using the Pattern
  • Coding the Pattern
  • Looking at Advantages
  • Investigating the Builder Pattern
  • Understanding the Concept
  • Using the Pattern
  • Coding the Pattern
  • Looking at Advantages
  • Investigating a More Complex Pattern
  • Understanding the Dao Pattern
  • Understanding the Problem
  • Looking at the Initial Code
  • Understanding the Dao Class
  • Understanding the Interface and Implementation
  • Looking at the Code After Applying the Dao Pattern
  • Using the Factory Pattern in Dao
  • Looking at the Code After Applying the Factory Pattern
  • Investigating Advantages of Using Patterns

See more

Unit 11: Introduction to Swing

  • Introducing Swing
  • Creating Frames
  • Displaying Information
  • Working with Fonts, Colours and Shapes
  • Displaying Images
  • Introducing Layout
  • Using Layout Management
  • Adding Components
  • Understanding Event Handling
  • Understanding Actions
  • Exploring Mouse Events
  • Adding Menus
  • Adding Dialog Boxes
  • Deploying the Application
  • Understanding JAR files
  • Understanding Applets
  • Using Java Web Start

See more

Unit 12: Introduction to JFX Application

  • Introducing Java FX
  • Using Scene Builder
  • Understanding the Window Structure
  • Displaying Text and Images
  • Understanding Event Handling
  • Laying Out Nodes
  • Using Radio Buttons, Mouse Events and Shapes
  • Understanding Binders and Listeners
  • Using Java FX Collections
  • Cusomising ListView Cells
  • Investigating Other Features

See more

Related Courses

Course Reviews

(5.00 out of 5) Moorthy S [ 02 September, 2020 ]
All good

Read all course reviews

Enquire Now

Fill in your details to have a training consultant contact you to discuss your training needs.

Your details

Other Ways To Get In Touch

You can also Book Online or call us on 1300 888 724

Back to Top