# Programming in Kotlin: Fundamentals

Apr 14 2020 · Video Course (4 hrs, 6 mins) · Beginner

Learn the fundamental building blocks of Kotlin, through hands-on exercises and challenges! Explore the world of data types, comparison and logical operators, loops, control flow, functions, classes as custom types, and more.

4.9/5 10 Ratings

#### Version

• Kotlin 1.3, IntelliJ IDEA 2019.3

## Use Data Types & Operations

#### Introduction

4:00 Free

Welcome to Programming in Kotlin: Fundamentals! Get an overview of the course, and what topics you'll cover in the first part.

1

#### Set Up IntelliJ IDEA

11:31

Set up the IDE you'll be using throughout the course, and start working with variables, constants, basic data types and comments.

2

#### Use Booleans & Comparison Operators

10:03

Learn about the Boolean type which represents a true or false value, and how to create it using comparison operators.

3

#### Challenge: Booleans

2:21

Challenge time! Practice comparing values in order to create Boolean values, which can be true or false, then print out those values.

4

#### Combine Logical Operators

8:32

Learn how to use multiple Boolean values with logical operators, to combine and create complex conditions.

5

#### Branch With If Expressions & Scopes

7:39

Branch out your code, to have multiple different execution flows, using if/else expressions and create code scopes.

6

#### Challenge: If Expressions & Boolean Logic

3:34

Practice what you've learned about if/else expressions, Boolean values, and logical operators.

7

#### Create & Consume Nullables

11:03

Sometimes values don't exist! Prepare for such cases by learning about Nullable Types and how to handle them.

8

#### Challenge: Nullables

3:34

Practice dealing with Nullable Types and null, using the safe call operator, the Elvis operator, and null-checks.

9

#### Conclusion

3:46

Review what you've learned in the first part of the course, and repeat all the concepts by solving a fun challenge.

10

## Store Data In Collections

#### Introduction

3:01

In this part of the course, you'll learn how to store data in collections. Let's get started!

11

#### Combine Data In Pairs & Triples

6:29

Learn how to group pieces of data in Pairs and Triples, how to work with such constructs, and how to destructure them.

12

#### Challenge: Pairs & Triples

2:27

Challenge time! Use what you've learned about Pairs and Triples to solve a short challenge.

13

#### Allocate Arrays

12:33

Learn what collections of data are and how they behave in memory, then learn about Arrays, a static collection type.

14

#### Create Lists Of Data

7:34

Upgrade from an Array to a List, a dynamic collection of data. Compare the performance between an Array and a List.

15

#### Challenge: Arrays & Lists

3:29

Practice what you've learned about Arrays and Lists, the two basic collection types, in a challenge!

16

#### Conclusion

3:34

Review what you've learned in the second part of the course, and practice the knowledge by solving a challenge!

17

## Manage Control Flow

#### Introduction

1:23

You're doing great! In this part of the course, you'll expand your Kotlin knowledge by mastering the concept of control flow.

18

#### Loop Using While Loops

5:28

Learn how to utilize the while loop, to repeat your code multiple times. Iterate over collections using loops.

19

#### Challenge: While Loops

3:02

Challenge time! Use your new skills and practice using while loops to iterate over collections and print data out.

20

#### Loop Using For Loops

7:06

Add another loop to your loop belt: the for loop. Learn how ranges let you repeat the code a fixed number of times.

21

#### Challenge: For Loops

2:41

Practice creating various ranges and for loops, to print data sequentially, by steps, and in reverse.

22

#### Iterate Over Collections

10:59

Use nested loops to iterate over two dimensional collections, and break and continue strategies to exit from loops early.

23

#### Challenge: Iterating Collections

3:02

Practice iterating over two dimensional collections - matrices, and using exit-early strategies with break and continue.

24

#### Simplify Code With When Expressions

10:01

Learn about the when expression, a more concise larger set of it/else expressions. Use when to return values.

25

#### Challenge: When Expressions

2:18

Practice using when expressions, to return values for constants and variables. Build complex checks that rely on smart casts.

26

#### Conclusion

1:02

You're over halfway through the course! In this episode, review everything you've learned about control flow.

27

## Explore More Collections

#### Introduction

2:12

Review the concepts you've learned so far, and learn about two new collection types - the Map and the Set.

28

#### Create & Access Maps

5:27

Learn what a Map is, how to create one, and how to store key value pairs within the map.

29

#### Work With Maps

7:07

Expand your knowledge of maps, to add and remove values, mutate the contents, and learn about three types of mutability.

30

#### Challenge: Maps

3:12

Use what you've learned about Maps to solve a fun challenge. Let's get started!

31

#### Store Unique Data In Sets

4:57

Learn what a Set is, and how it's unique compared to other collections. Create and use Sets.

32

#### Challenge: Sets

2:57

Challenge time! In this episode, practice using Sets to store unique pieces of data.

33

#### Conclusion

1:08

Review the collections you learned about in this part of the course, and find out what's up next!

34

## Write Functions

#### Introduction

1:12

In this part of the course, you'll learn about write functions. Let's get started!

35

#### Write Custom Functions

8:03

Learn what the function syntax is, and how to write your own functions. Create functions to reuse behavior.

36

#### Return Data From Functions

5:15

Learn about all the ways to return data from functions, and how to utilize expressions for the returns.

37

#### Challenge: Functions

3:31

Use what you've learned about using and creating functions to solve this challenge!

38

#### Declare & Pass Functions As Parameters

10:36

In this episode, learn how functions can become parameters, and how you can store functions as values.

39

#### Conclusion

1:14

Review the concepts you learned in this part of the course, and find out what's next!

40

## Create Classes

#### Introduction

2:50

Almost there! In this final part of the course, you'll finish off your fundamental Kotlin skills by learning how to create classes.

41

#### Model & Create Classes

8:21

Learn what classes are, what their syntax is, and how to create your own data types. Learn about properties and mutability.

42

#### Define Properties, Methods & Class Mutability

9:25

Expand upon properties, learn what methods are, and how exactly mutability affects classes & reference types.

43

#### Challenge: Classes

3:05

Practice what you've learned about classes, properties and methods by completing the challenge.

44

#### Model Objects Using Data Classes

7:04

Learn what a data model is, and how to create data classes: classes which are used to represent data.

45

#### Challenge: Data Classes

4:57

Last challenge of the course! Use what you've learned about data classes to copy, print out, or compare objects.

46

#### Conclusion

1:33

Congratulations on finishing the course! In this conclusion episode, review the many things you've learned and find out where to go from here.

47

## Who is this for?

Beginner developers who've had some or no experience with Kotlin, who want to gain in-depth knowledge of this majestic programming language!

You'll learn a ton of fun and useful Kotlin concepts, starting off with data types and operators, then moving towards more complex features like statements & expressions, loops, and the flow of control. Then, building upon those concepts, you'll play with collections, functions and classes.

Sound like fun? Let's dive in!

This course isn't suitable for experienced developers. If you're looking for more complex topics, check out our intermediate or advanced Kotlin and Android courses.

## Covered concepts

This course is jam-packed with the fundamentals to give you a solid grounding for your Kotlin adventures. Here are some of the concepts you’ll conquer along the way:

• Data Types
• Operations With Types
• Logical Operators
• Statements vs. Expressions
• Nullable Types
• Loops
• Control Flow
• Collections
• Pairs & Triples
• Nesting Expressions & Loops
• Functions
• Parameters vs. Arguments
• Scopes
• Classes
• Custom Types
• Methods vs. Functions
• Data Models
• Mutability