Gain insights into Kotlin’s basics, including variable declarations, data types, conditions, loops, and functions. Discover how to write simple Kotlin scripts and transition to advanced programming.

Kotlin is quickly joining the ranks of the most popular programming languages. Now that Google supports Kotlin for Android app development as the primary choice over Java, we’ll only see more developers making the switch. So if you’re looking to get started with Android app development, then you’ve come to the right place.

This course will be your guide on getting started with Kotlin. We’ll go over all the language basics including variable declarations, data types and the type system to conditions, loops, and functions.

After this course, you’ll be able to write simple Kotlin scripts and applications. With this solid understanding of the language basics, you’ll be able to more easily follow more advanced material covering functional and object-oriented programming.

Homam B.

What a brilliant course, its not too long so its fairly easy to get through in a weekend. Goes through the fundimentals of Kotlin in just the right amount of detail. I would recommend this as a first step into Kotlin language

"Brilliant course"

Patricio M.

I have completed the course and I have to say that it's extremely well done

The examples used are clear and easy to follow

The code is very clean and the instructor strives to write clear and concise code and he explains concepts very clearly

Kudos for a job well done!

"Extremely well done"

Alan J.

Clear explanations, and well organized. Highly recommended.

"Highly recommended"

Raphael A.

Excellent course. It's a beginner course in programming, but even as a Java programmer I've been able to remember a lot of things and get productive quickly in Kotlin. The course is well structured and the teacher knows the subject (I bought another course from the teacher).

"Excellent course"

Kotlin Crash Course for Programmers

In Kotlin, you can define default values for function parameters to make them optional.

# Default Parameter Values

Let's say you have a function that joins a collection of strings into a single string:

fun join(strings: Collection<String>, delimiter: String) = strings.joinToString(delimiter)

For instance, ``join(listOf("Kotlin", "Java"), " > ")`` would return ``"Kotlin > Java"``.

With this function definition, you always have to pass in a `delimiter`. But most commonly, you'll want to have a comma as delimiter, so it makes sense to set this as the default value:

fun join(strings: Collection<String>, delimiter: String = ", ") = strings.joinToString(delimiter)

Default values are defined by simply adding an assignment to the parameter definition. This way, you now have different ways to call this function:

fun join(strings: Collection<String>, delimiter: String = ", ") = strings.joinToString(delimiter)

fun main() {
  val planets = listOf("Saturn", "Jupiter", "Earth", "Uranus")

  val joined1 = join(planets, " - ")
  val joined2 = join(planets)

  println(joined1)
  println(joined2)
}

You're still free to use a custom delimiter by passing in a value, but you can now omit the delimiter to simplify the function call. Think of these as **optional parameters** that can majorly increase the flexibility of your functions (i.e., of your [API](https://en.wikipedia.org/wiki/Application_programming_interface)).

Kotlin's own `joinToString` function makes heavy use of default values because it's a prime example for their usability. You *can* pass in a delimiter, prefix, postfix, a transformation and more. But you can also call it with any subset of these or without any arguments.

> **Note:** Although the Kotlin compiler *could* infer the type of the `delimiter` parameter from the default value, you are required to define the type explicitly. This is because function signatures define an API that must be well-defined and that you should have put thought into (e.g., using an abstract type like `Collection` or `Iterable` instead of `List` to increase the function's flexibility).

## Named Parameters

Using named parameters, there are even more ways you can call the `join` function:

Discover how to use default parameter values to increase the flexibility of your functions and how to call functions using named parameters.

Hello Kotlin!

Variables and Data Types

Conditions

Collections

Loops

Functions

Equality Checks

Exception Handling

Summary

Default Values & Named Parameters

Default Parameter Values #