Full 2025 Kotlin Crash Course For Beginners

Main ideas and lessons

• Course purpose & scope

  • A beginner-focused Kotlin crash course aimed at:
    • People with no programming experience
    • People with experience in other languages who want to learn Kotlin
  • The instructor aims to cover ~80–90% of Kotlin language features.
  • Remaining features are either:
    • rarely needed, or
    • advanced and better learned later.
  • Mentions a separate (older) Kotlin playlist for deeper coverage.

• Why Kotlin (as presented)

  • Interoperability with Java
    • Kotlin compiles to bytecode compatible with Java.
    • Kotlin and Java code can be mixed in the same project.
  • “Syntactical sugar”
    • Kotlin provides shortcuts that reduce boilerplate.
  • Versatility
    • Native Android development (main focus).
    • Kotlin Multiplatform (build for multiple targets from one codebase).
    • Backend options
      • Mentions Kotlin backend framework Ktor (less common/less mature).
      • Also mentions Spring Boot as the more established Java backend framework.

• Setting up the development environment

  • Use IntelliJ IDEA (JetBrains IDE):
    • Download paid “Ultimate” or free Community edition.
  • Create a new Kotlin project using templates.
  • Key project files/folders:
    • build.gradle.kts (Gradle/build settings, including Kotlin version)
    • src/ and especially src/main/ for source code
  • Create a Kotlin file like Main.kt containing fun main().

---

Methodology / step-by-step instructions presented

1) Create and run your first Kotlin program

• Install IntelliJ IDEA
• Create a new Kotlin project
• Choose:
  • Project name (e.g., “Kotlin Crash Course”)
  • Build system: Gradle
  • JDK version: choose any suitable version
• Create Main.kt with:
  • fun main() { ... }
• Print output using:
  • println("Hello World!")
• Run using the IDE run button/play arrow
• Confirm console output appears (e.g., “Hello World!”)

2) Learn core language concepts through small examples

• Use println(...) to output results to the console.
• Define variables:
  • val = immutable (cannot be reassigned)
  • var = mutable (can be reassigned)
• Use type inference:
  • Kotlin often infers the type from the assigned value.
• Use primitive types:
  • Int, Float, Double, Boolean, String
• Use operators and interpret results:
  • Arithmetic: + - * / %
    • Integer division truncates/rounds down.
  • Increment/decrement shortcuts:
    • x++, x-- (not allowed if x is val)
  • Compound assignment:
    • +=, -=, *=, /=
  • Comparison: == != > < >= <=
    • Comparison results are Boolean.
  • Logical:
    • && (AND), || (OR)

3) Handle user input safely (nullability & parsing)

• Read user input:
  • readLine() returns a String? (nullable)
• Convert string to integer safely:
  • input.toInt() can throw NumberFormatException for invalid strings.
• Use null-safety operators to avoid crashes:
  • toIntOrNull() returns Int? instead of throwing:
    • valid number => Int
    • invalid number => null
• Example pattern for safe use:
  • Use if (inputAsInt != null) { ... } before doing arithmetic/comparison.
• Mention operators and their roles:
  • ?: (Elvis) to provide default values when null occurs
  • !! (assert non-null) discouraged because it can crash
  • ?. (safe call) to only call functions if value is not null
• If parsing may throw, use exception handling:
  • try { ... } catch (e: NumberFormatException) { ... }

4) Use collection types and control flow

• Arrays:
  • Fixed size, indexed from 0
  • Out-of-bounds access throws an exception
  • Safer access: getOrNull(index) returning nullable
  • Bounds checks including negative indices
  • Adding to arrays creates a new array instance (array size immutable)
• Lists:
  • Prefer mutable lists when the size changes dynamically
  • Use add(...) to append
• Loops:
  • while loop when the number of iterations depends on a condition:
    • controlled by a counter variable
    • with continue to re-ask input on invalid values
  • break to exit early
  • for loop when iterating over a range/list:
    • iterate from 0 until amount
  • Demonstrates iterating:
    • lists
    • strings (string is iterable over characters)
    • reversing strings by iterating from end to start
• Demonstrate functional iteration:
  • for (char in input) { ... }

5) Functions and reuse

• Define a function:
  • fun reversed(s: String): String { ... }
• Use return for returning values.
• Demonstrate calling functions multiple times.
• Mention:
  • return types
  • parameters and type annotations
  • default parameter values
  • named parameters for readability
• Function overloading:
  • Provide reverse(...) implementations for different parameter types (e.g., String vs Int)
  • Overloading requires different signatures/types.

6) Extension functions (Kotlin-specific convenience)

• Define an extension function:
  • e.g., fun String.reversedCustom(): String
• Use it like a method on the type:
  • "hello".reversedCustom()
• Inside extension functions, this refers to the receiver object (the thing extended).

7) Lambdas and higher-order functions

• Use standard library functions requiring lambdas:
  • filter { predicate }
  • map { transform }
• Lambda syntax patterns:
  • it (single-parameter shorthand)
  • named parameters when multiple parameters exist
• Write your own function taking a lambda:
  • predicate typed as: (Character) -> Boolean
• Demonstrate buildString { ... } and the idea that lambdas can be used to build outputs.

---

Control-flow and safety concepts covered in depth

Operator precedence in boolean logic (important behavior)

• && (AND) has higher precedence than || (OR).
• The compiler may short-circuit:
  • if left side already determines result, it avoids evaluating the right side.

Nullability as a central Kotlin feature

• Nullable types: Int?, String?
• Null-safety tools:
  • toIntOrNull() to avoid exceptions
  • ?., ?:, !! (with warnings about !!)
  • Use if (x != null) { ... } to establish non-null within a block.

---

Classes, interfaces, and architecture concepts

Classes and instances

• class Rectangle(val width: Int, val height: Int)
• Instances created with constructors:
  • val r1 = Rectangle(5, 7)
• Access properties:
  • r1.width, r1.height
• Add derived properties:
  • diagonal computed from width and height

Data classes (value-based behavior)

• Use data class when:
  • class is mainly data
• Key benefits:
  • equality compares by fields, not reference
  • readable toString()
  • copy() function for cloning with modifications

Interfaces (contracts)

• Define interface Shape:
  • properties like area, circumference
• Implement in classes (e.g., rectangle and circle)
• Use override and getters when needed for computed properties.

Abstract classes vs interfaces

• Abstract class
  • can have normal functionality + internal state
  • cannot be instantiated directly
  • used when shared behavior/state is needed.
• Interface
  • contract style; usually no shared state
  • in this course’s shape example, interface fits because each shape computes area/circumference independently.

Sealed interfaces/classes (exhaustive branching)

• Makes when expressions exhaustive without needing an else.
• Used for modeling a closed set of possible subtypes in your code/module.

Enum classes (finite constant sets)

• Enum values are known at compile time.
• Useful when options are constant, like countries or fixed UI choices.
• Supports:
  • entries iteration
  • when exhaustive matching
• Instructor contrasts:
  • Use enum when you truly have a limited set of constant instances
  • Use sealed types when you have a closed set but with potentially parameterized instances (e.g., circles with varying radius).

Objects / singletons

• object FixedSizeSquare : Shape { ... }
• No constructor; only one instance exists.
• Also used to group utility functions (e.g., a DateUtil-style object).
• Mentions “data objects” as a related concept.

Visibility modifiers

• Default is public
• Use private to restrict access to inside the class
• Use protected for access within a class hierarchy
• Mentions internal as module-level scope (less needed for beginners).

---

Generics (type-parameterized code)

• Generic functions:
  • Example idea: filtering a list for elements of arbitrary type T.
  • Predicate and result types depend on T.
• Generic classes:
  • Example “Result”-like sealed structure:
    • Success<T> carries data of type T
    • Failure<E> carries error of type E
• Mentions real-world usefulness in Android/networking and transformations like map.

---

Ending / how to proceed (recommended learning path)

• Practice with:
  • the creator’s additional Kotlin practice playlist (with homework)
  • coding challenge sites like Codewars
• Then specialize:
  • Native Android development
  • Backend development (Ktor or Spring Boot)

---

Speakers / sources featured

1. Philip (instructor; host of the crash course channel)
2. JetBrains (source organization mentioned for IntelliJ IDEA and Kotlin’s creators)
3. Java (as a platform and interoperability target; also mentioned as the bytecode ecosystem)