The Essential Kotlin Programming Course (Android Developers)

Install the Java Development Kit (JDK) and set up the Java path environment variable; download from Oracle, install with the wizard, and verify the setup with the Java C command.

Install IntelliJ IDEA to write Kotlin programs by downloading the community edition, choosing your OS, and following the wizard to install defaults, create shortcuts, bypass firewalls, and start Kotlin projects.

Explore essential Kotlin tools, including the Java to Kotlin converter in the IDE and online, and learn to use Kotlin extensions, Android extensions, and Anko wrappers to streamline Android development.

Create a new Kotlin project in IntelliJ IDEA, choose the Java or Android wizard, point to your Java installation, and explore import, open, and version-control options.

Explore the IntelliJ environment for Kotlin development by navigating menus, toolbars, and editors; configure project settings and code style, manage dependencies, and build, run, and debug projects.

Learn to create your first Kotlin program that prints hello world by writing a top-level main function, using a string literal, and running the build to see output.

Explore variations of hello world in Kotlin through a code-along, reading command line arguments via main, using string templates and an if statement to print arguments.

Organize code with packages using the package keyword and imports, grouping classes and top-level functions. Kotlin supports multiple classes per file, top-level declarations, and importing top-level functions by name.

Explore single-line and block comments, nested Kotlin comments, and best practices for file headers with author and date to describe code across languages.

Explore variables and data types in Kotlin, learn how to declare and assign values with var and val, and understand memory, types, and primitive vs object data.

Explore static typing and type inference in Kotlin, contrast declaration versus initialization, and examine compile-time checks that enable safe, efficient code with less verbose type declarations.

Compare Kotlin var and val to understand mutable versus immutable variables. Learn how to declare and initialize, and why var can be reassigned while val remains read-only.

Learn Kotlin’s basic data types, including long, int, short, byte, float, double, char, and boolean, how primitives become wrapper objects, use val, and perform literals and type conversions.

Build a Kotlin code along that computes and prints a rectangle’s area and perimeter, using val and var, type inference, and Java-style formatting in a main function.

Learn to build a Kotlin console program that converts minutes to years and days using data types, arithmetic, and type inference, with scanner input and string templates for output.

Explore Kotlin strings, including literals, read-only variables, indexing, and iteration. Learn to use string templates with interpolation, raw triple-quoted strings, and trim margin for multi-line text.

Learn how to work with strings in Kotlin by building a code along that uses starts with, string literals, and string templates, showing type inference and boolean results.

Explore Kotlin any and any? as the top-level super type for non-nullable values, mirroring Java's object, with toString, equals, and hashCode; use any? for nullable values.

The Kotlin unit type is the real counterpart to void, a full fledged type usable with generics and as a return value when a function returns nothing.

Explains the nothing type in Kotlin and how it differs from the unit type. Shows how nothing marks non-returning functions and supports precondition checks with the Elvis operator.

Explore smart casts and explicit casts in Kotlin, where the compiler auto-casts after is checks and the as operator, reducing boilerplate and enabling safer type use.

Demonstrate Kotlin's smart cast with the is operator to safely handle any type, and a get string length function that returns the string length or null.

Explore the Kotlin operators landscape, including arithmetic, comparison, and logical operators, with infix, prefix, and postfix styles, and learn about the Elvis operator, referential versus structural equality, and null safety.

Learn how Kotlin's in, index, invoke, and is operators work with collections, including contains checks and index access, and how range and smart cast improve code readability.

Explore how to use the in operator in for loops to iterate over the args array and print each command line argument in Kotlin, with a live code along demonstration.

Explore Kotlin's null safety with nullable types and compile-time checks, preventing null pointer exceptions. Master safe call, Elvis, and safe cast operators for robust code.

Explore Kotlin's safe call operator, '?', which enables calling methods on nullable values without explicit null checks, reducing boilerplate for properties and methods with clear examples.

Master the Elvis operator ?: in Kotlin to provide default values for nulls, using it with the safe call operator ?. to streamline null checks.

Master safe casting with the as? operator in Kotlin, preventing class cast exceptions by returning null when casts fail. Use the Elvis operator to handle nulls and explore nullable types.

Learn how the not null assertion converts a nullable type to a non-null type using the double exclamation point, enabling direct calls while risking a runtime exception if null.

Explore Kotlin null safety with a code-along that parses command line arguments to integers, guards against nulls, and prevents null pointer exceptions using safe calls, Elvis operator, and not-null assertions.

Explore Kotlin control flow, including conditional statements, loops, and branching with if, else, switch, break, and continue. Learn how Kotlin treats expressions vs statements to reduce boilerplate and improve readability.

Explore how Kotlin if expressions return values, letting you assign results to variables; use else branches, nesting, and blocks without ternary operators.

Explore the Kotlin when construct as a powerful switch alternative, usable as expression or statement, with or without arguments, exhaustiveness, smart casts, and ranges.

Follow a code-along to master the Kotlin when construct, using arguments and no-argument forms, type checks with is, and multiple and default cases for expressive matching.

Explore while and do-while loops in Kotlin, comparing them to Java, with post-test behavior, body execution at least once, and practical examples of counter and enumeration loops.

Explore ranges and progressions in Kotlin, using for loops, in and not in checks, and inclusive versus exclusive ends, with step, down to, and range over comparable types.

Explore how Kotlin handles for loops using ranges, in operator, and iterators; compare with traditional loops, nested loops, stepping, and exclusive end via until, and apply to collections and arrays.

Explore return, break, and continue control flow in Kotlin loops, including labeled breaks to outer loops, jumping from nested loops or functions, and returning from the nearest enclosing function.

Code along in Kotlin to build a guess the number game using a random secret number, a do-while loop, and if-else feedback.

Explore how Kotlin defines and calls functions using the fun keyword, with optional parameters, return types, and single expression forms using equals, including unit returns and member functions.

Explore top level functions, defined directly in a file outside any class, at the top, and use them as helper utilities, unlike Java methods, with Kotlin's require for parameter validation.

Explore member functions and local functions in Kotlin, showing how to call class methods with a dot, nest helpers inside functions, and use local scope to reduce duplication.

Enhance readability and maintainability by using named arguments to clearly indicate each parameter; limit functions to three parameters when possible, otherwise name all subsequent arguments to avoid confusion.

Explore how default parameters replace overloaded methods to reduce duplication in Kotlin and enable flexible calls with named arguments. See a divide function using defaults for divisor and rounding mode.

Explore infix calls and notation in Kotlin, showing how infix functions between an instance and a parameter enable concise, readable code for pairs, extensions, and class methods.

Explore Kotlin var args and the spread operator; learn how a function accepts a variable number of arguments, wrapped as an array, and how to pass them individually.

Master function overloading in Kotlin by exploring different parameter lists, how return type doesn’t count, and how overloading differs from overriding and static versus dynamic polymorphism.

Demonstrate method overloading in Kotlin by defining several add functions with different parameter types and counts. See how the compiler selects the appropriate overload based on inputs, illustrating compile-time polymorphism.

Explore extension functions in Kotlin, adding new functionality to existing classes without subclassing, via top-level or member extensions, using a receiver type, static dispatch, and imports.

Explore how the Kotlin standard library uses higher-order functions, lambdas, and extension functions to simplify collections, strings, and Java interop, with apply and with for clean initialization.

Explore kotlin standard library functions run, lazy, and use; see how run uses a receiver lambda, lazy defers expensive work, and use safely manages resources.

Explore Kotlin's repeat, require, assert, and check for formal specifications and contracts. Learn how they differ in exceptions, invocation, and runtime behavior, including lazy evaluation and input validation.