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

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

Introduction

• 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
• Discuss different Java Distributions (Oracle, openJDK, …)
• Installing Java manually
• Setting up your environment
• Running Java commands (java, jshell, …)
• Installing Java using sdkman (Linux only)
• Writing a simple program (using Unnamed Classes)
• Adding documentation (HTML and Markdown)

The Java Language Basic

• Java as an imperative object-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

Arrays

• 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

Expressions

• 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-statements
• 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)

Classes

• 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

Records

• The case for immutable data structures
• Introduce product and nominal tuples types
• Introduce java's Records
• Understand what boilerplate code is removed
• Using Record Patterns to extract values

References

• 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

Null

• 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's 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

Subclassing

• 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 object references.
• Appreciate Pattern Matching using instanceof
• Using pattern matching syntax in switch statements/expressions
• 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

Interfaces

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

Exceptions

• Understand exceptions
• Understand the effect of exceptions and the call stack
• Different types of exceptions
• Understand how exceptions to indicate 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

Optional

• 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