Kotlin

Posted on 19th Oct 2023 00:00:00 in pinned

Tagged as:

https://developer.android.com/codelabs/basic-android-kotlin-compose-variables?continue=https%3A%2F%2Fdeveloper.android.com%2Fcourses%2Fpathways%2Fandroid-basics-compose-unit-1-pathway-1%23codelab-https%3A%2F%2Fdeveloper.android.com%2Fcodelabs%2Fbasic-android-kotlin-compose-variables#2

https://developer.android.com/training/kotlinplayground


fun main() {
val count: Int = 2
println(count)
}

fun main() {
val count: Int = 2
println("You have $count unread messages.")
}

When you run the program, the output matches the desired goal:

You have 2 unread messages.

fun main() {
val unreadCount = 5
val readCount = 100
println("You have ${unreadCount + readCount} total messages in your inbox.")
}

Run the program and it should display the total number of messages in the inbox:

You have 105 total messages in your inbox.

For example, modify your program to print this out:


100 photos
10 photos deleted
90 photos left
Here's one way that you can write your program, though there are other correct ways to write it too!


fun main() {
val numberOfPhotos = 100
val photosDeleted = 10
println("$numberOfPhotos photos")
println("$photosDeleted photos deleted")
println("${numberOfPhotos - photosDeleted} photos left")
}

fun main() {
birthdayGreeting()
}

fun birthdayGreeting() {
println("Happy Birthday, Rover!")
println("You are now 5 years old!")
}

Run your code. You should see the following output:

Happy Birthday, Rover!
You are now 5 years old!

Return a value from a function

In more complex apps, functions do more than print text.

Kotlin functions can also generate data called a return value which is stored in a variable that you can use elsewhere in your code.

When defining a function, you can specify the data type of the value you want it to return. The return type is specified by placing a colon (:) after the parentheses and the name of a type (Int, String, etc) after the colon. A single space is placed after the return type and before the opening curly brace. Within the function body, after all the statements, you use a return statement to specify the value you want the function to return. A return statement consists of the return keyword followed by the value, such as a variable, you want the function to return as an output.

The Unit type
By default, if you don't specify a return type, the default return type is Unit. Unit means the function doesn't return a value. Unit is equivalent to void return types in other languages (void in Java and C; Void/empty tuple () in Swift; None in Python, etc.). Any function that doesn't return a value implicitly returns Unit. You can observe this by modifying your code to return Unit.

In the function declaration for birthdayGreeting(), add a colon after the closing parenthesis and specify the return type as Unit.

fun main() {
birthdayGreeting()
}

fun birthdayGreeting(): Unit {
println("Happy Birthday, Rover!")
println("You are now 5 years old!")
}

Run the code and observe that everything still works.

Happy Birthday, Rover!
You are now 5 years old!

It's optional to specify the Unit return type in Kotlin. For functions that don't return anything, or returning Unit, you don't need a return statement.

Note: You'll see the Unit type again when you learn about a Kotlin feature called lambdas in a later codelab.


Return a String from birthdayGreeting()
To demonstrate how a function can return a value, you'll modify the birthdayGreeting() function to return a string, rather than simply print the result.

Replace the Unit return type with String.


fun birthdayGreeting(): String {
println("Happy Birthday, Rover!")
println("You are now 5 years old!")
}

Run your code. You'll get an error. If you declare a return type for a function (e.g., String), that function must include a return statement.

A 'return' expression required in a function with a block body ('{...}')

You can only return one string from a function, not two. Replace the println() statements with two variables, nameGreeting and ageGreeting, using the val keyword. Because you removed the calls to println() from birthdayGreeting(), calling birthdayGreeting() won't print anything.


Using the string formatting syntax you learned in an earlier codelab, add a return statement to return a string from the function consisting of both greetings.
In order to format the greetings on a separate line, you also need to use the \n escape character. This is just like the \" escape character you learned about in a previous codelab. The \n character is replaced for a newline so that the two greetings are each on a separate line.

fun birthdayGreeting(): String {
val nameGreeting = "Happy Birthday, Rover!"
val ageGreeting = "You are now 5 years old!"
return "$nameGreeting\n$ageGreeting"
}

n main(), because birthdayGreeting() returns a value, you can store the result in a string variable. Declare a greeting variable using val to store the result of calling birthdayGreeting().

fun main() {
val greeting = birthdayGreeting()
}

In main(), call println() to print the greeting string. The main() function should now look as follows.

fun main() {
val greeting = birthdayGreeting()
println(greeting)
}

Run your code and then observe that the result is the same as before. Returning a value lets you store the result in a variable, but what do you think happens if you call the birthdayGreeting() function inside the println() function?

Happy Birthday, Rover!
You are now 5 years old!

Remove the variable and then pass the result of calling the birthdayGreeting() function into the println() function:

fun main() {
println(birthdayGreeting())
}

Run your code and observe the output. The return value of calling birthdayGreeting() is passed directly into println().

Happy Birthday, Rover!
You are now 5 years old!


4. Add a parameter to the birthdayGreeting() function

As you've seen, when you call println(), you can include a string within the parentheses or pass a value to the function. You can do the same with your birthdayGreeting() function. However, you first need to add a parameter to birthdayGreeting().

A parameter specifies the name of a variable and a data type that you can pass into a function as data to be accessed inside the function. Parameters are declared within the parentheses after the function name.

Each parameter consists of a variable name and data type, separated by a colon and a space. Multiple parameters are separated by a comma.

Right now, the birthdayGreeting() function can only be used to greet Rover. You'll add a parameter to the birthdayGreeting() function so that you can greet any name that you pass into the function.

Within the parentheses of the birthdayGreeting() function, add a name parameter of type String, using the syntax name: String.

fun birthdayGreeting(name: String): String {
val nameGreeting = "Happy Birthday, Rover!"
val ageGreeting = "You are now 5 years old!"
return "$nameGreeting\n$ageGreeting"
}

The parameter defined in the previous step works like a variable declared with the val keyword. Its value can be used anywhere in the birthdayGreeting() function. In an earlier codelab, you learned about how you can insert the value of a variable into a string.

Replace Rover in the nameGreeting string with the $ symbol followed by the name parameter.

fun birthdayGreeting(name: String): String {
val nameGreeting = "Happy Birthday, $name!"
val ageGreeting = "You are now 5 years old!"
return "$nameGreeting\n$ageGreeting"
}

Run your code and observe the error. Now that you declared the name parameter, you need to pass in a String when you call birthdayGreeting(). When you call a function that takes a parameter, you pass an argument to the function. The argument is the value that you pass, such as "Rover".

No value passed for parameter 'name'
Pass "Rover" into the birthdayGreeting() call in main().


fun main() {
println(birthdayGreeting("Rover"))
}

Run your code and observe the output. The name Rover comes from the name parameter.

Happy Birthday, Rover!
You are now 5 years old!
Because birthdayGreeting() takes a parameter, you can call it with a name other than Rover. Add another call to birthdayGreeting() inside the call to println(), passing in the argument "Rex".

println(birthdayGreeting("Rover"))
println(birthdayGreeting("Rex"))

Run the code again and then observe that the output differs based on the argument passed into birthdayGreeting().

Happy Birthday, Rover!
You are now 5 years old!
Happy Birthday, Rex!
You are now 5 years old!

Note: Although you often find them used interchangeably, a parameter and an argument aren't the same thing. When you define a function, you define the parameters that are to be passed to it when the function is called. When you call a function, you pass arguments for the parameters. Parameters are the variables accessible to the function, such as a name variable, while arguments are the actual values that you pass, such as the "Rover" string.

5. Functions with multiple parameters

Previously, you added a parameter to change the greeting based on the name. However, you can also define more than one parameter for a function, even parameters of different data types. In this section, you'll modify the greeting so that it also changes based on the dog's age.

Parameter definitions are separated by commas. Similarly, when you call a function with multiple parameters, you separate the arguments passed in with commas as well. Let's see this in action.

After the name parameter, add an age parameter of type Int, to the birthdayGreeting() function. The new function declaration should have the two parameters, name and age, separated by a comma:

fun birthdayGreeting(name: String, age: Int): String {
val nameGreeting = "Happy Birthday, $name!"
val ageGreeting = "You are now 5 years old!"
return "$nameGreeting\n$ageGreeting"
}

The new greeting string should use the age parameter. Update the birthdayGreeting() function to use the value of the age parameter in the ageGreeting string.

fun birthdayGreeting(name: String, age: Int): String {
val nameGreeting = "Happy Birthday, $name!"
val ageGreeting = "You are now $age years old!"
return "$nameGreeting\n$ageGreeting"
}

Run the function and then notice the errors in the output:

No value passed for parameter 'age'
No value passed for parameter 'age'
Modify the two calls to the birthdayGreeting() function in main() to pass in a different age for each dog. Pass in 5 for Rover's age and 2 for Rex's age.


fun main() {
println(birthdayGreeting("Rover", 5))
println(birthdayGreeting("Rex", 2))
}

Run your code. Now that you passed in values for both parameters, the output should reflect the name and age of each dog when you call the function.

Happy Birthday, Rover!
You are now 5 years old!
Happy Birthday, Rex!
You are now 2 years old!

Function Signature
So far you've seen how to define the function name, inputs (parameters), and outputs. The function name with its inputs (parameters) are collectively known as the function signature. The function signature consists of everything before the return type and is shown in the following code snippet.

fun birthdayGreeting(name: String, age: Int)

The parameters, separated by commas, are sometimes called the parameter list.

You'll often see these terms in documentation for code written by other developers. The function signature tells you the name of the function and what data types can be passed in.

You've learned a lot of new syntax around defining functions. Take a look at the following diagram for a recap of function syntax.


6. Named arguments

In the previous examples, you didn't need to specify the parameter names, name or age, when you called a function. However, you're able to do so if you choose. For example, you may call a function with many parameters or you may want to pass your arguments in a different order, such as putting the age parameter before the name parameter. When you include the parameter name when you call a function, it's called a named argument. Try using a named argument with the birthdayGreeting() function.

Modify the call for Rex to use named arguments as shown in this code snippet. You can do this by including the parameter name followed by an equal sign, and then the value (e.g. name = "Rex").

println(birthdayGreeting(name = "Rex", age = 2))

Run the code and then observe that the output is unchanged:

Happy Birthday, Rover!
You are now 5 years old!
Happy Birthday, Rex!
You are now 2 years old!

Reorder the named arguments. For example, put the age named argument before the name named argument.

println(birthdayGreeting(age = 2, name = "Rex"))
Run the code and observe that the output remains the same. Even though you changed the order of the arguments, the same values are passed in for the same parameters.

Happy Birthday, Rover!
You are now 5 years old!
Happy Birthday, Rex!
You are now 2 years old!

7. Default arguments

Function parameters can also specify default arguments. Maybe Rover is your favorite dog, or you expect a function to be called with specific arguments in most cases. When you call a function, you can choose to omit arguments for which there is a default, in which case, the default is used.

To add a default argument, you add the assignment operator (=) after the data type for the parameter and set it equal to a value. Modify your code to use a default argument.

In the birthdayGreeting() function, set the name parameter to the default value "Rover".

fun birthdayGreeting(name: String = "Rover", age: Int): String {
return "Happy Birthday, $name! You are now $age years old!"
}
In the first call to birthdayGreeting() for Rover in main(), set the age named argument to 5. Because the age parameter is defined after the name, you need to use the named argument age. Without named arguments, Kotlin assumes the order of arguments is the same order in which parameters are defined. The named argument is used to ensure Kotlin is expecting an Int for the age parameter.

println(birthdayGreeting(age = 5))
println(birthdayGreeting("Rex", 2))
Run your code. The first call to the birthdayGreeting() function prints "Rover" as the name because you never specified the name. The second call to birthdayGreeting() still uses the Rex value, which you passed in for the name.

Happy Birthday, Rover! You are now 5 years old!
Happy Birthday, Rex! You are now 2 years old!
Remove the name from the second call to the birthdayGreeting() function. Again, because name is omitted, you need to use a named argument for the age.

println(birthdayGreeting(age = 5))
println(birthdayGreeting(age = 2))
Run your code and then observe that now both calls to birthdayGreeting() print "Rover" as the name because no name argument is passed in.

Happy Birthday, Rover! You are now 5 years old!
Happy Birthday, Rover! You are now 2 years old!