The Complete Kotlin Course - Mastering Kotlin from Zero

Discover how Kotlin constants work using val, with integers, doubles, and floats, and learn immutability, precision, and when to use top-level compile time constants.

learn how to use variables to hold changing data, distinguish constants from variables, and adopt meaningful names like person age or number of students to keep code readable.

Explore how Kotlin handles type conversion between numbers, showing when assigning double to int causes errors, how to perform explicit casting, and how to inspect inferred types.

Explore Kotlin's primitive and numeric types, how Kotlin abstracts primitive vs object types, and how byte, short, int, long, float, and double behave with storage, range, and precision.

Explore the Kotlin char type by declaring single-quoted variables and printing, noting that chars are not numbers in Kotlin, unlike Java, and learn the boolean type with true or false.

Explore Kotlin strings by learning string literals, variables and constants, and type inference, then master concatenation with plus and string templates to build and print dynamic messages.

Master Kotlin basics by learning how to model two- and three-value data with Pair and Triple, create coordinates in 2D and 3D, use type inference, and access values with dot notation.

Master Kotlin triples to represent 3D coordinates by creating and printing Triple values, choosing val or var, and destructuring into x, y, z for practical access.

Explore Kotlin keywords any, unit, and nothing, covering any as the mother of all other types, unit as a void-like return, and nothing as a non-terminating computation.

Learn to use Kotlin boolean values and comparison operators to control program flow, including equality, not equal, not, and comparisons for greater than and less than.

Explore how to combine conditions in Kotlin using and or, and evaluate boolean expressions and their true/false outcomes through examples.

Determine if two strings are equal using equality operators, then compare strings for order with less than and greater than. Use logic operators to drive conditionals.

master conditional flow in Kotlin by using if expressions, evaluating conditions, executing code blocks, and handling else and else if branches with value-returning behavior.

Explore Kotlin conditional expressions to compute the minimum and maximum of two numbers using if expressions that return values, enabling concise one-line assignments for min and max.

Master the while loop in Kotlin by seeing how a block repeats while a condition stays true, with an iterative example that grows x as old x doubles plus one.

Learn the do-while loop, a variant of the while loop where the condition is checked after the loop body, guaranteeing at least one execution.

Learn how to break from a loop using the break statement to exit a while loop, prevent infinite loops, and continue with code after the loop.

Explore boolean expressions by evaluating four constants with and/or/not, simplify expressions, and verify true or false outcomes in Kotlin, including how to print the results.

Discover how to control program flow with ranges in Kotlin, including closed ranges, half-open ranges with until, and decreasing ranges using downTo, all within for loops.

Master for loops in Kotlin by iterating over closed and half-open ranges, using a loop variable and range syntax to accumulate sums and print results.

Explore Kotlin loops using repeat and downTo, compare with for loops, control iteration with ranges and steps, create odd-number sequences and countdown loops.

Master nested loops in Kotlin by using an outer row loop and an inner column loop to print a four by four stars table and prepare for a multiplication table.

Print a 5x5 multiplication table using nested for loops in Kotlin, iterating rows and columns from one to five and accumulating and printing each cell's product.

Master Kotlin loop control by using the continue statement to skip iterations, including in nested loops, with parity checks and for and while loops.

Learn how the Kotlin when expression controls flow by matching values with arrow syntax, handling zero and non-zero cases, multiple names, and no break statements, like a modern switch.

Explore how the when expression returns values in Kotlin, using multiple branches to compute numbers, assign names, and print results in a practical example.

Write a Kotlin program to assess a 3D point and identify whether it lies on the xy, xz, or yz plane or is an ordinary point.

Explore functions in Kotlin, declare a function with fun, define a main function, and call your function to print a welcome message, avoiding code duplication.

Master kotlin by building and calling parameterized functions that tailor welcome messages using named and multiple parameters, such as a user name and a rating.

Learn how to declare function return types in Kotlin, use the return keyword to return values like x times y, and ensure type matches to avoid compile-time errors.

Learn function overloading in Kotlin by using the same function name for different parameter types and counts, letting the compiler pick the right one for int, string, or two integers.

Learn how to treat functions as values by assigning them to variables, creating function variables with two integer parameters, using method reference operator, and passing function variables to other functions.

explore kotlin's nullability with a box analogy, distinguishing non-null values from nullable types and showing how to represent absence with null and none in variable examples.

Explore Kotlin's nullability by using the not-null assertion operator (the double exclamation mark) to extract the value from a nullable box and understand runtime null pointer exceptions and smart casts.

Master Kotlin's nullability with safe checks and smart casts to use variables only when they contain a value. Avoid null reference errors by applying not-null assertions only when guaranteed.

Explore the Elvis operator in Kotlin to extract a result and fall back to a default value when input is null, illustrated through practical examples.

Explore arrays in kotlin as ordered, zero-based collections of the same type, created with ArrayOf and guarded by type safety on the JVM.

Explore lists in Kotlin, compare them to arrays, and learn to create mutable and immutable lists with listOf, mutableListOf, including type inference and empty lists.

Explore Kotlin from zero by accessing elements in arrays and lists using properties and methods, including is empty checks, size, first, last, and indexing, with immutable and mutable lists.

Learn indexing and slicing in Kotlin by using square-bracket indexing on lists, understand zero-based indices, access elements with get, and slice ranges to retrieve multiple items.

Use the in operator to test for an element in an array or mutable list, and write a function that checks a name within it (aware of case sensitivity).

Learn how to append elements to arrays in Kotlin by using mutable lists, the add function, and the plus-equals operator, including end-of-list insertion and indexed insertion.

Learn how to insert elements at a specific index in Kotlin lists, inserting between existing items or appending to the end, across arrays and other collections.

Remove elements from a mutable list in Kotlin by value or by index, using the remove and remove at methods, and interpret the boolean result to confirm successful deletion.

Modify and manage Kotlin lists by updating elements at a specific index, handling insertions and removals, and sorting with sort to ensure alphabetical ordering.

Learn to iterate through a list in Kotlin using the for each loop, treating each list element as a user and printing its value.

Learn how maps store unique keys with corresponding values in Kotlin, compare maps to arrays, and create mutable and immutable maps with mapOf, adding and accessing entries by key.

Access map elements by key or through the get function, learning how to retrieve values using square brackets and the map's properties like isEmpty and size.

Explore adding elements to a mutable (dynamic) map in Kotlin by inserting key-value pairs with put or subscript, illustrated with a student map example.

Update a map’s value by assigning a value to a key, as shown when Jack changes from 19 to 14. Remove elements with the map’s remove method using the key.

Learn to iterate through maps in Kotlin using a for-in loop with destructuring to access key and value, or iterate over keys or values separately, and print results.

Learn how sets in Kotlin represent an unordered collection of unique values, automatically removing duplicates. Create sets with setOf, convert arrays using the spread operator, and grasp immutable setOf creation.

Access and manage sets in kotlin by using contains and in to check elements, then add or remove items with a mutable set, noting that immutable sets disallow changes.

Explore lambdas, anonymous functions that you assign to variables or pass as arguments, using arrow syntax and type annotations to implement a multiply lambda.

Learn how Kotlin shortens lambda syntax using type inference, omitting explicit types, and using the single-parameter it and the it keyword to create concise expressions.

Leverage lambdas to implement custom sorting of a collection in Kotlin, using a lambda-based comparator to sort strings alphabetically and by length.

Iterate over Kotlin collections with lambdas, applying forEach, filter, and map to transform and print elements, including squaring numbers and filtering values above 10.

Explore object oriented programming in Kotlin by defining a class with properties and methods, using a primary constructor, and creating class instances such as a person with a full name.

Understand how class instances are reference types in Kotlin, how variables hold references to memory on the stack and heap, and how the same reference points to the same object.

Build a Kotlin grade model and a student model with a mutable grades list, tracking subject letters, points, and credits; use a recordGrade function to add grades and update credits.

Explore how the Kotlin object keyword implements the singleton pattern. Build an in-memory student registry with a mutable and immutable list and add, remove, and print functions.

Explore how Kotlin uses a companion object to implement static-like members and a private constructor for auto-incremented ids across all student instances.

Master Kotlin properties in classes and objects, learn primary constructor properties, getters and setters, and mutability with val and var, illustrated by car and contact examples using dot notation.

Demonstrate how to set default property values in Kotlin for a contact class, using a relation such as friend, with a constructor for full name and email and later overrides.

Initialize Kotlin properties outside the primary constructor and in init blocks to build a full name by concatenating first and last names, while validating defaults for address properties.

Learn how to implement a custom getter in Kotlin to compute a TV's diagonal from width and height using the Pythagoras theorem, returning a computed integer diagonal via dot notation.

Master custom setters in Kotlin by showing how a read-write property uses a setter to compute height and width from a diagonal input with a ratio.

Master lazy properties in Kotlin by using by lazy to defer heavy calculations, such as computing pi for a circle's circumference until first access.

Learn how inheritance creates superclass and subclass relationships in Kotlin, using a person base class and a student subclass to share first name, last name, and grades.

Explore polymorphism by treating a student as a person and a person as a student, using inheritance to access the full name from the superclass.

Subclasses extend a super class by adding new properties and methods and can override inherited methods with override and super to customize behavior, such as a student's full name.

Learn how abstract classes in Kotlin prevent instantiation while enabling inheritance, including overriding abstract methods like consume food in subclasses such as mammals, humans, and cats.

Learn how sealed classes in Kotlin enforce a strict type hierarchy, using a shape sealed class with circle and square subtypes that define radius or side length.

Explore Kotlin visibility modifiers—public, private, protected, and internal—defaulting to public; learn how to restrict access in classes and across hierarchies with practical examples.

Explore interfaces as state-free blueprints of behavior with default implementations, requiring concrete types to implement accelerate and stop, as shown by a Bicycle implementing Vehicle.

Explore kotlin generics to centralize code, reduce bugs, and apply actions to any type using type parameters like t and standard library collections.

Explore why generics matter for type safety in Kotlin lists, learn how type inference and compile-time errors prevent wrong inputs, and see how any enables flexibility in mutable lists.