Build Spring Boot Apps with the Kotlin Programming Language

Course Curriculum

Chapter 1: Chapter 1 – Introduction

Lecture 1: What is Kotlin

Lecture 2: Configuring and installing IntelliJ

Lecture 3: How to get support while you're taking this course

Chapter 2: Chapter 2 – Working with Strings

Lecture 1: Creating a new project in Kotlin

Lecture 2: Creating a Kotlin hello world project – just to check everything is working

Lecture 3: The syntax of declaring a variable – the var and val keywords

Lecture 4: Inferring variable types

Lecture 5: Using String templates

Lecture 6: Creating a string with multiple lines

Chapter 3: Chapter 3 – Other variable types

Lecture 1: Using the Double data type, and determining class types in Kotlin

Lecture 2: The Int data type

Lecture 3: Other data types

Lecture 4: Casting from one data type to another – the Java version

Lecture 5: Casting from one data type to another – the Kotlin version

Lecture 6: Chapter review – what we have learned in this chapter

Chapter 4: Chapter 4 – Nullable variables

Lecture 1: Creating variables that can contain the value null

Lecture 2: Running methods which work with nullable variables

Lecture 3: The null-safe operator

Lecture 4: The non-null asserted operator

Lecture 5: The nothing object type

Chapter 5: Chapter 5 – Functions

Lecture 1: The function syntax, and the Unit object

Lecture 2: Creating and calling top level functions

Lecture 3: Single expression functions

Lecture 4: Using named parameters when calling functions

Lecture 5: Using optional parameters in functions

Lecture 6: Parameter attributes are always immutable

Lecture 7: Functions within a function

Lecture 8: Functions that take a lambda parameter

Chapter 6: Chapter 6 – Classes

Lecture 1: Project structure and packages

Lecture 2: The class declaration, and adding attributes

Lecture 3: Instantiating a class, and accessing the class attributes

Lecture 4: Creating a simple constructor

Lecture 5: Adding secondary constructors to a class

Lecture 6: Alternative class design

Lecture 7: Overriding getters and setters

Lecture 8: Creating a dummy variable get method

Lecture 9: Functions within a class

Lecture 10: Overriding functions

Lecture 11: Creating static functions

Lecture 12: Data classes

Lecture 13: Destructuring and ComponentN functions

Chapter 7: Chapter 7 – Practical Exercise 1

Lecture 1: The challenge – explaining the Java code

Lecture 2: Solution walkthrough

Chapter 8: Chapter 8 – The IF expression and object equality

Lecture 1: The if keyword as an expression in kotlin

Lecture 2: Assigning a variable using an if expression

Lecture 3: Assigning values using if to do a null-safe check

Lecture 4: The Elvis operator

Lecture 5: Using the Elvis operator to overcome null-safe check smart cast compiler warning

Lecture 6: The let function

Lecture 7: Object equality

Lecture 8: The when expression

Chapter 9: Chapter 9 – Ranges and Looping

Lecture 1: The while loop

Lecture 2: Using for to loop through a collection

Lecture 3: Destructuring with a for loop

Lecture 4: Looping with the Range object

Lecture 5: Creating different types of ranges

Chapter 10: Chapter 10 – Collections

Lecture 1: Mutable arrays with immutable variable assignments

Lecture 2: Creating an immutable list

Lecture 3: Creating a mutable list

Lecture 4: Creating maps and sets

Lecture 5: Working with Arrays in Kotlin

Chapter 11: Chapter 11 – Practical Exercise 2

Lecture 1: The challenge – explaining the requirements

Lecture 2: Solution walkthrough

Chapter 12: Chapter 12 – Exceptions and Try Catch Blocks

Lecture 1: All exceptions in Kotlin are unchecked

Lecture 2: Throwing exceptions

Lecture 3: Try as an expression

Lecture 4: Using the use expression to ensure resoruces are always closed

Chapter 13: Chapter 13 – Testing

Lecture 1: Using Junit with Kotlin

Lecture 2: The Kotlin test assertions

Lecture 3: Testing for exceptions

Chapter 14: Chapter 14 – Interfaces and Extending classes

Lecture 1: Creating and implementing Interfaces

Lecture 2: Class inheritance

Lecture 3: Inheriting from classes with constructors

Lecture 4: Implementing multiple interfaces

Lecture 5: Creating custom exceptions

Lecture 6: Adding functions to existing classes (extension functions)

Chapter 15: Chapter 15 – Java Interoperability

Lecture 1: Providing values to non-nullable variables

Lecture 2: Using data classes

Lecture 3: Using immutable lists

Lecture 4: Exception handling

Lecture 5: Using static functions

Lecture 6: Importing a Kotlin jar into a Java project

Chapter 16: Chapter 16 – Getting started with Spring Boot

Lecture 1: Creating the project using the Spring Initializer

Lecture 2: A hello world controller