Core Java 13 Application Development

Duration: 5 days

Having spent 25 years delivering successful Java courses around the world, it’s pretty safe to say that we have solid in-depth knowledge of what makes an awesome Java course. That’s why we are not only super confident about our new groundbreaking course, but also proud of what we have achieved with it.

We have built a new and modern course from the ground up that incorporates a fresh and improved way to introduce Java to Developers. We have accomplished this by leveraging new Java tools to introduce a new and unique way of explaining the Java Programming Language.

During our course you'll learn:

  • The Java Platform
  • The Java Language (version 13)
  • Declaration, Statement and Expression
  • Control flow-statements
  • Contemporary Object Oriented Programming Principles (in today's context)
  • Defining classes in Java
  • Using inheritance to specialise classes.
  • Using interfaces to define capabilities
  • Handling exceptions and resources
  • Using exceptions to impose business rules
  • The Collection Framework
  • Lambda Expressions
  • The Optional type to prevent system failures
  • Introduction to streams to work with collections in a declarative style

This course should be of keen interest to anyone looking to work with Java 8 or higher.

Ideally students should have some experience with an imperative programming language, such as Python, JavaScript, C.

Please find the course objectives below:


  • Introduce the Java Platform
  • History of Java
  • Overview of the Java Platform (APIs)
  • List different languages for the Java Platform
  • Understand the difference and relation between JDK, JRE, JVM, JSDK
  • Discuss different Java Distributions (Oracle, openJDK, …)
  • Installing Java manually
  • Setting up your environment
  • Running Java commands (java, jshell, …)
  • Installing Java using sdkman (Linux only)

The Java Language Basic

  • Java as an imperative Obect-oriented language
  • Java as a strongly typed language
  • Understand declarations and statements
  • Understand the difference between statements and expressions
  • The role of the semicolon
  • Documenting your code using comments
  • reserved words and keywords
  • Introduce some basic types

Declaration and Expression Statements

  • Declaring (local) variables
  • Define valid identifiers
  • Using expression statements
  • Understand literal expression
  • Using type inference using the var keyword

Core Types

  • List and discuss the three type systems in java
  • Introduce the primitive types
  • Use various literal values
  • Introduce the String type
  • Basic operations with Strings
  • Working with Strings
  • Using the java documentation (api)
  • Concatenating strings
  • Introduce multi-line text blocks


  • Understand arrays
  • Two ways of declaring arrays
  • Two ways for initialing arrays
  • Accessing array elements
  • Splitting Strings into arrays
  • Declaring and using Multi-dimensional arrays


  • Define Arithmetic expressions
  • Using boolean expression
  • Combining boolean expressions (logical and, or ,…)
  • Using the assigment operators
  • Different unary operators
  • Understand the difference between prefix/postfix operators

Control-flow statements

  • The if-stamenets
  • Using if-else
  • Introduce the block statement
  • Using the conditional expression (aka ternary operator)
  • The while and do statements
  • The for-statement
  • Using the enhanced for-statement (aka for-each)
  • Using the switch-statement and the switch-expression

Object-Oriented Programming (OOP)

  • Understand the essence of OOP
  • Contrast with other programming paradigms
  • What is an Object
  • Discuss behaviour and state (and their relation)
  • Introduce the concept of encapsulation (aka data-hiding)


  • Define abstraction means
  • Grouping objects into classes
  • Understand the role of classes
  • Introduce instances
  • Understand the deference between objects and instances
  • Clearly understand the relation between objects, classes and instances

Classes, Instances and Objects in Java

  • List some key classes
  • Introduce constructors
  • Creating instances
  • Understand immutable instances
  • Calling methods on objects
  • Using overloaded methods


  • Introduce the concept of a reference
  • Understand the difference between references and pointers
  • Introduce the heap
  • Appreciate the garbage collector
  • Understand where objects are instantiated
  • Multiple references to objects
  • Understand the difference between a reference and a value
  • How to compare objects


  • Introduce the null-reference
  • Understand the problem of null
  • What is a NullPointerException
  • Preventing NullPointerExceptions

Core Objects

The StringBuilder

  • Introduce the StringBuilder
  • Building strings
  • Understand when to use string concatenation vs StringBuilder
  • Working with the StringBuilder (insert, add, delete, …)

Wrapper Classes

  • Understand the need for Wrapper Classes
  • List the different wrapper classes (Integer, Boolean, Double, …)
  • Converting (parsing) Strings to primitive
  • Creating strings from primitive values
  • Autoboxing and auto-unboxing
  • Understand the difference between valueOf and constructors
  • Appreciate the cache

Writing Basic Classes

  • Introduce the class-declaration
  • The Java Naming conventions
  • Capture object behaviour in methods
  • Keeping the object' state in fields
  • Appreciate how fields are initialised with default values
  • Define Immutable state using final fields

Implementing Methods

  • Understand the this reference
  • Implementing methods and return values
  • Understand the method's return type
  • Introduce void
  • Overloading methods
  • Passing multiple values using varargs
  • Defining constructors
  • Scoping using private and public

Defining Constructors

  • Understand the role of the constructor
  • Appreciate the default constructor
  • Adding constructor arguments
  • The no-arg constructor

Static and Enum

  • Introduce static
  • Object state vs class state
  • Defining class state using static fields
  • Defining behaviour on a class using static methods
  • Implementing static methods
  • Understand enumerated types
  • Defining an enum class
  • Defining elements

Java Application Development

  • Understand the structure of a java application
  • Writing java source files
  • Compiling java source to class files
  • Organising project files
  • Defining a main-method
  • Running java applications
  • Understand the CLASSPATH
  • Introduction to using build tools (maven and gradle)
  • Introduce packages
  • Importing classes from other packages
  • Scoping rules for packages
  • Using the static import


  • Understand type-hierarchies
  • Understand the concept of *inheritance (aka specialisation)
  • Explore the java object type system
  • Introduce java.lang.Object
  • Construct a class that extends another class.
  • Correctly implement equals, hashcode and toString.
  • Write constructors that pass initialization data to the parent constructor as appropriate.
  • Use instanceof to verify the class type of an object reference.
  • Override subclass methods and use the super keyword to leverage behaviors in the parent.
  • Safely typecast references to a more refined type.
  • Understand the concept of polymorphism
  • Use the final keyword on methods and classes to prevent overriding through subclassing.


  • Use interfaces to Separate capability from object type
  • Defining interfaces
  • Implementing interfaces
  • Adding fields to interfaces
  • Discuss Use cases for interfaces


  • Understand exceptions
  • Understand the effect of exceptions and the call stack
  • Different types of exceptions
  • Understand how exceptions indicating a system failure
  • Implementing business rules using application exceptions
  • Correctly implement/override a method which throws exceptions.
  • Throwing exceptions

Handling Exceptions

  • Define a try-catch block to handle exceptions
  • Discuss handling patterns (logging, propagating, passing on)
  • Catching multiple exceptions
  • Rethrowing exceptions
  • Define try-finally to handle resources
  • Using try-with-resources for automatic resources management (ARM)

The Collection Framework

  • Understand the different types of collections
  • Introduce the collection interfaces
  • Discuss collection implementations techniques (e.g, arrays, linked list, trees)
  • Explain the big-O notation
  • Appreciate how generics ease the development of (type-safe) collection
  • Type inferences and collection variables
  • Iterating through a collection
  • Defining ordered collection using List
  • Choosing between ArrayList, LinkedList and other implementations
  • Working Sets and OrderedSets
  • Appreciate hashing vs trees
  • Understand the hashCode and equals contract
  • Create read-only and immutable collections
  • Sorting collections
  • Implement natural ordering
  • Defining a Comparator
  • Introduce Queue and Deque implementations
  • Using key-value pairs using Map
  • Working with maps (reading, updating, iterating, …)
  • Discuss different map implementations

Lambda Expressions

  • Understand functions as values
  • Introduce higher-order functions
  • Use function-literals in Java
  • Type inference when using lambda-expressions
  • Returning values from a lambda-expression
  • Using lambda's with clojures (and understand java's restrictions)
  • Use the benefits of single abstract methods (SAM)
  • Using Method references so that they can be used as functions


  • Discuss the problems with null as a bottom value
  • Explore alternatives to null
  • Introduce Java's Maybe type: Optional
  • Using Optional in your applications to prevent NullPointerExceptions
  • Using map to keep your code clean
  • Composing optionals using flatMap

Introduction to Streams

  • Recap imperative vs declarative programming
  • Introduce streams
  • Using collections as a source
  • Implementing side-effects using for-each
  • Performing intermediate operations (e.g, filter, map, …)
  • Using peek as a wiretap
  • Using stateful operations (e.g., distinct, sorted, …)
  • Using short-circuiting terminators (e.g., allMatch, noneMatch, findFirst, …)
  • Understand the concept of reduce (aka folds)
  • Using common reduce operations (e.g, count, min, avg, min, …)
  • Collecting stream data into collections and maps
  • Converting a stream to a string
  • Grouping data into multiple collections
For an onsite course please contact us