Core Java Application Development

Part of our "Java & Spring" courses

5 days

Course Overview

Having spent many years successfully delivering Java courses around the world, it’s pretty safe to say that we have a solid in-depth knowledge of what makes an awesome Java course. That’s why we are super confident about our new groundbreaking course. We have built a new and modern course that incorporates a fresh and improved way of introducing 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

Course Prerequisites

Students should have prior programming experience in imperative languages such as C, C++, JavaScript etc


During our course you'll learn:

  • The Java Platform
  • The Java Language
  • 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.


  • 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


  • The case for immutable data structures
  • Introduce product and nominal tuples types
  • Introduce java's Records
  • Understand what boilerplate code is removed


  • 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.
  • Explain the concept of sealed classes
  • Permitting inheriting sealed classes


  • 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

Public Events

Currently we have no public courses planned for Core Java Application Development

Private Events

Do you have a team that needs a Core Java Application Development course?

Contact Us

Send us a message

This Core Java Application Development course looks very interesting, I do however have a question