To run the code in this chapter, you will just need Android Studio and Git installed. This chapter won't require any additional installations.

You can find examples from this chapter on GitHub, at the following link: https://github.com/PacktPublishing/Learn-Spring-for-Android-Application-Development/tree/master/app/src/main/java/com/packt/learn_spring_for_android_application_development/chapter2.

The 3.0 version of Android Studio was released by Google, and it promoted Kotlin as a first class language for Android development. Kotlin is developed by JetBrains in the same way as the Intellij IDEA platform, which is the basis of Android Studio. This language was released in February 2016, it was in development for five years before it was released. It's easy to gradually convert the code base of a project from Java to Kotlin, and a developer that is familiar with Java can learn Kotlin in a few weeks. Kotlin became popular before its release, because this language is full of features and is designed to interoperate with Java. The following diagram shows how Kotlin and Java code are compiled to the same bytecode:

As you can see, part of our application can be written in Java and another part in Kotlin. The kotlinc compiler compiles Kotlin source...

To get started with Android development, you will need to download and install the Java Development Kit (JDK) from http://www.oracle.com/technetwork/java/javase/downloads/index.html. You will also need to download and install the Android Studio Integrated Development Environment (IDE), from https://developer.android.com/studio/.

To create a new project, launch Android Studio and press Start a new Android Studio project. Then, you should type a project name and your unique application ID, as shown in the following screenshot:

In the preceding screenshot, the Application name field is filled according to the name of this book, and the Company domain field is packt.com. Android Studio concatenates these two values and creates the Package name identifier that is equal to the application ID identifier. In our case, the application ID is as follows:

com...

Android Studio is an official IDE for Android development, and it is based on the Intellij IDEA platform and uses the Gradle build tool system. A typical project structure looks as follows:

The build.gradle file contains the project configuration and manages the library dependencies. To add a dependency to the Spring for Android extension, we should add the following lines:

repositories {
    maven {
        url 'https://repo.spring.io/libs-milestone'
    }
}

dependencies {
    //.......
    implementation 'org.springframework.android:spring-android-rest-template:2.0.0.M3'
}

Syntax is a significant part of the programming language, defining a set of rules that must be applied to combinations of symbols. Otherwise, a program can't be compiled, and will be considered incorrect.

This section will describe the basic syntax of Kotlin, covering the following topics:

• Defining packages
• Defining variables
• Defining functions
• Defining classes

Packaging is a mechanism that allows us to group classes, interfaces, and sub-packages. In our case, a declaration of a package in a file may look as follows:

package com.packt.learn_spring_for_android_application_development

All citizens of the file belong to this package and must be located in the appropriate folder.

Object-oriented programming is a model of programming language that is based on objects that can represent data. Kotlin supports object-oriented programming in the same way that Java does, but even more strictly. This is because Kotlin doesn't have primitive types and static members. Instead, it provides a companion object:

class Bar {
    companion object {
        const val NAME = "Igor"

        fun printName() = println(NAME)
    }
}

The companion object is an object that is created once, during class initialization. In Kotlin, we can refer to members of companion object in the same way as static in Java:

fun test() {
    Bar.NAME
    Bar.printName()
}

However, under the hood, the nested Companion class is created, and we actually use an instance of this class, as follows:

Bar.Companion.printName();

Moreover, Kotlin supports the following...

To define a function in Kotlin, you have to use the fun keyword, as follows:

fun firstClass() {
    println("First class function")
}

The preceding snippet demonstrates that we can declare functions as first class citizens. We can also define functions as class members, as follows:

class A {
    fun classMember() {
        println("Class member")
    }
}

A local function is a function that is declared in another one, as follows:

fun outer() {
    fun local() {
        println("Local")
    }
    
    local()
}

In Kotlin, control flow elements are expressions. This is different from Java, in which they are statements. Statements just specify the flow of a program, and don't return any values. This section will cover the following control flow elements:

• The if { ... } else { ... } expression
• The when { ... } expression

In Kotlin, the if control flow element can be used in the same way as it is used in Java. The following example demonstrates the use of if as a usual statement:

fun ifStatement() {
    val a = 4
    if (a < 5) {
        println(a)
    }
}

If you are using the if { ... } else { ... } control flow element as an expression, you have to declare the else...

Kotlin supports the concept of ranges, which represent sequences of comparable types. To create a range, we can use the rangeTo methods that are implemented in classes, such as Int, in the following way:

public operator fun rangeTo(other: Byte): LongRange = LongRange(this, other)

public operator fun rangeTo(other: Short): LongRange = LongRange(this, other)

public operator fun rangeTo(other: Int): LongRange = LongRange(this, other)

public operator fun rangeTo(other: Long): LongRange = LongRange(this, other)

So, we have two options for creating a range, as follows:

• Using the rangeTo method. This may look as follows—1.rangeTo(100).
• Using the .. operator. This may look as follows—1..100.

Ranges are extremely useful when we work with loops:

for (i in 0..100) {
    // .....
}

The 0..100 range is equal to the 1 <= i && i <= 100 statement.

If you want...

Kotlin supports one more powerful feature—string templates. Strings can contain code expressions that can be executed, and their results concatenated to the string. The syntax of the string template assumes that we use the $ symbol at the start of an expression. If the expression contains some evaluation, it has to be surrounded by curly braces.
The simplest use of string templates looks like the following:

var number = 1
val string = "number is $number" 

A more advanced example that contains an expression is as follows:

val name = "Igor"
val lengthOfName = "length is ${name.length}"

As you can see, the string templates feature allows us to write code in a more concise way than the usual concatenation or the StringBuilder class.

Although we have already covered the most common topics that relate to a basic overview of Kotlin, there are a few more topics that have to be touched upon.

This section will introduce the following topics:

• Null safety
• Reflection
• Annotations

Kotlin supports a more strict type system when compared to Java, and divides all types into two groups, as follows:

• Nullable
• No-nullable

One of the most popular causes of an app crashing is the NullPointerException. This happens as a result of accessing a member of a null reference. Kotlin provides a mechanism that helps us to avoid this error by using a type system.

The following diagram shows what the class hierarchy looks like...

In this chapter, we took a close look at the basic syntax of Kotlin. We also introduced and looked at examples of some features, such as lambdas, string templates, and ranges. Furthermore, you learned that control flow elements, such as if { ... } else { ... } and when { ... }, can be used as expressions that can make our code more concise and readable.

In the next chapter, we will take a look at an overview of the Spring framework.

1. What is Kotlin?
2. How does Kotlin support object-oriented programming?
3. How does Kotlin support functional programming?
4. How do we define variables in Kotlin?
5. How do we define functions in Kotlin?

Kotlin Quick Start Guide (https://www.packtpub.com/application-development/kotlin-quick-start-guide) by Marko Devcic, published by Packt.