Kotlin Course

A Brief Overview Preview 05:12

Kotlin is an object-oriented languages with functional features as well. It facilitates many things, provides null safety and offers a concise and readable syntax.

Try It Out In 30 Seconds! Preview 01:04

On try.kotlinlang.org (check link in the resources), you can try out some sample applications and get to know the basics of Kotlin. It is a great playground for simple code snippets.

Downloading the JDK Preview 02:46

This lectures guides you through the process of downloading the latest Java Development Kit (JDK) we need to use Kotlin.

Downloading IntelliJ Preview 01:54

In this step, we download the free and powerful IntelliJ Community Edition from the Jetbrains website. This is an Integrated Development Environment (IDE) that provides awesome support for Kotlin, Java, and many other languages. It is also the IDE used by Google for Android App Development.

Setting up IntelliJ Preview 04:59

Learn how to adjust the editor theme and font size in IntelliJ to your personal preferences and how to create the first project.

Using Kotlin Interactively in REPL Preview 05:31

In this lecture, we use Kotlin interactively in the REPL (read-eval-print-loop) as a calculator, learn how to assign values and run some simple commands.

Variables Preview 04:01

This lecture covers how to create variables in Kotlin, when to use val vs. var and why you prefer val over var when creating variables to enforce immutability.

Variables

Primitive Types & Strings Preview 09:51

This lecture covers all basic types available in Kotlin plus strings to store text.

Basic types in Kotlin include Byte, Short, Int, Long, Float, Double, Boolean, and Char. This lecture guides you through each of them and their differences.

Variables and Data Types

Expressions vs. Statements Preview 05:41

Expressions are pieces of code that have a value, such as 4*(3+5) or listOf(1,2,3,4,5). We can assign the values of expressions to variables and the Kotlin REPL will print an expression's value right below it whenever we type in an expression.

Statements on the other hand don't carry a value, such as print("Hello there") or val a = 4. Assignments are a special type of statements because they also don't have a value.

Expressions vs. Statements

Check your understanding of the differences between expressions and statements.

Nullable Variables Preview 07:22

In contrast to languages like Java, Kotlin offers null safety through explicit nullable types!

Learn how to create nullable variables and why you should avoid this. You will also understand the advantages of having to make variables explicitly nullable to avoid NullPointerExceptions.

Nullables

Your First Stand-Alone App Preview 04:31

Now it's time to create our very first stand-alone Kotlin application!

You will create a simple "Hello World" app and be guided through the process of creating a main() function as the entry point to your application.

Conditional Statements Using "if" Preview 08:10

Learn how to use if statements for handling conditional program flow. So this concept lets you define different program behavior based on conditions you can define.

if Statements

Conditional Statements Using "when" Preview 03:40

This lecture covers the use of when statements to handle a fixed set of possible options.

In contrast to if statements, these do not allow arbitrary conditions and are commonly used to switch between a number of distinct cases based on the value of a variable.

when Statements

When to Use "if" vs "when" Preview 01:52

Learn when to use if statements vs. when statements.

If statements allow defining arbitrary conditions and are the most common choice to handle control flow. In some cases however, when statements express your intentions better. That is, when you want to switch application behavior based on some distinct values of a variable.

When statements can always be simulated by if statements.

Conditional Statements Using "if" and "when"

Conditional Expressions Preview 05:20

In Kotlin, we can use conditional statements as expressions with a value. In fact, every if or when statement is an expression in Kotlin and we can, for example, save its value into a variable.

The last expression in each block of an if or when expression defines the value of the whole if or when expression if that block is executed.

More Advanced "when" Constructs Preview 03:45

Inside when blocks, we can actually use more sophisticated expressions on the left side than just plain values. More specifically, Kotlin allows us to check for ranges, types, values of function calls and more on the left side of each condition in when constructs.

Advanced Conditionals

Coding Challenge: Conditionals Preview 1 page

Coding Challenge: Put your knowledge of conditionals into practice by generating random numbers and checking which range they fall into.

Arrays vs. Lists Preview 04:58

Learn about two super important data types of every programming languages: Arrays & Lists!

What are arrays? What are lists? This lecture goes through each of them and explains their differences and similarities. You will also learn when to use arrays vs. lists which is a question you find many people asking online.

Arrays in Kotlin Preview 06:25

Learn how to create, modify, and access arrays in Kotlin using the square bracket notation. This allows you to store multiple elements inside a single variable.

Later, we will also see how to loop over arrays to perform some tasks on each of its elements.

Lists in Kotlin Preview 06:21

This lecture guides you through the process of creating, modifying, and accessing lists in Kotlin. We will see that we can work with lists in a similar way as we do with arrays, but that there are also some differences to keep in mind.

Arrays and Lists in Kotlin

"for" Loops Preview 06:29

Learn how to use for loops in Kotlin to loop over an array/list or to repeat a certain block of code a certain number of time (when you know in advance how many iterations you will need).

"while" Loops Preview 03:52

Learn how to use while loops in Kotlin to repeat blocks of code, similar to for loops. But when using while loops, you don't need to know the number of iterations in advance. The while loop allows you to define arbitrary conditions which must be true for the loop to continue.

Loops Using "for" and "while"

Using "break" and "continue" Statements Preview 04:48

The break and continue statements allow you to completely skip over a loop or to skip to the next iteration, respectively. So with break, you can stop a loop and go on with execution right after it. Whereas with continue, you can skip to the next iteration of a loop to avoid unnecessary computation.

The break statement is useful, for example, when you are only interested in the first occurance of something. For instance, to check if an array contains a certain value, you just need to check until you find it. After finding that first occurance, you can skip the rest of the loop.

The continue statement is useful to skip computations in unnecessary iterations. For example, if you only want to do something with String of length > 2, you can skip iterations with a shorter string when you iterate over a list of strings.

Naming loops Preview 03:33

Learn how to use loop labels and then address them in break and continue statements. This allows you to break or continue an outer loop when inside a nested loop.

Using break, continue and return

Coding Challenge: Using Loops Preview 1 page

What's the sum of all numbers from 100 to 100,000?

Congratulations! Preview 04:03

Congratulations! By making it this far, you are already ahead of 90% of the other students. Keep going!

All The Basics (Recap What You've Learned!)

Recap of all topics covered so far, including variables, data types, nullable types, conditionals, arrays, lists, and loops.

Coding Challenge: Loops, Lists and Conditionals Preview 1 page

Another programming task for you to practice what you learned.

Keep going! The best topics are still to come!

Functions Preview 10:32

This lecture teaches you one of the most important concepts that applies not only to Kotlin but all other programming languages as well: creating and using functions!

Functions are self-contained pieces of code that can take in parameters and may return a value. Parameters allow passing in information into the function when calling it, so that the function can then work with that data and perform computations on it.

Functions

Code Along: Reversing A List Preview 07:52

Let's see how to reverse a list using a loop. This is a functionality that often comes in handy when working with ordered collections like lists and arrays.

This code along gives you some more intuition on how to work with loops if you've never worked with them before. It also helps you internalize how to write loops in Kotlin. And of course, it's guides you into what a programmer does all day: implementing algorithms. Reversing an ordered collection is great little algorithm to start with.

Starting with Object-Orientation Preview 07:11

Object-orientation is the most widely used software development paradigm. Popular programming languages are mostly focused on object-oriented development, including Java, Python, C++, C#, PHP, and Swift.

This lecture explains all the major elements of object-orientation: classes, objects, interfaces, data, and methods. It also goes through the concept of creating an abstraction of the real world by modeling objects.

The Basics of Object-Orientation

Your First Class Preview 04:20

Let's create our first class in Kotlin!

This lectures guides you through creating basic classes, adding properties to classes, creating objects from it and accessing its properties. Classes are like blueprints from which we can create objects and they contain properties and methods. The next lecture will cover methods.

Methods Preview 06:49

While properties define what data a class holds, methods define functionality and can execute.

This lecture teaches you how to add methods to classes, which are essentially just functions inside a class. We can then call those methods on our class.

Properties and Methods

Constructors Preview 06:49

Learn how to define basic constructors in Kotlin to define how exactly objects are supposed to be created from a class. Parameters can be added to the constructor to add properties to the class and define what information/data an object needs to be instantiated.

Object Creation

Coding Challenge: Classes Preview 1 page

Named Parameters & Default Values Preview 05:40

This lecture covers how to use named parameters and default values for function and constructor calls. This is super handy to make the code more readable and also allows you to change to order of the parameters when calling the constructor or function.

Named Parameters & Default Values

Open Classes and Inheritance Preview 10:20

Learn how and when to use open classes in Kotlin to allow inheritance. This also includes how to extend classes, implement interfaces, and how to override methods and properties

Open Classes and Inheritance

Abstract Classes Preview 06:04

Learn how and when to use the "abstract" keyword in Kotlin, what exactly abstract classes are and when you should use them.

Abstract Classes

Open vs. Abstract Preview 04:02

You can use the open keyword to allow inheriting from a class or overriding a property/method vs. the abstract keyword to require inheriting and overriding.

Open vs. Abstract

Interfaces Preview 08:57

Interfaces are like contracts that classes may adhere to (meaning they implement that interface). This lecture explains...

• how you can create interfaces,
• what constraints there are in interfaces,
• the importance of interfaces in object-oriented programming,
• and the differences compared to classes.

Interfaces

Object-Orientation - Part I

Overriding Rules Preview 10:02

Learn how to handle overriding in Kotlin. This lecture covers some of the special cases that you may come across and the overriding rules involved. This includes required vs. optional overriding and handling name clashes from two supertypes

Overriding

Data Classes Preview 11:21

Learn how to create data classes! This is a really handy feature in Kotlin that takes a lot of work from your shoulders.

Data classes automatically override methods such as toString() so that they can be printed to the console in a readable way. Learn about all the cool features of data classes in this lecture.

Data Classes

Coding Challenge: Putting It All Together! Preview 1 page

Put what you learned into practice by creating interfaces, abstract classes, and concrete classes for a sample library inventory system.

Objects / Singletons Preview 04:12

Singletons are classes of which at most one instance can exist at runtime.

In software design, you often come across classes for which you only need or want one object at runtime. Imagine for example a Cache class -- in many cases, you only want (at most) one cache object to exist.

This can even prevent errors resulting from working with another object than you wanted.

Basic Enums Preview 09:40

Enumerations, simply called enums, are a great way to design classes of which only a defined finite set of instances are possible. In this case, those possible instances are simply listed ("enumerated") explicitly in the code.

This also means that there can be no other objects of the enum class than these at runtime -- there is no constructor available.

Basic Enums

Recap the basics of enum classes.

Packages Preview 06:24

Packages are used to structure your code into logical units. Thereby, they also define boundaries between the classes in the different packages which can be exploited for information hiding (see later lectures).

Classes that perform similar tasks should be grouped into a package. Such classes from the same package may rely a lot on each other. However, classes from different packages should have less dependencies (e.g. calling a methods from classes from different packages).

Grouping classes into packages is an important sub-task of software design.

Packages

Recap of the basic concepts of packages.

Imports Preview 09:09

Imports allow to make classes from other packages accessible inside your class.

Therefore, imports are what allow you to access decades of work, research, and knowledge from developers around the world by using, among many others, the Java and Kotlin standard libraries.

In Kotlin, you can import a whole package (non-recursive), classes, top-level functions, enum instances, and methods declared in objects.

Imports

Check what you learned about import statements!

Hexadecimal Numbers & The Color Enum Preview 11:25

Hexadecimal Numbers

Test what you learned about hex numbers!

Binary Numbers & The Color Enum Preview 13:13

Binary Numbers

Strengthen your knowledge about the binary number system!

Bitwise Operators Preview 07:35

The Principle of Information Hiding Preview 03:55

Information hiding is a fundamental principle in object-oriented software design that increases the reusability, maintainability, and robustness of your code.

The basic idea is to restrict access to the internals of a class from the outside. That way, users of your class can also use it via a well-defined interface, meaning that you can enforce invariants in your code more effectively.

Information Hiding

Properties II: Getters and Setters Preview 09:23

In Kotlin, you declare properties as members of a class via val/var -- in contrast to Java, where fields are used.

With properties, there are implicit getters and setters that are called whenever the property is accessed or updated. This can greatly enhance maintainability and extensibility of the code.

Quiz: Getters and Setters

Visibilities Preview 10:09

Visibilities are the way to implement information hiding in object-oriented languages like Kotlin, Java, Scala, Swift etc.

The visibility of a class, property or method defines from where it will be visible/accessible, including which kinds of other classes have access to that element.

Kotlin has the following visibility modifiers:

1. private
2. protected
3. internal
4. public (default)

Quiz: Visibilities

Generics Preview 06:34

Generics are a more advanced concept of OO design which help you avoid code duplication for groups of similar classes, especially collection classes (such as Array, List, Map etc.)

In contrast to a non-generic class, a generic class is parametrized with one or more generic type parameters which can be defined when instantiating an object of the class. For example, Kotlin's built-in generic class Array<T> (read "array of T") can be instantiated as an Array<Int>, an Array<Person>, etc.

Quiz: Generics

A Generic Stack Preview 09:54

In this lecture, we finish implementing our first real data type -- a generic Stack type which allows the push() and pop() operations.

Thanks to the genericity, we can instantiate a Stack<Double>, a Stack<Card>, etc. without implementing more than one Stack class.

Generic Functions Preview 06:48

In addition to generic classes, you can also use generic functions in order to avoid code duplication (remember the DRY principle!).

Here, we implement a generic stackOf() function that behaves similar to Kotlin's built-in arrayOf() and listOf() functions. It's a simple helper function to create a stack of some elements.

Quiz: Generics II

Introduction to I/O Preview 02:51

A Little Console Game Preview 07:50

Code Along: Hangman Game - Part I Preview 11:35

Code Along: Hangman Game - Part II Preview 09:08

Reading From a File Preview 04:22

Challenge Preparation: Maps Preview 11:27

Challenge: Find the Most Frequent IP Address Preview 01:10

Challenge Solution: Find the Most Frequent IP Address Preview 12:04

Bonus: Reach Your Full Potential As A Software Developer Preview 00:15