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

Java Object Oriented Programming Course

(4.90 out of 5) 2 Student Reviews

About the Course

During this 3-day course students will learn about object-oriented design and understand how to start a Java-based project from scratch. You will learn about the Java environment and its inner workings so you can run the code you have written in the most appropriate environment. You will also learn to write code that utilises inheritance to save unnecessary duplication, polymorphism to make your code extensible, encapsulation to keep code simple, and interfaces to allow 'plug-and-play' style coding. At the end of this course, students should feel confident to write object-oriented code that is efficient, well designed and future proof.

Who should do this course?

This course is suitable for participants who want to extend their skills beyond the syntax of Java language and be able to write code to professional standards using best practices. This course is also relevant to people who want to learn about Object-oriented programming and principles.


Students should have completed the Java Beginners course or have a good understanding of Java syntax and coding structure and also have a good familiarity with using IDE’s, preferably Netbeans or Ecllipse

Course Details

  • $1980 incl GST
  • Duration: 3 Days
  • Max. Class Size: 10
  • Avg. Class Size: 5
  • Study Mode: In Class Live Online
  • Level: Intermediate
  • 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
    02 - 04 Dec 20 Wed - Fri
    24 - 26 Feb 21 Wed - Fri
    29 - 31 Mar 21 Mon - Wed
    17 - 19 May 21 Mon - Wed
  • 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

    18 - 20 Jan 21 Mon - Wed
    17 - 19 Feb 21 Wed - Fri
    06 - 08 Apr 21 Tue - Thu
    24 - 26 May 21 Mon - Wed
  • 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: Starting Out

  • Understanding this Course
  • Checking your Understanding of Code
  • Understanding Object Oriented Programming
  • Understanding Platform Independence
  • Understanding Java's Origins
  • Exploring how the Internet Saved Java
  • Understanding Java's Current Place in the Internet of Things
  • Exploring the Java Timeline

See more

Unit 2: Understanding Platform Independence

  • Gaining a Better Understanding of Platform Independence.
  • Understanding the Compiler
  • Understanding Bytecode
  • Understanding Machine Code
  • Understanding the Java Virtual Machine (JVM)
  • Putting it All Together
  • Investigating the Consequences of Platform Independence
  • Looking at Languages that are Platform Independent
  • Looking at Languages that are Not
  • Understanding the Drawbacks of Platform Independence
  • Understanding Micro, Standard and Enterprise Java
  • Understanding the Importance of Specifications
  • Joining the Java Community Process
  • Understanding the Java Environment
  • Understanding the Function of A JVM
  • Understanding how the JVM and Specification Work Together
  • Understanding why Some JVMs Differ from the Specification
  • Understanding the Java Developer's Kit (JDK)
  • Finding the JDK
  • Downloading the JDK
  • Exploring the Contents of the JDK
  • Running Java
  • Understanding how Java Runs
  • Compiling your Code
  • Running your Code
  • Looking at the Results

See more

Unit 3: Understanding Object Oriented Programming

  • Getting a Better Understanding of Object Oriented Programming
  • Looking at Languages that are Object Oriented
  • Looking at Languages that are Not Object Oriented
  • Understanding why Some People Say It's Easy and Others Say It's Hard
  • Comparing Object Oriented Code with Procedural Code
  • Analysing an Object Using a Simple Example
  • Looking at Different Types of Pens
  • Looking at Objects that are Not Pens
  • Checking Accuracy
  • Considering the Domain of Our Problem
  • Understanding Objects - Fields Verses Methods
  • Understanding Objects - Object Verses Class
  • Understanding Objects - Other Principles
  • Coding Objects in Java
  • Coding Blocks
  • Coding Classes
  • Coding Methods
  • Coding Fields
  • Coding Packages

See more

Unit 4: Gaining a Deeper Understanding of Classes

  • Understanding Memory: Stack Verses Heap
  • Understanding the difference between a primitive and an object
  • Investigating AutoBoxing and AutoUnboxing
  • Understanding the Class Loader
  • Understanding the Garbage Collector
  • Understanding How Java Passes Parameters

See more

Unit 5: Understanding Inheritance and Polymorphism

  • Looking at an Example of Inheritance
  • Reviewing Our Pen's and Pencil Example
  • Coming to Terms with the Concept of Inheritance
  • Understanding When to Use Inheritance
  • Sharing Features
  • Understanding the Advantages
  • Coding Inheritance in Java
  • Coding the Writing Implement
  • Coding the Pen
  • Coding the Pencil
  • Coding a Permanent Marker
  • Understanding the Concept of Single Inheritance
  • Understanding Why We Have Single Inheritance.
  • Coding Constructors to Utilise Inheritance.
  • Understanding the Inheritance of Constructors
  • Creating Multiple Constructors
  • Chaining Constructors
  • Explicitly Declaring the Default Constructor
  • Calling the Parent Constructor
  • Understanding what Polymorphism Is
  • Casting your Object
  • Understanding Casting
  • Using Instance Of
  • Writing Code Using Polymorphism
  • Using Polymorphism when Passing Parameters
  • Looking Deeper at Generic Code Using Polymorphism
  • Understanding Virtual Method Invocation
  • Investigating the Advantages of Generic Code
  • Understanding Polymorphism Through an Everyday Example

See more

Unit 6: Writing Code Using Encapsulation (Optional)

  • Encapsulating a Class
  • Understanding the Concept of Encapsulation
  • Writing Getters and Setters
  • Looking at Some Examples
  • Making Fields Private
  • Looking at a Complete Example
  • Making an Object Immutable
  • Understanding Immutable Objects
  • Looking at the Advantages
  • Looking at a Class Before Immutability
  • Creating Constructor
  • Removing Setters
  • Looking at the Class After Immutability
  • Investigation Encapsulation and Immutability with NetBeans
  • Generating Getters and Setters
  • Making Fields Private
  • Creating Constructors
  • Using Encapsulation in Real Life Examples
  • Adding Validation
  • Adding Formatting
  • Writing Code to Interpret Input
  • Writing Code for Data Independence
  • Looking at the Finished Product

See more

Unit 7: Using the Abstract, Final, and Static Keywords

  • Using Access Modifiers
  • Declaring and Using Final Variables
  • Declaring and Using Final Classes
  • Declaring and Using Final Methods
  • Understanding Static Fields
  • Declaring and Using Static Fields
  • Creating a Static Field
  • Comparing the Static and Final Keywords
  • Understanding Static Methods
  • Declaring and Using Static Methods
  • Understanding the Limitations of Static Methods
  • Understanding Static Classes
  • Declaring and Using Static Classes
  • Creating a Static Class
  • Declaring and Using Static Blocks
  • Declaring and Using Helper Classes
  • Using The Static Import Command
  • Understanding the Meaning of the Word 'Abstract'
  • Declaring and Using Abstract Classes
  • Understanding Abstract Classes
  • Declaring an Abstract Class
  • Using an Abstract Class
  • Declaring and Using Abstract Methods
  • Understanding Abstract Methods
  • Declaring an Abstract Method
  • Using an Abstract Method
  • The Relationship Between Abstract Methods and Abstract Classes.

See more

Unit 8: Writing Better Code with Enumerated Datatypes

  • Using Constants to Represent Datatypes
  • Understanding Why This Approach Fails
  • Looking at a Better Solution
  • Coding with Enumerated Datatypes
  • Investigating More Complex Enumeration
  • Putting it All Together

See more

Unit 9: Developing Interfaces

  • Introducing Interfaces
  • Understanding the Concept of an Interface
  • Understanding the Function of an Interface
  • Looking at an Example
  • Implementing the Interface
  • Programming Bottom Up with Interfaces
  • Programming Top Down with Interfaces
  • Creating an Interface for Global Constants
  • Creating an Interface to Serve as a Marker
  • Programming to an Interface
  • Writing Code That Uses an Interface
  • Revisiting Polymorphism
  • Using the Interface in Our Code

See more

Unit 10: Using Interfaces

  • Casting the Object from Its Interface to Its Implementation
  • Changing the Implementation of Our Interface
  • Investigating the Advantages of Interfaces
  • Writing New Code Using Interfaces
  • Using Interfaces to Understand Existing Code
  • Using Interfaces to Help with Possible Future Code
  • How Interfaces and Encapsulation Are Different
  • Investigating Multiple Inheritance with Interfaces
  • Writing Code for Multiple Inheritance
  • Understanding How It Works
  • Comparing Implementation and Extending
  • Looking at an Examples of Inheritance Hierarchies
  • Investigating Changes in Java SE
  • Putting Static Methods in an Interface
  • Including Default Methods in an Interface
  • Understanding How Default Methods Work

See more

Unit 11: Understanding How Lambda Expressions Work

  • Relationship Between a Lambda Expression and its Interface Name
  • Finding the Name of the Method
  • Working Out the Parameters
  • Assigning Code to the Method
  • Investigating Where Lambda Expression Can Be Used
  • Understanding What Is So Revolutionary About Lambdas

See more

Unit 12: Use of Object Oriented Principles in the API

  • Investigating an Example of Static Classes
  • Understanding the Math Helper Class
  • Using the Math Class
  • Using the Static Methods and Fields in the Math Class
  • Investigating an Example of Inheritance
  • Understanding Inheritance in Exceptions
  • Catching the Right Exceptions
  • Ordering the Catch Clauses
  • Raising your Own Exceptions
  • Creating your Own Exceptions
  • Wrapping Existing Exceptions
  • Investigating an Example of Interfaces and Polymorphism
  • Understanding Collection Interfaces
  • Coding to the Interface
  • Looking at the Advantages

See more

Related Courses

Course Reviews

(5.00 out of 5) Helen F [ 23 September, 2019 ]
Really like how the course is put together and all the practical examples.
(4.80 out of 5) Sangeeta [ 12 August, 2019 ]
This Course helped me refresh my basics in Java and Matthew explained concepts very well and in an interesting way. Thoroughly enjoyed. :)

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