Kotlin Course - Tutorial for Beginners

Hi, my name is Nate and welcome to this tutorial on the Kotlin programming language. If

you're not familiar, Kotlin is a statically type programming language developed by JetBrains.

It's been around since about 2011 and has steadily increased in popularity ever since.

Today it's actually the primary development language for Android and in this tutorial

we're going to move from basic topics like setting up your first project up to more advanced

things like modeling data and working with higher order functions. The goal for this

tutorial is to help you understand how the work with Kotlin so that you can then take

that knowledge and apply it to building applications across mobile, web and native code. So without

further ado, let's jump in and start building our first Kotlin project.

The first thing we're going to want to do is to install JetBrains IDE Intelijay so that

we can work with our Kotlin code on our development machine. The first thing to do is to open

up your browser and search for it. Until Jay here, you should see a download link and we

can click on that to be taken directly to the download page. Now I'll be working on

a Mac, but intelligent is available on windows and Linux as well. You'll also notice here

that there are two different versions of intelligence. There's the ultimate edition and the community

edition. The ultimate edition has a lot more features that we need and there's also a paid

product. The community edition is supportive for JVM development and Android development,

so it's perfect for what we want to look at in this tutorial. When you're ready, go ahead

and click the download button and that should start the download. Once the download is complete,

we'll get started on installing the IDE and we'll take a look at hello and Kotlin. Now

that our downloads complete, we can go ahead and onto the installer

and I'm Mac. We'll drag the application into our applications folder which will start the

install process here for us. Once the files have been transferred to your machine, we

can go ahead and start intelligent for the first time to start the install process. In

this case, we want to do a fresh install, so click that. Do not import settings and

hit okay.

Go ahead and accept the privacy policy. Hit continue. Now here you can choose your theme.

I'll choose the dark theme. Go ahead with the standard and tell the J key settings here

and we'll go ahead and click next through to finish the setup process and then we'll

finally launch intelligent IDE community edition.

The next thing that want to do is create our first Kotlin project here in intelligence.

So to do that we'll click on create new project. Now over on the left side of this panel, we'll

see a number of different project templates to choose from because we are going to be

learning about Kotlin. We want to make sure that we have selected the Kotlin template.

Now within this, there are a number of different Collin project types that we can choose from.

The default here at the top is a Kotlin module for a JVM target, so this would be sort of

a standard, just Kotlin project that could target a the JVM. I have nothing else added

to it. Other examples would be, you know Caitlyn module for a Java script target or I taught

in the native targeted or an Android or iOS mobile target. So all of those are interesting

but more advanced. For this, we want to just stick with the basics so we will make sure

that we have selected Kotlin module for JVM target and go ahead and hit next. Then we

want to make sure that we name our project something meaningful. So in this case, let's

call it hello Caitlyn. We'll make sure that our project location is set and then we'll

go ahead and select finish.

Now we have an empty Kotlin project. Let's start by adding our first common file so that

we can write a simple hello world example. So do that. We'll come over here to the left

and here we have the project panel within intelligent. You'll see at the top we have

our hello Collin module. If we expand that we can see that we have a source directory

but it's currently empty. That's right. Click on source, go to new and then Caitlyn file

our class. And here we're going to type main for the name of our file and then we will

leave this as file so that we can create our main dot KT file. Now we can get started by

writing our main function here in our main dotK T file. So to start we'll type in fun

Maine, no parameters and then we can type print Ellen parentheses.

Hello Collin. And from there you'll see now that we have this little green arrow intelligent

recognizes that this is an executable main function within this uh hello Caitlyn module.

So we can actually go ahead and run this. We'll select to run main KT and that'll take

a second to go ahead and build the project. And then we will get our output window here

at the bottom and you can see that we have hello Collin. Now one extra quick fun fact

here and tell Jay comes with a number of live templates built it. This means that you can

type something and it will know how to complete that and auto-generate some code for us. So

we can start typing Maine and then hit enter and it will automatically generate a main

function for us. And then we are free to fill in with our, hello Caitlyn text.

Awesome. You've just written your first program in Kotlin. Now let's dive in and start actually

learning the language to get started. Let's look at how you can define variables in Kotlin.

Now there's two types of variables. In Kotlin we can define mutable variables, which can

have their values reassigned. Those are declared using the VAR keyword. Or we can define local

read only variables, which can have their value assigned only once these are defined

using the vow keyword. So to define a variable, we can use the keyword of our choice. So in

this case we use vow, then we'll define the name and then we need to indicate that type.

In this case I'll say a type string and then you can use an equals and then you can assign

the value to this variable. So in this case I've defined a variable called name of type

string.

And then I have assigned the string literal Nate to that variable. Now, like I mentioned,

vow our assign once variables, meaning this is read only once it has a value assigned

to it. So if I tried to update the name of this, we'll see that we get an error. That

area says vow cannot be reassigned. So this is our indicator that if we need to be able

to update the value of our variable, we're not going to be able to use a vow. Instead

we can use a VAR. Now VAR variables can be reassigned as many times as you want. So as

soon as I updated that keyword, now I can update the value of our name variable. And

then if we want to use that variable, we can pass that in to the print function here. And

if we then run our main function, well now see the output value of that variable at this

time is blank because we had reassigned it.

If we remove that reassignment, well now see that we get this little underlying saying

variables never modified and can actually be declared immutable instead using vow. So

this is nice that the IDE gives us that helpful hint. So in this case we'll go back to a vow.

And now if we rerun this once again, well now see that my name was printed out to the

console and this example we're using a local variable, meaning that the variable that we

have defined is available locally within the current scope. So in this case it's available

only within the main function we have defined. Now in Kotlin you can actually declare variables

outside of any type of enclosing function. Our class, all you have to do is declare a

variable within a Kotlin file. So in this case we've moved our variable name outside

of the main function into the main dot. Kate. He file variables defined like this are referred

to as top level variables. And you see now that we've moved this outside of the main

function, we can still run it and our variable is still completely valid.

Top level variables can be worked with just like a local variable. So we get a fine and

an additional variable. This time we'll say VAR greeting of type string equals hello.

We now have a publicly available top level variable called greeting. So now if we wanted

to come down here and print out a greeting before the name, we could do that by calling

print line and passing in greeting. We can also modify that greeting because this is

a mutable variable and if we then print out this new value, we will see that the message

has changed.

So when we hit run here, we should now see hello Nate. And then hi mate, let's take a

closer look at how variable types are defined. So in defining our variables, in both cases

we use either the voucher or VAR keyword and then we have the variable name. Both of these

are must haves. Next step we have the colon and then the type. So in this case we have

the type of string and then we assign our value. One interesting difference between

Java and Kotlin is that types in Kotlin are non null. By default this means that there

is a distinct difference between string and a nullable string. Now what does this look

like in practice? Well in this case because types are non all by default name is a nano

string. So if I tried to assign a no value to this, we'll actually get an error and it

will hopefully say no, cannot be a value of a non Knoll type string. So if you want to

actually have no as a valid value for your variable, you need to add a question Mark

after that string value. This indicates that now named as a knowable string. And I can

assign no or I can go ahead and sign an actual value. So let's look at how we could use this

with the greeting variable.

So if we make greeting a knowable variable, we can come down here and we'll go ahead and

print out the default greeting value. We'll print out the name and then we'll see that

we can modify the value of greeting to null. And then we can go ahead and print out these

values ones again and we can then see that greeting has been updated. And when we try

to print that out, it actually recognizes that it's no and prints that out to the console

for us. So let's look at how we can actually simplify the declaration of our variables.

I mentioned that vow or bar as well as the name are mandatory. However, Kotlin supports

type inferences on variables and properties. What does this mean? Well, this means that

Kotlin can recognize what type the value is that we're trying to assign to the variable

and if it can figure that out, we can actually omit a type declaration of the variable.

So in this case we could actually remove the colon and string and the name variable will

still be of type string. Now we can do the same for our greeting variable so we can remove

this. But if we come back down here and tried to assign knowl to greeting will get an error.

No, it cannot be a value of non node type string. So why is this? Well again, because

types are non nano by default and Kotlin and we are assigning a nano string literal to

greeting the compiler. In first the greeting is meant to be a non null string. So if you

want to have a knowable string you might try and just assign no. However we get a warning

saying implicit nothing type. This is because greeting now cannot really be inferred. It

doesn't know what is a null type of. So in this case we will need to go ahead and specify

a knowable.

Now down here we can assign Knowlton greeting or we could assign an actual greeting. Now

that we've taken a look at how to create variables and how the type system works, let's introduce

some basic control flow and we'll do this by working with the nullable string variable

of greeting. So let's go ahead and remove these values. Now let's say that we only want

to print out the value of greeting if it's not no. So we could do that in a couple different

ways. The first one we'll look at is using an if statement, if statements in Kotlin work

very much the same way as in Java. So we'll use the if keyword followed by parentheses,

we use greeting. In this case we want to say if greeting is not no printed out, so we can

say not equal to know and we'll finish it off with curly braces.

And then if we move our print statement within that, if conditional when we run this, we

should now have no greeting printed out. And sure enough we see that just the name is printed

and if we modified the value of greeting to be non null and then rerun this, we'll now

see that we have our greeting. Now what if we wanted to add and else claws? So just like

Java, we could add the else, we can add curly braces again. And so here we could define

a default greeting of hi. So now if we run this once again, greeting will be normal and

so we should see the default high value. Now another means of control flow within Kotlin

is the when statement. The Wednesday mint is very similar to a switch statement in Java.

So to create that we can come down and use the when keyword and then print the CS.

We didn't want to pass end to this, the value that we want to check and switch on depending

on its value. So in this case we'll pass in grieving followed by curly braces. Now within

this block we can define each value that we want to act on differently. So in this case

we can say no. And then to define what action to take, we use an arrow and then we'll say

print line, hi. And then we can define and else case here. And this will act as the default

if none of the values above are matched. So this case we will print out the value of greeting

on its own.

So now if we run this, we should see high printed out because greeting is still not.

And once again if we update greeting to be some other value and rerun, we'll see that

the branch of the, when statement is hit and we are printing out the value of treating.

So these are two of the basic ways in which you can manipulate control flow within Kotlin.

Now we just saw how if and when can we use as statements to take different actions based

on some checked value if and when can also be used as expressions to assign a value depending

on that, those logical conditions. So let's take a look at how we could use an expression

to assign a value to a local variable. So let's go down here and type vow greeting to

print. I can say equals. Now if the greeting variable in our top level declaration is non

no, then we want to go ahead and stick with that.

So we can say if greeting does not equal null, then we want to assign greeting to the new

greeting to print variable. Otherwise we want to say hi and then we'll update our print

line to use the local variable. Now when we print this out, we should see the ELs branch

of high being printed out. This is because the top level variable is currently no. If

we modify this to pass in a greeting. Now if greeting does not equal null or return

true and we'll see that hello is printed out instead. So if we want to assign different

values to a variable, depending on whether or not something is normal or some other logical

check, we could use an expression. However, we can also use a when expression if we want

it. So we can say when, and again, we'll pass in treating here and again we'll use our no

value as the first check and if it's no, we'll go ahead and return high. Otherwise we'll

go ahead and return the original greeting value. So now with this, when expression is

saying is assign the value of high to greeting to print. If greeting is know. And likewise

if greeting is nominal, go ahead and assign that value to the new greeting to print variable.

So if we run this one more time, we should see high because grieving is null.

And if we assign that value to greeting and rerun, we'll see that updated value of hello.

So again, like the if expression a when expression can be used to assign a value to a variable

depending on that input value that it's checking to start understanding functions in top line.

Let's look at this example. Within this example, we actually are using two different functions.

We have our main function and then we're also using the print LN function as well. So let's

take a look at how we can define our own new function. We'll start by clicking here and

we'll define the new function that is going to return this string that we want to print

out to the console. So the first thing to do when defining any function is to use the

fun keyword. This denotes that we are going to define a new function.

Then we want to specify the function name. So I'm going to call this function, get greeting,

and then you want to follow that up with open and closed parentheses. And within this we

can actually define any function parameters. Now for now we're going to skip any function

parameters and we want to define our return type for this function. So similarly to variables,

we can define a return type by using a colon. And then the type in this case string. And

then we'll do open and closed curly braces. Now like in Java we can define the return

value by saying return. And then in this case I'll say hello Kotlin. So now we have the

function called get greeting this green to return the string. Hello Caitlyn. If we want

to then invoke that function, we can do so by calling get greeting with open and closed

parentheses.

This should look very similar to what you're familiar with and calling methods from Java.

And now if we run our code, we'll see to print statements. We'll see the first one, hello

world. And the second one. Hello Collin. So one thing you may have noticed is that in

our gig greeting function, we're the return type of stream. However, in our main function

there's no return type specified. So why is this? Well let's illustrate this by an example.

Let's write a function called say hello. So again we'll use the fun keyword and it will

maim it. Say hello, no parameter values. And then we're going to declare this as returning

type unit unit. And Kotlin is essentially the absence of any useful type. It's similar

to saying this returns nothing useful. And the reason we're going to use unit in this

case is because we don't want to return anything.

We're going to simply print out our get greeting functions, return value, so we can then call

say hello. And you'll notice up here that unit is underlined and it's giving us this

message that says redundant unit return type. Basically what this is saying is that if you

have a function that returns unit, that is to say if you have a function that doesn't

return anything useful, you can omit that type value. So we can actually remove unit

from our say hello function and this is perfectly valid. So that's why in our main function,

we also don't have the return type specified. Aside from the rules around unit return types,

return types or functions work very similarly to how you would define them and treat them

for variables or properties. So for example, if we wanted to return a Knoll string from

our get greeting potion, we would modify the return type to be a nullable string and then

we could return note in our return statement.

Additionally, functions support type inference as well. So in our get greeting example here

we are returning a single string literal, in which case we could actually simplify this

to a single expression. We could remove the curly braces and add an equals and then the

string literal after that. So this is what's known as a single expression function because

the entire function definition is now in a single expression. And now this is where the

title inference comes into play. Again, because the compiler understands this single expression

function definition and it knows that it's always going to return a string. We can actually

remove the explicit return type. Now our get greeting is extremely simple and is functionally

equivalent to the previous definition. So if we run our code, once again, we'll see

that we now have our three different print statements. You might be noticing a theme

here of Kotlin allowing us to reduce the amount of code we need to write to get the equivalent

functionality. This is a theme that will crop up more and more as you start to learn the

language.

Now let's take a look at how we can define function parameters. Now before we get started,

let's clean up our code a little bit. So we'll remove everything from our main function and

we're going to go ahead and remove the existing function examples we've been working with.

So once again, we're gonna define a function named say hello and to start it will print

out. Hello Collin. Now this is exactly like we have seen before, but what if we wanted

to change the thing that we were greeting? So instead of saying hello Collin, maybe we

wanted to say hello world or hello mate, or hello John. So how might we do that? Well

that's where a function parameter comes into play. So to define a function parameter, we'll

go within the parentheses after the function name, and we'll define this using a notation

of the parameter name colon, the parameter type. So in this case we're going to say item

two Crete as our parameter name, colon. And then we want this to be a string value that

we're passing it. Now with dinner function, we can say, Val, message equals hello. Plus

I even went to greet.

Okay.

And then we could pass in the message. Now if we come down to our main function, we want

to, when folks say hello, so we can start typing, say hello. And now we need to pass

in a parameter value which it suggest to us in this little tool tip. So in this case we'll

say Caitlyn. And now if we run our main function,

we now see hello Kotlin is printed out to the console. If we wanted to pronounce something

else, we could duplicate the invocation and maybe this time we'll pass it in world. And

if we invoke our main function again, we'll now see hello Caitlyn and hello world printed

out to the console. Now if we go back up to our say hello function. Well notice that there's

this squiggly line here. This is unrelated to function parameters, but this is a really

interesting feature in Caitlyn. Caitlyn supports string templates which allow us to substitute

in variable values or argument values into a predefined string template. So in this case,

instead of using concatenation, we can say hello space. And then to define a template,

add value, please a dollar sign and then we can pass in that parameter name. So now if

we hit run once again, we'll see the same output as before.

So this is just one more way in which Kotlin can produce boilerplate for us by allowing

us to define these convenience string templates. In fact, in this scenario we can take it one

step further and remove the local variable all together. And then we can actually take

this one step further and define this as a single expression. Oh shit. Now we have a

say hello function that will take in a parameter value, which is the item degree. And then

it will always print out hello item degree. So now let's update this to take two parameters

so that we can customize both the greeting and whatever it is that we want to agree.

So to do that, we're going to add a new parameter and we will name this one in greeting and

have it be of type string. And now we will update our string template here to include

that new parameter.

Awesome. So now we've updated the function. Now we need to update the invocation of that

function. So for this first line we can say, Hey, common and now for the next one we'll

say hello world and if we read this well now see our desired output. So by adding that

second parameter value, we have now made our say hello function much more flexible. Now

we can add any number of parameters we want to say hello, but like any programming language,

if you have too many parameters in your function, it might be an indicator that your function

is doing too much. Now what last thing I'd like to point out about functions at this

time is that you'll notice that these functions are not defined within any type of enclosing

class. These are free functions or as they're referred to in Kotlin. These are top level

functions like variables, functions can be defined outside of any in closing class or

independent of any associated class. Now there are types of functions that are associated

with a class and we'll take a look at those later on in the tutorial.

Like most programming languages, Kotlin has support for collection data types. These are

things like arrays, lists and maps they can use to group values together and then operate

on them at a later time. So let's start off by looking at how we can define inner Ray

and Fallon. We'll clear out these invocations to say hello because we won't need them right

now, but we'll leave the say hello function definition because we'll come back to it later.

Your create a basic array. We'll create a new local variable named interesting things

and then we'll use the equal sign and then we can use a convenience function called array

of in parentheses. This will create an array of whatever the inferred type is and then

we can start defining values within this function. So in this case, as soon as I add a string

literal, it can infer that this is going to be an array of strings. And then we can define

some interesting things like Kotlin programming or comic books.

Now that we have this variable defined, let's see what types of operations we can perform

on it. If we start typing interesting things and hit dot the IDE will start to auto-complete

and show us some of the methods available. So you see we have a size property, we have

a get method, and we also have this open and closed of bracket syntax that we can use to

access individual elements in the array. Let's try printing out some of these values to demonstrate

how we can use the array to start. Let's print out the size. We can do that by saying print

LN and then we'll do interesting things that size. Now let's print out the first element

in the array. We can do that by going print, LN, interesting things. We can use the open

and closed bracket and then pass in an index. This is how we can conveniently index in fact

array.

This is similar to doing a jet, so if we duplicate that line, we could say get, and again, passing

is zero element of that array. If we now run this, we'll see three Caitlyn, Caitlyn, but

this is just as we would expect. Now, what if we wanted to iterate over all of the elements

of this array and then perhaps print out each of those values? Well, there are a number

of different ways we could do that. For now we'll take a look at a basic for-loop so we

could start typing for, and then we could say interesting thing in interesting things.

Then open and closed curly braces. This is now the convenient syntax of four loops within

Kotlin. So this is going to iterate over each value in the array and we can access those

values in the interesting thing variable that we have defined within this four loop.

So now we can type out interesting thing and if we rerun this code well now see that we

have printed out each element in the array. So that type of for-loop is what is probably

most similar to what you're used to if you're coming from Java. However, in Kotlin because

we have top level functions and higher order functions, really just first class of port

for functions across the board, we can write code that is a bit more functional. So let's

take a look at how we could do a more functional approach to collection iteration. So or remove

our four loop and now we could say interesting things doc for each. And what this is is invoking

a for each function that is available in the standard library. That function then takes

in a another function and returns unit. That function that we pass it in essentially defines

what to do on each iteration over this collection.

So within our curly braces here, this is where we can define what we want to do with each

element in contrasting things. Now this might look a little bit confusing at first, but

don't worry well explain this, but if we simply want to print out each item in this array,

we can now say print LN and pass in it. It is the default name for each element in the

array that is passed into this Lambda function in which we are defining. So if we run this

well, now see that we have our three elements in the array printed out to the console. Now

it is not always very readable. So another little quick tip here is if you want it to

be named something else, you can rename that to value that's passed into the Lambda. In

this case we could call it interesting thing and then we'll use the arrow and now instead

of if we can reference that value by calling it interesting thing and once again if we

run this, we'll see that our interesting things are printed out to the console.

You might be looking at this wondering why we are not using an open and closed parentheses

when calling the for each function. In fact, it might seem rather odd that we are not passing

in that argument two for each, but instead of have just specify this open and closed

parentheses independent of the rest of the for each call. So this is actually what's

known as Lambda syntax within Kotlin. Now we'll look at how to implement this later.

But the idea behind Lambda syntax is that if you have a function and it's only parameter

is another function, then you can omit the parentheses all together and you can pass

that function in by specifying this open and closed parentheses. So again, if we look at

for each, we'll see that it takes a single function as a parameter so we can omit the

parenthesis values and past that function into the for each function using the open

and closed curly braces.

And like I said, we'll look at how we actually define this type of higher order function

a little bit later in the tutorial. So here we looked at a basic for each function on

this array collection. But by doing it this way, we've lost the index data for whatever

index the current interesting thing is in the containing array. So to handle that there

is another function we can call. So once again we'll say interesting things and this time

we'll say for each indexed. Now this time it's going to pass into us the current index

as well as the current string. Now once again, we'll update this to be named interesting

thing and that one's again, we could print out these values. So we can say print,L ,N

and we can say interesting thing is at index.

And now if we print this out, we'll see that we have gotten the value from the array as

well as its current index. So this could be really useful if you need to iterate and still

maintain that index data. Now everything that we've been looking at here for res is applicable

for lists as well. So if we clear out some of this previous code, we now go to our declaration

of this interesting things variable. Now we're using the convenience function array of to

define this variable as an array of type string. Now there's also a list of function as well.

Now if we try to work with interesting things, we'll see that we have a lot more methods

to choose from because it's now a list rather than an array. And so like an array, we can

access individual elements by using a jet or also by using the bracket syntax like we're

familiar with with arrays as well.

And also like with the array, we have functions available to us to help with integration.

So if we wanted to print out all of the interesting things again, once again we can say interesting

things doc for each ad. Once again we'll say interim vesting thing. We use the arrow here

within our Lambda expression and then we'll print out the interesting thing and if we

hit run while that we have our three interesting things printed to the console. Now that we've

looked at arrays and lists, let's take a look at one more collection type and Kotlin which

is map. So let's remove this duration over our interesting things variable here. Now

let's create a new variable. I'll just name this map equals and once again there is a

map of function that we can use. Now the map of function will essentially take in pairs.

Pair is a simple wrapper class containing two values and that there is also the convenience

function to create pairs.

So if you want to create a basic key value map we could do so like this. We'll use a

key of one and then we'll use two and then the value in this case will be a, and then

we'll define it. Another pair, we'll use a key of two. Then we'll use the two function

and then a value of B. And then we'll define one more pair. And we'll say three is our

key to C. so what we've now done is defined a map with three pairs of values in it. The

keys are one, two and three, and the associated values are a, B, and C. now we can iterate

over this by saying map for each and it's going to return to us both the key and the

value. Unfortunately the default to it, not

very useful name. So this case we'll remain them again within our Lambda expression. So

we'll say key value and then we can print these out and we'll use a string template

and we'll just say key and then we'll define an arrow just for some separation and then

value. And now if we print this out, well now see that we're giving each of our key

and value pairs and then we could do with those whatever that we need to. We've seen

how you can define several different types of collections such as arrays and lists and

maps. And we've also seen how you can iterate over those collections and access individual

elements from our collection. And there's an interesting thing to point out about the

way Kotlin handles the collections similar to the way in which it differentiates between

knowable and nano types. Caitlyn also differentiates between mutable and immutable collection types.

Now what does this mean? This means that by default a collection type in Kotlin is immutable

so that you can't add or subtract values from that collection once it's initially created.

So let's look at an example of this. We have defined our interesting things list using

the list of function here. And if we wanted to try and add something to interesting things,

there's no function available to us to do that. That's because it's immutable by default.

If we wanted a immutable list, we could use the mutable list of function. Now if we want

to add something, we can say interesting things. Dot add and we could add a new string to our

interesting things list. The same goes for map. If we wanted to add a new key value paired

wire map, you could say map doc put, but there's no put method available. But if we change

to immutable map, now we could say map dot put and we can define a new key of four and

a new value of D. so this is something to keep in mind. If you have a collection that's

going to be static, once it's defined, then you're fine to use the regular list of array

of map up, et cetera functions. And that is a good thing because immutability is often

a desirable trait in your code. However, if you're going to want to modify the values

in that collection, then you'll have to create a mutable collection so that you have access

to things like put or add that let you modify that collection.

Okay,

now that we have an understanding of working with collections, let's modify RSA hello function

to take a collection parameter so that we can greet multiple things, will modify first

the name of item to greet two items to greet because it's now going to be plural because

it will be a collection. And that will update from string to list of string. And then now

we're going to update the implementation of this function. So instead of being a single

expression function, we'll add a function body. And then now we're going to want to

iterate over the items to greet parameter. So we'll say items to greet dot for each.

And then we'll paste it back in our original print statement. And then we'll go ahead and

update the receiver value here from it to item to Crete. It'll add our arrow. And so

now we have a say hello function that you can pass a collection into. And then it'll

print out multiple lines. So now we can say, say hello and we can still pass in our custom

greeting so we can say hi. And then we can pass it in our interesting things variable.

And now if we click run, we now see high Caitlyn, hi programming and high comic books. So this

just a quick example of how you can pass it in a collection type to a function as a parameter.

There's nothing wrong with including a collection parameter in your function, however functions.

And Kotlin do provide an additional piece of functionality that can satisfy this use

case and provides a little additional flexibility. Now to demonstrate why this might be interesting

to us. Let's look at an example. So let's say we want to call say hello and we'll pass

on or greeting, but then we don't want to pass in any interesting things in this case.

Well, because of the way that this function is currently defined, we have to pass in the

second argument. So in this case, if we wanted to pass in no items, we would have to pass

in an empty list, which isn't really a big deal, but it's also not the most flexible

way of handling things. So let's take a look and alternative means of achieving this functionality.

If we come up here to our say hello function, we're going to modify this second.

So that is a VAR arch perimeter VAR ARG is a keyword in Kotlin. It essentially represents

a variable number of arguments. So in this case, instead of taking a list of string,

we'll define a VAR R of string. This tells the compiler that we're going to take a variable

number of string arguments after the initial greeting argument to this function. So now

if we try to pass something in to say hello, well first pass in our grieving and now we

don't actually have to pass anything in after the initial argument. This is because the

[inaudible] parameter will essentially be treated as an array of whichever type it's

used to specify. So in this case, items to GRI is now an array of type string. So if

we don't pass any items after the greeting, it will be treated as an empty array. If we

did want to start to pass items, we can do that by separating them with commas. So it

could say Kotlin and now this would be an array of size one. But where the real flexibility

comes is we can now start to define many argument values here.

And so now all of those arguments that are passed in will be grouped together, treated

as an array. And so in our function implementation, we can still iterate over all the elements

in that array. So if we now run this, we should get the same outfit as before. So by using

our VAR arc parameter, we've eliminated the need to always pass in a value after the initial

greeting argument and lets us have greater flexibility because it will support zero one

or any other number of argument values to be passed it. Now it's very convenient to

be able to pass multiple arguments to this [inaudible] hard perimeter. However, you're

usually not going to be hard coding those arguments in manually during compiled time.

More likely you're going to get a array of values from a network request or a database

and then you're going to want to pass it those in. So you might think that it would be as

simple as passing in an array after that initial greeting. So let's try that. We could change

list of two array of, and then after I,

we'll pass in interesting things. Oh, unfortunately this does not work. And if you look at the

air, the see a requires string found array of string. So how do you actually pass in

an array of existing values to this far ARG perimeter? Well, you can do that with the

spread operator and all the spread operator is, is applying the asterisk before the array

variable when you pass it in as an argument value. So now if we hit run, we'll see that

the compiler is now accepting that array and we are iterating over each item in that interesting

things array. So this is how you can pass in an existing collection as a VAR ARD parameter.

Another really interesting and powerful feature with Kotlin functions are named arguments.

Now let's take a look at an example of what name arguments provide to us. Let's start

by cleaning out our main function and then we're going to define a new simple function

that will take a greeting and a name and then print that up.

So now when we want to call this new Greek person function secret person, hi, and then

I'll use my name here. Now this is fine and it's very easy to understand because the ID

is helping us and showing, okay, this is the greeting argument. This is the name argument.

However, if you are in a code review, you might not be able to know exactly which order

these arguments are supposed to be passed in. Also, if you wanted to modify the function

signature of Greek person down the line, you'd have to make sure that these are in the same

order because since they share the same type, you could mix that order up without getting

any type of compiler pair. Now what made arguments allow us to do is specify which parameter

this argument value is going to be used for. So what does that actually look like in practice?

Well, it looks like defining the name of the parameter and then an equal sign. And then

here we can say main equals. And so now we're saying very explicitly assigned, high to greeting

and Nate. To me, the cool thing that this allows us to do is actually mix up the order

of these arguments. So now we can actually pass the second parameter first and the first

parameter second so that we could actually theoretically modify the signature of Greek

person changing the order of these parameters and it wouldn't impact the invocations of

that function. Caitlyn allows us to take this flexibility one step further by leveraging

default parameter values. So once again, let's look at our Greek person example. So here

we are now able to pass the arguments in whatever order we want. If we're using name arguments

in tax, but what if we wanted to pass main first and then not even passing the greeting?

Well now we get an error because it says no value past for perimeter greeting. So as great

persons currently defined, it must take both arguments, even if they are in a mixed up

order. Default parameter values allow us to change that. It allows us to tell the compiler

what the default value should be if not as specified. So for greeting, we could provide

a default value of hello and for name we'd get provided default value of Kotlin. You'll

see now great person can be called by only specifying a single argument value. And if

we run this, we'll see. It's going to say hello mate. So it's giving the default greeting

value and then it was using the value for the name that we passed in now because both

arguments have defaults, we could actually call this without passing any arguments in.

And if we run it now, we'll see it's using both defaults and prints out.

Hello Kotlin. Now this becomes a really powerful feature because now we can not only mix up

the order in which we pass arguments, but we don't even have to pass all of them in.

This actually allows us to replicate functionality of the builder pattern without actually having

to write getters and setters and have private constructors and all of that. We can configure

and reuse functions and objects by leveraging these default values and the named arguments,

syntax, Wilde, Decaux parameter values, main argument and VAR. Our parameters are really

convenient and flexible and powerful. They do have limitations as well. So I want to

illustrate one of those limitations. So we're going to go back to our say hello function.

Let's redefine our interesting things are right. And so now if I want to invoke, say

hello and I want to pass things in order with the greeting and then the interesting things

I can do that no problem. And if I run this, we'll get our three lines of output.

And so now what if we wanted to use named arguments in techs? Well we could do that

as well. Breathing equals high. However, as soon as I add the name argument syntax to

the first parameter, I get this air saying mixing name and position arguments is not

allowed. So this is one of those limitations. As soon as you use named arguments in tax

for what argument, everything that follows, that must also be named. So in this case,

I could fix this by saying items to treat equals and now I can run this again and I'll

get the desired three lines of output once again. Now I could mix these up though

and because both of them are using names, argument syntax, there are no problems here.

And once again, we could run this and we would get our desired output.

Now we're going to take a look at how we can create a simple class in Kotlin. Now up until

this point, we've been working within a single main dot K T file. However, now that we're

going to move into classes, let's go ahead and add a new file. So we'll come over to

our project panel, right click source, go to new Kotlin file or class, and we're going

to come down and on this dropdown we're going to select class and then we're going to name

this class person and then hit enter. We can see here, then it automatically has created

a person class for us and I might notice that this class is quite simple. So let's take

a look at how this class actually works. To start, we have the class keyword followed

by the class name and then really that's it. We could actually even optionally remove these

curly braces. Since we're not defining any properties or methods at this time, if we

wanted to then use this class, we could return to our main function here. And then we can

create an instance of the class like this. So we'll create a variable named person equals

person. Now this syntax right here is how you create a new instance of a class. Notice

there's no new keyword and Caitlyn, you do not have to explicitly call new. You can simply

specify the class name and then the constructor and any arguments that you need to pass into.

It can may notice

that we were able to create an instance of the person class using this empty constructor.

However, if we go back to our class definition, we don't have any constructor defined. This

is because when you're defining a class in Claplan, if you do not have any properties

defined in your primary constructor or any arguments defined in your primary constructor,

then you can actually just omit that primary constructor altogether. So what we see here,

class person is really a shorthand form of this. If we wanted to explicitly define this

primary constructor, we can do so by adding the constructor keyword and then the opening

closed parentheses. You'll see here that it actually gives us a message recommending that

we remove the empty primary constructor. Now we could also modify this primary constructor

by just removing the constructor keyword and moving the open and closed parentheses directly

after the classmate. However, we still get that same recommendation to remove the empty

primary constructor. So let's add a primary constructor once again. And this time let's

actually define a parameter that must be passed into this constructor. So if we're creating

a person in class, let's pass in a first and last name for this person. So we could say

first name string, last name string.

So now we have two unused parameters that we pass it into the constructor. And now if

we come back here to the creation of an instance of our person class, we'll see that we now

have a compiler error saying no value pass for our printers. So I'll go ahead and I'll

pass it in my first and last name here so we can come back here and we're not actually

doing anything yet with these perimeters. So let's change that. Let's define our first

property on our person class. So since we're passing in first name and last name, let's

define properties for first name and last name. So we can say Val, first name street,

thou last name street. Now you notice that both of these, now I have red areas underneath

them saying property must be initialized or be abstract. And there's a couple of different

ways that we can initialize these.

The first way we'll look at is using and then hit block can define it in a net block by

using the unit keyword and then open and close curly braces. And a net block is a piece of

code that is run anytime. An instance of this class is run and you can actually have multiple

admit blocks that will be processed in the order in which they are defined within your

class body. So within this a net block we can initialize our property values using the

parameters from our primary constructor. So we'll say first name equals underscore, first

name, last name equals underscore, last name. Now we have initialized properties. But if

we look up at where those properties are declared, we will see these little warnings saying,

can be joined with assignment. What does that mean? Well this is the other way in which

we could initialize these values.

We could actually get rid of the NIC block here and we could initialize these at the

point where they're declared by saying equals underscore first name equals underscore last

name. So now we're passing in those parameters to the constructor and then immediately declaring

and initializing properties on the class. So now if we go back to our usage of this

person class, after we create the instance of person, we can now access those properties.

Jax as the properties where you type person. Dot and then we can access the properties

by their names directly. So we can say last name or person dot first name. Now you noticed

that we're not using a getter here in Kotlin. This is known as property access syntax. You

can reference properties directly by their name without having to worry about the getter

or the setter. So now if we go back over track class, we could actually simplify this even

a little bit more. And to do that we'll go ahead and remove these properties.

And so now instead of passing in a parameter to the constructor and then defining a separate

property that mirrors that parameter, we can actually declare the property directly and

the primary constructor. So to do that, we'll come up here, we'll remove this underscore

since this is now going to be the property name and then we'll add the vow keyword. And

now when we have defined a first name and last name properties within our primary constructor

directly, and if we go back to our usage, we see that nothing has changed here. We can

still initialize the class in the same way and still access our last name and first properties

the same way. So far we've been working with the primary constructor within our class declaration,

but it's also possible to define what are known as secondary constructors. Secondary

constructors can provide alternative means for you to instantiate an instance of your

class.

So let's work with an example. Let's say we want to create a secondary constructor that

takes no parameters so that we don't have to always pass values in what we want to create

a new person object. So to create a secondary constructor, we'll use the constructor keyword

and then open and close parentheses. And in this example we're not going to pass in any

parameters. We didn't need to call through to the primary constructor. To do that we

use colon and then the this keyword open and closed parentheses. And then now we need to

satisfy any parameters that are declared in the primary constructor. So in this case,

let's define some default first and last name values. So for our first name we'll use Peter

and last name. We'll use Parker.

Okay.

And then we can define a body for the secondary constructor. And to just take a look at how

this works with the NetBox. Let's go ahead and add a print statement here that says secondary

constructor

[inaudible].

Well then add and then that block, and we'll put a message here that says, and that one.

And then just for fun, let's add a second, a net block after the secondary constructor

and we'll print out in it too. Now let's run our main function and just see what happens.

[inaudible]

so in this case we're using the primary constructor so we can specify and explicit values for

the first and last name. So we'll see that the secondary constructor is never called,

but both admit box are called and log out to the console. So now let's remove the explicit

arguments that are being passed in. And now let's rerun this

[inaudible]

and now this time we'll see that I didn't block one is run and Nickboch two is run and

then our secondary constructor was run

[inaudible].

So what this shows is that the admit blocks are always going to run before the secondary

constructor. Now the Invitbox will execute in order in which they're defined within the

class body and the secondary constructor will be called. Now in this example, and actually

in many practical examples when using Kotlin on real projects, a secondary constructor

isn't strictly necessary because of the power of default parameter values. So in this case

we can remove all of this within our class body and instead we can define default values

here in the primary constructor.

Okay.

Now if we go back over to our usage, we can still use the person class as if it had this

empty primary constructor because both parameters have default values.

Now let's look a bit more closely at class properties. Now we've already defined two

properties within our primary constructor. Both of these are read only properties so

they have no center, but they do have a getter available. That Gitter is how we are able

to leverage property access and tax and reference those properties directly as we are doing

here in our main function. Let's explore this more fully by adding another property. Let's

add a nickname property. In this case we'll use VAR because it's not going to be set initially.

We'll call it nickname string and we're going to go ahead and make this a notable string

and then we'll go ahead and set that initially to know. Now let's see if we type person.

Dot. We see that we have a nickname property, but unlike last name and first name, this

is a mutable property.

So we can actually assign a value to this. So we can say equals. And then my nickname

growing up was shades. So assign that string to this nickname property. So if we go back

to our person class, let's look at this property a bit more closely. We've already mentioned

that properties and Caitlyn will get getters and setters generated for them automatically

by the compiler. So if your property is a vow, it will have a get or generated. If it's

a bar, it will have it getter and a setter generated. But what if you don't want to rely

on the default behavior of these getters and senators? Maybe you want to do some complex

logic within that. Or maybe you want to log something out for debugging purposes. Well,

you can override the behavior of these default getters and setters and provide your own implementations.

So let's log out every time a new nickname is set.

To do that. We go to our nipping declaration and then we'll go to the next line and then

we'll space over four times. And now if we start typing set, we'll see auto-completion

comes up with several options here. So I'm going to choose this bottom one. So what this

essentially does is allows us to define the function behavior for wins set is called.

Now when we do this, this will generate a backing field for this property. So to actually

assign the new value to our nickname property, we need to use a special keyword called field

equals value. If we didn't make this call, then the value of nickname would never actually

be updated. And now we are free to implement whatever you want. So in this case we can

update this with a log message that says the new make name is dollar value. So now if we

go back over to our main, let's see what this looks like. So we're assigning one nickname,

person that nickname that. Let's assign a nother nickname. In this case we'll just say

new nickname. Now if we run this, we can take a look at the log. So you see here each time

for assigning a value to the nickname property, our log statement is being run. Similarly,

we can override the default Gether. We do this very much the same way. I'll start by

saying get,

there's no new value to set so there's no value being passed in. So instead we'll just

lock this out. Say print line. The return value is dollar field. We still have that

field backing value, which is what his storing the actual value of nickname. And then we're

going to return the value of field. So now we'll come back over to our main, we'll use

a print statement here, person dot nickname and if we run this, we're seeing that our

center is being called multiple times. Then our getter is being called and the value logged

out. And then finally our print statement here in the main function. Now that we've

explored class properties, let's take a look at how we can add a method to our person class.

To add a method, we really just need to define it function within our class declaration.

That's great. A method called print info. It'll take no parameters

and it's just going to print out the user's info. So in this case we'll use a print statement

and then we'll use a string template to pronounce the first name, the nickname, and the last

name. So we go back over here to our main class. Let's go ahead and remove most of this.

Now if we want to call the method on our person variable, we can type person dot and then

print info. So now if we run this, we see Peter, no Parker. So our method worked, however,

the formatting is maybe not quite what we would have wanted because nickname was no

like print info was called, we printed out the word no rather than anything possibly

more useful. So let's refactor this method a little bit and see if we can improve that.

So that's great. A variable called nickname to print. And then let's check whether or

not this is no. So we can say if nickname does not equal no, we'll go ahead and use

the nickname else. We'll use this more descriptive string of no nickname and now we can update

this implementation and instead of using nickname directly, we'll use this new local variable.

So now if we go over to our main again and we run this, now we see our output is formatted

a little bit better now while the output now looks better, this expression right here is

a little bit verbose. This type of check where we're comparing whether or not something is

no and then providing one of two values comes up quite a bit and Kotlin and because of that

there's actually a convenient syntax we can use that simplifies this expression. So what

we can do is this like maybe question Mark Colon, no nickname.

The question Mark Colon is what's known as the Elvis operator and Caitlyn, what this

expression is saying is check what's on the left side of the Elvis operator. If that side

of the expression is not no, then go ahead and return that. Otherwise return what is

ever on the right hand side of the expression. So if we go back to Maine and run this once

again, well now see that we're still getting our updated output. So this case, the Elvis

operator is just a much more concise way of doing that. If else check. Now I want to take

a minute and talk about visibility modifiers within Kotlin. Looking at this code here,

you'll see nowhere do we have any type of visibility modifier specified. However, if

we go over here to our main, we're able to create a new instance of this class. We are

able to call the print info method and we are able to access all of the properties.

This is because in Kotlin classes, properties, methods, really visibility in general is public

by default. If we wanted to modify the visibility of any of these, we can add one of for visibility

modifiers. So from the class we could add public here. However, because it's public

by default, this is not needed. We could add internal. Internal means that this class is

public within the module. So in our case, because we're in a single module, this doesn't

change anything. We can also make this private.

Once we make it private, we'll now see that it's no longer available in our main dotK

T file and this case a private class is only available within the file in which it's implemented.

Now we get to apply similar rules to our nickname property. If we make this an internal property,

nothing changes and we can still access that. If we make this protected and go back to our

main function, we'll now see that we're getting an air cannot access nickname. It is protected

in person. A protected property or method will only be available within that class or

within any subclasses. And as you might expect, if we make this a private property, once again,

we cannot access it from our main dot KT file. And the same goes for our method. If we make

this private or protected, it's not going to be available within main bat. K T now that

we have an understanding of how classes work in Kotlin, let's take a look at how interfaces

work. So we'll go back to our source directory, go to new Kotlin file or class. This time

in the kind drop down, we'll select the interface and let's go ahead and call this person info

provider and we'll hit okay.

So now the IDE has created a person info provider dotK T file and it's auto generated this empty

person info provider interface for us. Now, like with the class, because the curly braces

are empty, we can actually remove those and this is a completely valid interface within

Kotlin. It's MD. There's no methods that can be implemented and there are no properties

that can be implemented. However, this could still be used as a marker interface, for example,

in other classes, could in fact implement this interface. In fact, why don't we do that

right now? Let's create a class called the basic info provider, the implements person,

info provider. We can actually do that within the same file. We don't need to have one file

per class or interface within Collin. So to start we can say class basic info provider.

Now we want to indicate that this class is going to implement person and vote provider.

To do that we'll use a colon and then we'll type the name of the interface and just like

that, we've now created a new class basic info provider that implements person info

provider. And because person info provider does not currently have any methods or properties,

basic info provider has nothing that needs to implement. Oh, let's add a method to our

person. Info provider interface can do that. We'll come back up to the interface declaration,

we'll add back our braces, and now we're going to define a function signature within this

interface. Now we don't have to actually implement this, we just have to define the name and

the parameters that are required by this method. Now once we've added this, we'll notice down

below now that our basic info provider class has a compiler error saying that it does not

implement the required interfaces or add the abstract keyword.

So let's take a look at how we can address this issue. Could you, so we're going to start

off by adding a main function so that we can play around with this class. Now what are

the ways that we could solve the compile issue with basic info provider is by declaring it

as an abstract class. This means it doesn't need to implement all the methods available

on the interfaces that includes, but it also can't be instantiated. So if we tried to come

down here and say vow provider equals basic info provider, we'll get an error saying cannot

create an instance of an abstract

class. So this case we don't want to make this abstract cause we do want to work with

this class so we can remove the abstract class keyword and that we want to actually implement

the required methods from person info provider. So to do that we can start typing print info

and the IDE will recognize that. And if we hit enter, it will generate a step down version

of that print info method.

Now let's take a look at how this was generated. We see that it starts by including the override

key word. This is different than in Java where it was an override annotation. And Caitlyn,

if you remove the override keyword, it'll actually give you a compile error in this

case saying print info hides member of super tight and needs the override modifier. So

it's very specific in indicating that you do need to include that override. And then

after that it's simply matches the rest of the method declaration from the interface.

So here we're now free to define the behavior of this interface, however we want you also

seen down below that now that we have implemented the interface fully, we can actually create

an instance of this class. So if we implement this right for now, just printing out print

info,

yeah,

we can come down to our main function, we can type provider doc and then we can invoke

the print info method and we'll pass it in a empty instance of the person class and we'll

see here that it executes that print info method

[inaudible].

So that's a very simple example of how we can define an interface to find a method on

that interface, implement it, and then run it on that. Implementing class. Let's improve

upon the implementation of print info. So here we're going to say basic info provider

and then below that we're actually going to call the print info method on our person class.

So now if we run this, we'll see that we have that basic info provider being printed out

and then the info from the person. Now perhaps we want to encapsulate this logic within the

interface itself. Maybe this print info method, it should always generally work in this same

way. Well, we could actually move the implementation that we've just defined right here up into

our interface C and Kotlin interfaces provide default implementation of an interface method.

So now we can actually remove the implementation of print info from basic info provider and

the code will still compile and run.

So now if we run this, we're going to get the same output. However, there's an issue

with this. We see now in our person info provider interface, we are including the basic info

providers string. Well, we probably don't want that since it is an implementation detail

of basic info provider. So here we could actually leverage another interesting feature interfaces

in Kotlin. We can provide properties on our interfaces as well as methods. So we'll define

a property called provider info of type strength. Now you might be tempted to give this a default

value, but if you do, you'll see that we actually get a compiler error saying property initializers

are not allowed to interfaces. So you will in fact have to override this and any implementing

class. But now that we have this provider info string, we could modify our print info

default implementation to print out that provider info.

So now we've kind of encapsulated this logic into the interface itself. And then the basic

info provider class can now just override that provider info property. And we override

a property in much the same way as a method. So we'll use override vow provider info type

string and then we have to provide the getter. So in this case we'll say basic info provider.

And now if we run this once again that we'll see that we are picking up the overwritten

property value and then still relying on the default implementation of print info in person

info provider. And now if we wanted to still override print info we could absolutely do

that and we could call through to the super implementation if we would like and then we

can print out anything else here and if we were in this one last time we'll

see that we are now relying on the property, the default implementation of print info as

well as now our additional logic and the overwritten implementation of print info. Next up, let's

look at how we can implement multiple interfaces with a single class. To start we'll add a

new interface called session info provider

and then we'll add a method to those called get session ID and that will return a string.

And so now if we come down to basic info provider, we want to make this class implement session

info provider as well. Well I'll be asked to do is to add a comma after the previous

interface declaration and now add session info provider as well. And now once we do

that we'll now see you basic info provider telling us that we don't implement the required

methods so we can come down here and implement get session ID and we can return some session

ID. Now down here on our provider class, we can now see that we can call get session ID

on our basic info provider instance. Now's a good time to talk about how type checking

and typecasting work in Kotlin. To do this we're going to create a new function here

called check types and we're going to take a parameter of type person info provider.

Now let's say that we want to check whether this person info provider is also an instance

of a session info provider. How about we go about doing that? Well we can say if info

provider is session and vote provider and then we'll print that out. Say is a session

info provider. Otherwise print Ellen, not a session info provider and now we will call

this check types function and we'll pass in our provider variable. So now if we run this

we'll see is a session invoke provider printed out to the console. So this conditional was

able to determine that the past in info provider was also an instance of a session in both

provider. Now if we wanted to flip this logic and check that it is not a session info provider,

we can add an exclamation point before that and then we'll just flip these print statements

here and now once again if we run this we'll see is a session in both providers.

So you have the flexibility there to check that either way. Now let's take a look at

how typecasting works. So within this else block we've already checked that info provider

is a session info provider. So we can cast it and then call methods on it as if it was

a session info provider. So we could say info provider as session info provider. The as

is the keyword used to cast something to another type doc, get session ID. So now we're able

to cast info provider is that session and from a provider and call any methods or access

any properties on it that are specific to session info provider. Now Caitlyn also includes

what is known as smart casting, which means that if the compiler can check a type and

validate that that type will not change, then you don't need to do any additional casting.

So in this case we've already validated that info provider is a session info provider.

So we don't actually need to explicitly recast this. We could say info provider dot. Get

session info. And the compiler is performing a smart cast for us. So here we can access

get session ID or other properties and methods on the session info provider without having

to explicitly cast it each time.

We've never seen how a class can implement multiple interfaces as an example of our basic

info provider. Let's now take a look at how a class can inherit from another existing

class and override methods and properties on that base class. To start, let's create

a new file called fancy info provider. Within this file we're going to create a new class

called fancy info provider. We didn't want this class to extend the basic info provider

that we already defined. So we can do that by adding a colon and then typing the name

of the class that we want to inherit from in this case basic info provider. Now as soon

as I do this, you may notice that we have a red squiggly line here indicating an error.

The error says this type is final, so it cannot be inherited from this is a characteristic

of classes in Kotlin by default and Caitlyn classes are closed, meaning they cannot be

inherited from or extended. To extend this basic info provider class, we meet to add

the open keyword by adding the open keyword, it now means that you can inherit from this

class. So if we go back to our fancy info

provider, you'll now see that our error has gone away and we can now override methods

and properties in this class. Now let's start by overriding the provider info property.

So we'll add the opening closed curly braces to our class definition and then I can start

typing provider info and you'll see that the IDE is suggesting the property available to

us to overwrite. So I'll hit enter and that will go ahead and auto complete the property.

Now notice it has the override modifier indicating that this property is being overridden and

I noticed that it automatically provides a custom getter and you'll see that it defaults

to deferring to the super implementation of this. So we could actually override this just

like this by saying fancy info provider. If we were to then come back to our main function

here and replace this with an instance of fancy info provider and we rerun this, what

mousey is printing out fancy info provider so that provider info is being correctly overwritten

in our new extended class.

Now let's try overwriting the print info implementation in our fancy info provider class. So if I

start typing print info, once again, we'll see the IDE suggesting the method that can

be overwritten. I'll hit enter and again by default this will call through to the super

implementation of print info within basic info provider. And so I can then add another

line here that just maybe says something like fancy info. And if I come back and run my

main function and that we'll see the base implementation is the basic info provider

implementation. And now this extra line added by our implementation of fancy info provider.

Now I want to illustrate one last point in regards to inheritance, but before we do,

let's refactor basic info provider a little bit. Instead of hard coding the session ID

here, let's add a property to hold that value. So we'll come here and we'll say Val and we'll

say session IB prefix, let's say equals session. And now we roll return session ID prefix right

here in our implementation of GIP session ID. So now if I come into fancy info provider,

I want to override that new session info prefix.

So to do that I might start typing session and you'll notice that it's not auto suggesting

that new property that we just added. This is because to overwrite a property and a derived

class, you have to Mark that property as open. This is just like extending a class so we

can come here to session ID prefix and add the open modifier as soon as we do that. If

we start typing once again, now we'll see it's suggesting the option to override session

ID prefix. So just like the provider info property, I can now override this and I can

say fancy session. So this is just one other way in which Kotlin works to enforce immutability.

It forces you to Mark both your classes, your properties, and your methods as being explicitly

open for extension. Now there's a small problem with this new session ID prefix that we've

added.

It's really meant to be an implementation detail of the class. However, if we come here

to our call site where we're using a fancy info provider variable, you might notice that

we can actually access that prefix directly. This isn't ideal because like I said, it's

an implementation detail. Our API shouldn't really be exposing that property. Now the

reason it's available is because we have defined it as a public property. So what can we do

about this? Well, if we want it to be available and our child classes but not to the public

API, we could add the protected modifier. So now that property is protected down here,

when we try to access it, we get an error saying cannot access session ID prefix. And

if we come back to fancy info provider, you'll see that we can still override that property

without any trouble.

Now that we've explored how we can extend an existing named class, let's look at how

we can create an instance of an anonymous interclass using an object expression. To

do that. We'll come over to our main function here and now instead of instantiating an instance

of fancy info provider, we're going to create an anonymous interclass. So we'll delete that.

And to start off to create our object expression, we can type object, colon and then the name

of the class that we want to extend. In this case it'll be person info provider. Now within

this class we can

override any available properties or methods. So in this case I'll update the provider info

and just say something like new info provider. Now notice below here that our provider dot

get session ID call is now being marked as an error. That's because there is no guest

session ID on person info provider. But we could go ahead and add a new method to our

object expression here. So we can just say fun, get session, I ID equals and then we'll

just put in a value here. So you see you can not only override the existing properties

and methods, but you can add to them as well. Just like you could in any other name to class.

And now if we run this code, we'll see new info provider being printed out to the screen.

So an object expression allows you to create an anonymous inter class so you don't have

to create a new named class. So this might be useful for things like a click listener.

If you were working in, let's say, Android development.

Now that we've explored object expressions, we're going to now look at companion objects.

And to do that, we're going to create a new file and we're going to name that file entity

factory. Now imagine we want to create a factory to create instances of something called entity.

So to start we might create an entity class and maybe that class will have a single ID

property to start. Now we want to make this a factory like we said. So what we might want

to do is change this constructor to be private. And so now if we add a main function and we

try to create an instance of entity, we'll see that we have an issue here. Well notice

that there is this error saying cannot access in it. It is private to entity. So this is

because of that private constructor. Well, so what can we do?

This is where a companion object could come in handy. A companion object is an object

is scoped to an instance of another class. So within our block body here, we can type

companion object. Now we could create a create function called fun create and we'll have

that simply return an instance of entity. And for now we'll just pass it in a placeholder

ID. So now we can come back down to our main function and we can type entity dot companion

dot create. And we can use this to create an instance of that class. This works because

companion objects have access to private properties and methods of that in closing class. Now

in this case, we can actually shorten this by removing the reference to companion altogether.

That new companion is implicit and if you're using it from Kotlin, you can leave it off.

However, if you were using this companion object from Java, you would have to reference

that companion object instance directly. You can also rename your companion object. So

if we wanted to name this something like factory to be a bit more explicit, we can then say

doc factory and reference it that way. And so again, not needed from Kotlin but it could

be a good way to make your code more understandable from the Java side of things. If you're doing

a lot of Java to Kotlin interrupt, we can also store properties within our companion

objects as well. So in this case we can create a const thou well

ID equals IB and then we can come down here and replace our entity and pass that in. Now

that we have this ID property added to our companion object, we can reference it from

other calling code as if it was a static property like we're familiar with from Java. So we

could do that by typing entity dot. And then we can reference that ID property directly.

Now competing objects are like any other class and that they can also implement other interfaces

to demonstrate that we'll create a new interface called ID provider with a single method this

called get ID. It will return a string. Now then come down to our companion object declaration

and we can make it implement ID provider the same way we would with any other class. We

can then choose to implement the required members and then here we will just return

a simple ID and so now when we create our instance of ID, we could rely on this ID method

if we want it. So you see companion objects can be quite flexible if you need them to.

You could use those to compose other types of behavior, store your semi static properties

or methods and use them to create factories by referencing private inner properties or

methods of the enclosing class. This is really what you would want to leverage if you want

functionality similar to that of static members

and field from the world of Java. Now that we've covered object expressions and companion

objects, let's take a look at creating an object declaration. To start, we're going

to clean up some of this code we've been working with so we will remove this implementation

of ID provider and we will go back to using a placeholder ID. We'll remove this reference

to entity ID and we can remove this ID provider interface. Now what our object declarations

and object declaration is a convenient way of creating threads saved singletons within

Kotlin. We can do this by using the object keyword and then a class name in this case

entity factory. Now within this you can add any types of properties or methods that you

would like. So let's start by migrating our create method from our companion object into

heart entity factory and now we can remove that companion object and instead we can reference

entity factory dot create.

Now there's one small problem with this so far, which is that entity still has only a

private constructor. Now we're going to remove that private modifier for now so that we can

use that constructor. However very shortly we will continue to refactor this code to

limit the ways in which entities can be created. Now before we go on and continue to explore

some of these other class types in Kotlin, let's add to our entity class by implementing

two string so that if we print out an instance of entity, we get some nice user readable

text. So we can start typing two string. And then I'll use a string template here and we'll

say ID colon is ID. And then we will also add in a name property here, Val name of type

string.

And then we'll say name and then substitute in that main property. And then here in our

create method we will just put in a generic name. And now down here we can use a print

line statement and pass in our instance of entity. And now we see our new two stream

texts being printed out to the console. So this will help us going forward demonstrate

some of how these other classes are going to work. All right, now that we can print

out useful information about an instance of an entity, let's refactor our create factory

method to actually differentiate instances of entity. So to do this, we're going to change

this and make it no longer a single expression function. So we will add a return type of

entity and then we'll add a return keyword. And that will, we'll add entity. Now the first

thing you want to do here is actually add a proper ID value.

So here you could say Val ID equals you do ID dot random U U ID dot two string. So this

will give us a new random identifier and then we can pass that into our entity. But now

we have this main property. So what can we do to pass in a name here? Well one thing

we might do is think about differentiating between different types of entities. So in

a very basic case, maybe you want to differentiate between easy, medium, and hard difficulties

of these entity types. So we might want to then have some way of passing or indicating

to this factory method, what those different types should be. So what am I, we could do,

this is with an ENM class. Now if you're familiar with Java and Enim class is going to be very

similar to what you're familiar with from [inaudible] in Java. To do that, we can start

typing email and then class. And then in this case we might name this something like entity

type and open and closed curly braces. And then we can iterate the different instances

of the email. So in this case we might say easy, medium, hard. So now we can come down

here to our create method and then we can add a type parameter of entity type.

And so now we could say vow name equals when type. And then we are going to add in the

remaining branches. So now we have a branch for each of our entity types. And then for

a basic name, I'm just going to map these to a string. So say easy, medium and hard.

And so now I can pass in that name. So now our factory method actually allows us to differentiate

and create different types of instances. So down here we might start off by creating an

easy entity and then we'll print that out. And then we might say vow medium entity equals

entity, factory dot. Create entity tight medium. And then we can print that out as well.

And if we run this well, now see that we have a unique identifier for each entity. And then

we have the customized name based on that entity type. So the addition of this ENM class

to represent our entity type has allowed us to pass in different types to our factory

method and then customize the way that those entities are created by mapping the entity

type to a name. Now in this case, we're mapping the name very closely to the name of the actual

class itself. So to make this a little bit easier and more encapsulated, there's a couple

of things we could do. So the first thing we could do is take advantage of the name

property on an ITAM class. So to do that, we could reference our type dot nay. So this

is referencing the name of that actual [inaudible] class. And if we run this, we can see what

that name looks like.

So you see it's easy all in capital letters. This matches exactly the way that the class

name is actually defined. So this allows us to reference the classes name directly without

having to map it manually. Now this is nice, however, we don't have a lot of control over

the formatting here. So another thing we could do is actually add a new method to argue in

class. So in this case we get add fun, get formatted name, and then we can reference

that named property.to lowercase dot capitalize. So this will return us that preform at a name

and capitalize the first letter. So now down here we can update our medium mapping and

type type dot get format in name. And so now if we run this code again, we'll see that

the first one by using the name property directly is all capitalized. But now by using our new

format and method, we have a nicer format similar to what we were using before. So that's

just one example of how you can define an Enon class and then add additional properties

and methods that class like you would any other class.

Now let's continue refactoring this code to further differentiate between different types

of entities. To do that, we're going to leverage a sealed class seal classes allow us to define

restricted class hierarchies. What this means is that we could define a set number of classes

all extending a base type, but those classes will be the only ones that can extend that

base type. So one example of this could be a loading state or results state for a network

operation. It's either going to succeed or fail and there aren't really any other options.

So in the right place we're going to create a sealed class with an easy, medium, hard

and help entity types. To start creating our sealed class hierarchy. We're first going

to remove the properties from our entity class as well as this existing override of the two

string method. The next step is to add the sealed keyword before the class keyword in

the entity class declaration.

As soon as we do that, we'll start getting an error above where we tried to create an

instance of entity. This is because you can't instantiate based sealed class type directly.

So this is now where we will create each type within our sealed class hierarchy. So the

first type we're going to create is a David class to represent easy entities. And then

we will add the properties we want in this case the ID and name, and then we want to

make sure that we inherit from entity. So next up we can copy that and update the name

for the medium type. And now for the third type, once again we'll copy that, we'll name

this hard, but now we're going to add an additional property. This property will be called multiplier

and we'll be afloat and this can represent some type of difficulty, multiple fire if

we were creating a game for example.

Now notice that all of these types within the sealed class all extend from entity but

have different types of properties. This is one of the key differentiators between sealed

classes and [inaudible] classes. With seal classes, you can have different properties

and methods on each of these type and the compiler can perform smart casting to allow

you to use these different properties and methods as you would like. We can also use

different types of classes itself within our sealed class. So you notice that these are

all created as data classes. However, if we wanted to remove data from one of these, that

would be perfectly fine. We could also use object declarations within our seal class

hierarchy. So this case will create an object class called help to represent some type of

generic static help entity within our program. Now because help doesn't have a constructor

because it's static. In this case, we can add a class body and we could add a name and

add help directly. And in this case, more ad ID. Since it's a Singleton and there's

only going to ever be one instance anyways,

now that we have our seal classes defined, we're going to update our factory method to

instantiate and return different types of entity classes. So we'll come up here to our

return statement and instead of returning an entity directly, we're going to use a wind

expression based on the entity type being in class. We'll then add all of the needed

branches. And so when we have an easy type, we want to instantiate an instance of the

easy class. So to do that we'll type D Z and then we will pass an ID and name. And similarly

for media type, entity dot. Media ID, combat name. And now for hard, once again we'll pass

it and entity dot hard ID name. But now again we have this additional property type and

the compiler recognizes that. So for now we'll just pass it in to F as our multiplier.

Now notice though that we have this help entity being unused. So let's update the factory

to allow us to create instances of the help type. So we'll come up to our entity type

Unum class and add a help type here. Now notice as soon as we added that additional type on

the entity type in them class are when expressions one to us that we need to add an additional

branch. So to do that, I'll add the remaining branch here and I'll default to typed up get

format name. And once again below here I'll add the remaining branch. And in this case

I'm just going to return help directly.

Oh, notice here that help is giving us an error. It's saying required and to be found

entity that help. This was done to demonstrate what happens if you do not extend from the

base entity type. So if we come down to our entity class here and you notice our object

declaration for help, if we then add a colon entity to extend from entity, we'll now see

that error go away. So this is a good example of how the compiler can help give us this

nice static type checking and all of these things. And if we are combining even classes

was sealed classes with these, when expressions get allows us to be sure that if we add a

new type or a new branch somewhere that we have to handle that effectively because the

compiler will warn us or even give errors if we're not handling all of those different

branches. Now let's come down to our main function and demonstrate one of the advantages

of representing our entities as a seal class hierarchy.

So if I remove everything, but this first instance of creating an entity, I'm going

to specifically add a type here of entity. And so now if we, if we come down again, we

can use a one expression and we'll say, now we can go down here and use a wet expression

to do some type checking about the entity that we have just instantiated. So here we'll

say Val, message equals when entity. And now again we're going to rely on the IBE to add

all the remaining branches. So there's a few things of interest to note here. So we'll

see that for an easy, medium and hard, it's adding. This is check. So this is going to

basically tell if it's an instance of that class or not. But then notice for the help

class, because that's an object declaration and as a Singleton there's no need to have

it is.

So in that case we can reference that class directly. And so now here we could add whatever

message we wanted. So we could say help class, easy class, medium class and hard class. And

then if we simply print that message out and run the code, we can see in this case we're

getting an easy class. And then if we change what we pass into our factory method and rerun

this, well now see that we're getting the help class. So now we have static type checking

both and specifying what type of entity we want back and and checking the type that we're

actually getting back from that. And so we could use this to then call any methods or

properties that are specific to that class. And if we were operating on these types as

in a one expression here, if we ever added a new type, that compiler would be sure to

make sure that we handled the addition of that new type.

So now let's return to our sealed class hierarchy for a second and dive more deeply into what

data classes are. So you see here both easy and medium and hard are all defined as data

classes. Data classes are cotton's way of providing very concise, immutable data types.

By defining a class as a data class, it means that it is going to generate methods such

as equals hashcode into string automatically for you. What this allows us to do is perform

a quality comparisons on instances of these data classes and treat them as equal if the

data they contain is equal. So here's an example. Let's explore what this looks like. So we

can say Val entity one equals entity factory that create and will create an easy entity.

And then we're going to create another version of this. And then now we can check their equality

comparison.

So you can say if entity one equals entity two per DeLeon, they are equal else per Delon,

they are not equal to. Now if we run this, what will we see? They are not equal. And

that's to the expected. That's because if we come back up to our factory, we'll notice

that we are creating different unique ideas each time. So even though that the name is

the same, the unique ID is different. So now let's update this and see what it looks like

if we pass the same data in. So in this case we could create an easy directly and this

case will pass in ID comma name and then we will duplicate this for entity two. And so

now if we run this, we're going to expect to see you. They are equal and of course they

are. So this is really convenient. This allows us to represent data within our applications

and compare this data no matter where it comes from.

And as long as those properties are all the same, we're going to be able to evaluate these

as true. Now another really interesting thing that data classes give us are effective copy

constructors. So we can create an instance of entity two by copying entity one entity,

one dot copy. And because this is a direct copy, if we run this once again, we're going

to see they are equal. However, we could also use named arguments with the copy constructor

to change the value. So let's say we only wanted to change the BAME and you could say

name equals new name. And once again, if we rerun this, we're going to see they are not

equal. So you could see changing a single property and the data class is going to impact

whether or not two instances evaluate to true or not when compare.

Now one thing to notice is this is comparing the value of the data themselves. If we wanted

to U S referential comparison, we hit add a third equal sign here and this will check

whether or not it's the exact same reference or not. So in this case they are not equal.

However, this isn't all that surprising since the data was also equal. So what about if

we revert this and make this an exact copy again? So before if we were just using two

equal sign, the data would be the same. So it would print, they are equal. However, by

using three equal signs and using referential equality, we see they are not equal. That's

because it's not the same exact reference of the object. If we updated this to be entity

one equal equal equals entity one and run this, now we'll see they are equal.

So that's just one way in which we can check whether or not we have the exact same object

or if it's two different objects that have the same data. Now also keep in mind that

these equality comparisons are working off of the generated equals and hash code methods

generated by the compiler when indicating a data class. However, we could update this

to change how the equals or hash code is evaluated and to do that we would do it like any other

class. We could add a class body and then we could simply override equals and or hash

code. Now as in Java best practice, if you're going to override one of these, you should

really override both of them and you have to follow the same rules, but you have that

freedom if you would like to.

Another really useful feature in Kotlin is the ability to define extension functions

or extension properties on an existing class. This is particularly powerful if you're working

with classes that you can't control but would like to modify the way in which they're used.

You can define your own properties and methods and defined kind of a new API around the existing

class. So an example of this would be adding a new method to the medium class without actually

defining that method within the definition of the medium class. So to do that, let's

come down here and you can start off by typing the fun keyword. And then instead of directly

typing the method name, we can reference the class name. Dot. And this case will type print

info.

And then we can define our function buddy. So in this case we'll just say medium class

with the ID and that'll be it. And so if we wanted to come down here and now create an

instance of entity dot medium directly, we could do that. And then we could call that

print info method. And if we run that code, we'll see a medium class and then that ID

printed out. So this is great if we know that we have that exact type that we're working

with. And in cases where we don't know if we have that direct type, we could rely on

smart casting. So if we update this to you, their factory say entity factory, create entity

type medium. Now we can say if entity two is medium entity, now we can reference that

new print info method.

This is done because the if statement will only evaluate to true if that cast is successful.

So anywhere within that context it will automatically perform the smart cast for us. And like I

said before, not only can we define extension methods, but we can also define extension

properties as well. To do that, we could start off by saying Val or VAR. In this case we'll

say vow and then again we'll reference the class type. So medium dot we'll say info will

be this property name string equals some info. If you do that, notice that we have this air.

If you look, it says extension property cannot be initialized because it has no backing field.

So to actually create an extension of property for an existing class, you need to rely on

backing fields. Thankfully the IDE can generate this forest, convert extension property initializer

to a getter.

So once we do that and notice here that we have still defined our property but now we're

relying on this custom getter for that property and so now if we come back down here within

our, if statement that's doing our smart cast for us, we could reference that new info property

directly. So this is how extension functions and properties work. You could use these anytime

you want to add additional functionality to existing class. You might notice within the

Kotlin standard library that many functions and operations work by using extension functions

in classes be are particularly effective when using them with template ID types

because it allows you to define the same common functionality across any type that matches

that template. Now up until this point, we've covered a lot of things. We've looked at the

basic type system of Kotlin, how to work with different variable types, how to work with

basic functions and then diving into more advanced functional topics like named arguments

and default parameter values. And then we took a deep dive into modeling data with Kotlin.

So now I'm going to circle back to functions and specifically take a look at higher order

functions and how to work with functional data types. Now what are higher order functions?

Higher order functions are functions that either return another function or that take

functions as perimeter values. Now much of Kotlin standard library is built on top of

higher order functions and it's what really allows us to write highly functional code

by leveraging that standard library.

So let's take a look at how we can write our own higher order function. To start we have

a new Kotlin file and we're going to define a new function. So we'll call this fun. And

then we're going to call this print filtered strengths. And now the first argument to this

is going to be a list of strings. So we'll call this list and then define it as list

of string. And now the next thing we're going to do is define a parameter which will in

fact be a function. That function will take in a string and return a bullying. We can

then use that to filter out values in the past collection. So to define a function parameter,

you could start off by defining the parameter name as usual. And this case, we'll name it

credit kit, followed by colon. And now you have to define the type as you normally would

to define a functional type.

You can start by adding your parentheses. This will define the parameters of the function

being passed in to your other function. So in this case we are going to take a string.

He'll then add the arrow, and then you want to define the return type. So in this case,

that will be bullying. And now we'll add the open and closed curly braces to define our

block body. So now we have a parameter called predicate, which will be a function that takes

in a string parameter and returns a Boolean. Now we can implement our print filtered strings

function to make use of that predicate function to filter out any strings in that past list.

So to implement this function, first off, we want to iterate over each string in the

past list. So to do that, we could say list doc for each and now we will be able to iterate

over each of those strings.

So now what we want to do is evaluate the predicate for each stream in the collection.

So we can call the predicate function in several different ways. So to start we'll say if,

and then the easiest way to invoke the predicate is to simply say predicate open and close

parentheses and pass in the parameter value. A parameter that is a functional type can

be called as if it was a regular function. As long as you can satisfy the required arguments.

So in this case we can say if predit kit returns true, then we can print out that string. Now

to test this, we'll come down here and we will add a main function and we will say vow

list equals list of, and then we can say something like Kotlin, Java C plus plus Java script.

And now we could call print filtered strings pass in our list.

And now we need to pass in a function as the second parameter to print filters, drinks.

So we can do that by specifying a Lambda, and in this case we will say it starts with

K. so this Lambda is going to evaluate to true if any of the past strings begins with

a K. now if we run this function, we'll see only Kotlin print it out to the screen. If

we were to update this to print things out, that started with a J, well now see Java script

and Java. Now one thing to notice is it in our invocation of print filtered strings,

we've passed our Lambda within the parentheses of that function in vacation. However, this

is something that we don't have to do. As we mentioned earlier, we can take use of Landus

syntax, which says that if the last parameter of a function is a function, you can specify

that as a Lambda outside the function body. So we can restructure our function to look

like this. We can pass in the list first and then specify or Lambda outside of the parentheses.

So this is actually very similar looking to the for each function which we called up above.

And in fact if you look at the implementation of for each is in fact a higher order function.

The Lambda that we specify after invoking for each is a function which will operate

over each string and that list. Now if we come back up here to our implementation notice

we are calling the function parameter directly as if it was a regular function. So this works

absolutely great in most situations. However, if we were to make this function, type a NOLA

ball type by wrapping it in parentheses and adding new question Mark. Well now see an

error in our implementation of print filtered strings. That error basically says that you

cannot invoke that function parameter by using the parentheses directly. If it's a nullable

type to get around this, we can make use of the invoke method on that functional type

and then we can make use of the safe call operator and now, but updating this to do

a safe invoke call on the predicate function.

We can handle this rather not the predicate is no calling invoke will invoke the function

just as it would any other indication of a function. So now down here nothing has changed

and how we can call print filtered strings. However, we could also pass it in list and

now we could pass in no as a no function. So we've seen how we can treat functions as

parameters to other functions and these function parameters are really treated as tight. Just

the same as let's say integer or string. Caitlyn has this idea of functional types. It's a

first-class part of the language. This means that we could define a variable of a functional

type and then pass that variable in any time. We needed a function parameter that matched

that function signature. So an example of this might be something like vow credit kit

and then we will define our function type to match that of our print filtered strings

function.

So in this case it'll take a string and return bullion and now we'll define our function

the same way that we were doing it before. By saying if the string starts with aJ , go

ahead and return true. Now instead of invoking print filters, strings with a landed pass

to it, we can pass in our predicate variable directly. And now if we run this, we'll see

the same output as we would before. So this allows us to store function as variables.

This can be really useful for things like optional input handling. For example, maybe

you have a view on some screen and you want to be able to specify a ClickList center for

that view. You could define that as a Lambda property on some class and allow client code

to set that ClickList center as needed. As we mentioned before, higher order functions

include functions which take other functions as parameters, as well as functions that return

other functions.

So let's define a function called get print predicate and it'll take no parameters, but

we defined its return type as a function which takes a string and returns a bullion. And

now we can return that value by saying return. And then we could pass a Lambda and say it.

That starts with J. So we're passing essentially the same type of Lambda that we've been using

in these other examples. But now we've wrapped it in this other function and so now and so

then passing predicate directly or instead of defining a new Lambda as our function parameter,

we could instead call get print predicate as a function on its own, which will then

return a function which then can be used as the predicate for print filtered strings.

And if we run this once again, we'll see that our output hasn't changed though. So higher

order functions can work as both inputs and outputs and Kotlin allows you to define properties

with functional types.

So through this function's really become a very powerful and first-class part of the

language that can start to replace a lot of other instances. For example, you might find

yourself relying more heavily on functions to define things like event or a ClickList

centers rather than defining concrete interfaces for those same types of functionality. Now

this was recently mentioned. Much of the Kotlin standard library is built around higher order

functions and especially a higher order functions defined with generic types. So if we look

at the implementation of four each, well notice that this is actually an extension function

as well as a higher order function. So for each works on generic Iterable type and takes

in a function parameter that takes in that generic type and returns unit. So this essentially

allows us to iterate over each element in the collection and then call that action on

it and it doesn't have to return anything.

And similarly for each index takes in a single function parameter as well. But this one takes

in an event to represent the index as well as the generic type. This allows us to iterate

over each element in the collection while incrementing a counter and then passing that

counter into the function parameter as the index. The power of generic types, extension

functions and higher order functions allows us to write single implementations of these

methods and then reuse them over any type that we can think of. Now this is very powerful

and can allow us to write much more functional code without having to redefine these methods

and functions for all of our different types. So let's take a look at example of how we

can combine some of these different functional operators to perform complex operations with

very little code. We'll come into this new main function here and we'll start off by

defining a list of strings.

Once again. Now let's look at some ways in which we can chain these functional operators

together to do more interesting things. So as we've seen before, we can do a simple for

each to iterate over each item in this collection and print it out. And if we run it, we'll

notice that we see all of the programming language printed out to the console. Now what

if we wanted to print out only the strings that start with J plus similar to the functions

we were working with before, we could do that by making use of a filter operation. So we

have a lot of options to choose from. In this case, we will just choose a generic filter

and then we will use a predicate which says it starts with J and now if we run this was

he, he had only Java and Java script printed out. Now, what if our collection included

some no values?

So as soon as we add, no, we see now here in our filter operation, it's warning us that

Hey, this value might be no, you need to add a safe call weld in Kotlin. Oftentimes we

don't want to work with no, we want to try and hide no as much as possible. And so we

could make use of another functional operator called filter not know. What this does is

immediately filter out any no values up front. So everything past that in the functional

chain will be guaranteed to be not. No. So as soon as we added filter, not know, we no

longer had to deal with a possible no string. And if we run this once again, we'll see only

Java and JavaScript printed out.

Now what if we wanted to change the type of this? Let's say we wanted to convert this

from a string to an integer, which represents the length of that input string. We could

do this type of transformation using a map function. The map function will take in whatever

the previous type is in this case string, but it'll allow us to return any other type

we want. So in this case, we might define our map function as simply returning the length

of the string. As soon as we've done that. Now below that in the for each, the type has

changed from string to end. And now if we print this out, we'll see four and 10 printed

out for representing the four characters in Java and 10 representing the 10 characters

in Java script. Now let's remove this mapping and let's remove the filter. And instead,

let's imagine that we want to take only a certain number of items from this collection.

So we can do that by using the take function and passing in. Let's say three. What that'll

do is we'll take the first three items from that collection and then we'll be printing

out each of those three names. So you see in this case we're getting Kotlin, Java and

C plus plus. Alternatively, if we didn't want to take the first three elements in the collection,

we could use take last today, the last three. So in this case we see Java C plus plus and

Java script and it has skipped over Kotlin since that was not one of the last three elements.

We can also do other transformations such as associating the input values with some

other value to return a map. So let's create a map that essentially maps the string to

the number of characters in that string. So to do that we could say associate, and then

in this case we could say it to it dot length. And so now in our, for each function, instead

of iterating over strings, we're iterating over map entries of string and event. So in

this case we can now use a template string and say it got value comma it dot key.

And if we print this out, we'll see the length comma followed by the name. This makes it

really easy to map all of the input strings to some other value and then iterate over

that map. Now, what if we didn't want to iterate over the map but instead just wanted to hold

on to that in a variable? Well, instead of using a fork each at the end, we could assign

this to a variable just like this. The continent standard library also provides a variety of

functions to help us pull out individual elements from a collection to demonstrate that that's

created a variable called language. And then we're going to perform different operations

on our list to grab a single language string from our list. So we could do that in a number

of ways. We could say list dot first and if we print this out, we'll expect to see Kotlin

as that is the first language in the list.

Alternatively, we could say we'll start last and in this case you'll see that it's actually

printing out. No, since [inaudible] was the last value in that list. Now, if we didn't

want to retrieve a null value from our list and instead wanted the Alaskan non-male value,

once again, we could add the filter, not no function, which we used previously. And now

if we rerun this, we'll see Java script printed out instead, since this is the last non no

value. Now what if we wanted to find a specific item in the list? Let's say we wanted to use

the find function and in our predicate we'll say it got starts with and we'll pass in Java

as a street. So this is going to find the first value in this list that starts with

Java. So in this case it actually returns us Java and alternatively we could use find

last to find the last element in the collection that matches this predicate, in which case

it's going to return JavaScript.

Now what happens if we are searching for a string which doesn't match our predicate?

We can test that by looking for a string which starts with food. If we then run this, we'll

see no print it out to the console. This is because there is no matching string. So fine.

Last is going to return. No. And then the print line statement, we'll print out. No

if it has a null value. Well what if we didn't want to work with no? What if instead we wanted

to use an empty string as the placeholder? Well, strings in Kotlin have a useful function

called or empty. So we can actually chain that directly off of find last here and call

or empty. So at this will do is return either a nano string or a static empty string. So

now if we run this once again, instead of no, we're just seeing empty, we're not printing

anything out.

So this is one way in which you could default your collections or your strings to an empty

value as opposed to a no value. And this is something you might want to consider doing

more and more of in Kotlin as you start to move away from relying on null. So as we've

seen, Caitlyn has first-class support for functions including functional types and higher

order functions, and the Kotlin standard library builds upon those tools and provides a rich

set of functional operators for us to use. This allows us to build powerful functional

chains to transform our data and make complex workflows much simpler. All right, that's

it for this tutorial. You now have a good understanding of the fundamentals of Kotlin

and how to work with it, and you're now ready to start taking that knowledge and applying

it to other domains. Until next time, devs.