To follow the instructions in this chapter, you’ll need the following:

• IntelliJ IDEA Community Edition (https://www.jetbrains.com/idea/download/)
• OpenJDK 19 or higher (https://jdk.java.net/19/)

The code files for this chapter are available at https://github.com/PacktPublishing/Kotlin-Design-Patterns-and-Best-Practices_Third-Edition/tree/main/Chapter01.

If you’re familiar with Java, C#, Scala, or other similar programming languages, you’ll find Kotlin’s syntax quite familiar. This is by design, as Kotlin aims to facilitate a smooth transition for those with experience in other languages. Beyond solving real-world problems with features like improved type safety, Kotlin also addresses shortcomings inherent in other languages, such as Java’s notorious Null Pointer Exception (NPE) issue or the absence of top-level functions. The language maintains a practical approach that is consistently applied throughout its design.

One of the biggest advantages of Kotlin is its ability to work seamlessly with Java. You can use both Java and Kotlin classes together in the same project and freely use any Java library. However, it’s worth noting that this interoperability isn’t without its challenges, such as dealing with nullable types. So, while the integration is robust...

When you start programming in Kotlin, your first step is typically to create a new file, which usually has the .kt extension.

In contrast to Java, Kotlin doesn’t strictly enforce a one-to-one relationship between the filename and the class name. While you have the flexibility to include multiple public classes within a single Kotlin file, it’s generally considered best practice to group only logically related classes together in one file. Keep in mind that doing so should not make the file excessively long or difficult to read. Additionally, packing multiple public classes into a single file can make it harder to search for specific functionality, as the project overview may not display all available classes.

Naming conventions

As a convention, if your file consists of a single class, it is recommended to name your file the same as your class.

When your file contains multiple classes, the filename should describe the...

Previously, we stated that Kotlin is a type-safe language. Now, let’s delve into a Kotlin-type system and compare it to what Java offers.

Basic types

In some languages, a distinction is made between primitive types and objects. Java, for instance, has the int type for primitive values and Integer for objects. The former is more memory-efficient, while the latter is more expressive due to its support for null values and additional methods.

However, Kotlin does not make such a distinction between primitives and objects as Java does. From a developer’s perspective, all types in Kotlin are treated equally, and you typically do not deal with primitives directly, which is a significant departure from Java. In Java, you often need to consider whether you are working with primitives or objects when writing code.

Nonetheless, this difference does not imply that Kotlin is less efficient than Java in this regard. The Kotlin compiler optimizes...

There are three important groups of data structures we should become familiar with in Kotlin: lists, sets, and maps. We’ll provide a brief overview of each here, and then delve into topics related to data structures, including mutability and tuples, in more detail in Chapter 5, Introducing Functional Programming.

Lists

A list in Kotlin represents an ordered collection of elements of the same type. To declare a list, we utilize the listOf() function instead of calling the constructor of a specific list implementation. This function provides a convenient way to create a list and initialize it with elements:

val hobbits = listOf("Frodo", "Sam", "Pippin", "Merry")

It is important to note that we didn’t explicitly specify the type of the list. This is because type inference can be employed when constructing collections in Kotlin, similar to initializing variables.

If you prefer to...

You could say that control flow is the bread and butter of program writing. We will begin by exploring two conditional expressions: if and when.

The if expression

In Java, the if statement is not an expression and does not return a value. Let’s examine the following function, which returns one of two possible values:

public String getUnixSocketPolling(boolean isBsd) {
    if (isBsd) {
        return "kqueue";
    } else {
        return "epoll";
    }
}

While this example is easy to understand, it is generally discouraged to have multiple return statements, as it can make code more difficult to comprehend.

We can rewrite this method using Java’s var keyword:

public String getUnixSocketPolling(boolean isBsd) {
    var pollingType = "epoll";
    if (isBsd) {
        pollingType = "kqueue";
    }
    return pollingType;
}

In our previous example, we used a single return statement but had...

In the previous sections, we have explored numerous examples of working with text. After all, it is essential to utilize strings to output something as simple as “Hello Kotlin”. Attempting to achieve this without using a string would be both awkward and inconvenient.

In this section, we will delve into more advanced features that enable efficient manipulation of text.

String interpolation

Now, let’s assume we want to print the results from the previous section.

Firstly, Kotlin provides a convenient println() standard function that simplifies the usage of the bulkier System.out.println command from Java. We saw this when we looked at the Hello World example.

Moreover, Kotlin supports string interpolation using the ${} syntax, as seen in one of the previous examples. Let’s revisit the previous example:

val hero = "Batman"
println("Archenemy of $hero is ${archenemy(hero)}")

Executing the above...

Now, let’s talk about another common control structure: loops. Loops are essential for developers because they allow us to repeat a block of code multiple times. Without loops, it would be difficult to execute the same code repeatedly (although we will explore alternative approaches to achieve repetition without loops in later chapters).

The for-each loop

One of the most useful types of loops in Kotlin is the for-each loop. This loop allows us to iterate over strings, data structures, and any object that has an iterator. We will learn more about iterators in Chapter 4, Getting Familiar with Behavioral Patterns. For now, let’s see an example of using the for-each loop with a simple string:

for (c in "Word") {
    println(c)
}

When you run this code, it will display the following output:

> W
> o
> r
> d

The for-each loop can also be used with other types of data structures we have discussed, such as lists, sets, and...

Kotlin, being a language that aims for strong interoperability with Java and the JVM, shares a strong affinity with the Java programming language, which is class-based. Therefore, Kotlin also supports classes and classical inheritance. In this section, we will cover the syntax to declare classes, interfaces, abstract classes, and data classes.

Classes

In Kotlin, a class is a collection of data, called properties, and methods. To declare a class, you use the keyword class, similar to in Java. For example, let’s define a class to represent a player in a video game:

class Player {
    // class members and functions
}

To create an instance of a class, you simply call the class constructor using parentheses, without the need for the new keyword:

val player = Player()

If the class doesn’t have a body or additional members, you can even omit the curly braces:

class Player // No body, still valid

However, classes without...

In Kotlin, you can extend not only abstract classes but also regular classes. Let’s explore this by extending our Player class. Specifically, we’ll create a ConfusedPlayer class that moves to (y, x) instead of (x, y) when given the coordinates (x, y).

Initially, let’s create a class inheriting from Player:

class ConfusedPlayer(name: String ): ActivePlayer(name)

Here, the round brackets in the abstract classes signify that arguments can be passed to the parent class constructor, similar to Java’s super keyword.

However, this code won’t compile. In Kotlin, all classes are final by default, meaning they can’t be inherited unless marked as open. So, let’s modify the ActivePlayer class to allow for that:

open class ActivePlayer (...) : Moveable(), DiceRoller {
...
}

Next, let’s override the move method for the ConfusedPlayer:

class ConfusedPlayer(name : String): Player(name) {
    // move...

The last feature we’ll cover in this chapter, before moving on, is extension functions. Sometimes, you may want to extend the functionality of a class that is declared final or is not under your control. For example, you might like to have a string that has the hidePassword() function from the previous section.

One way to achieve that is to declare a class that wraps the string for us:

data class Password(val password: String) {
    fun hidePassword() = "*".repeat(password.length)
}

However, this solution is somewhat inefficient, as it adds another level of indirection.

In Kotlin, there’s a better way to implement this. To extend a class without inheriting from it, we can prefix the function name with the name of the class we’d like to extend:

fun String.hidePassword() = "*".repeat(this.length)

This looks similar to a regular top-level function declaration, but with one crucial change – before...

Now that we have gained a better understanding of basic Kotlin syntax, we can explore what design patterns are all about.

What are design patterns?

There are several misconceptions surrounding design patterns. Some common misconceptions include:

• Design patterns are simply missing features in a programming language.
• Design patterns are not necessary written in dynamic languages such as JavaScript, Ruby, or Python.
• Design patterns are only relevant to object-oriented languages.
• Design patterns are only used in enterprise settings.

In reality, design patterns are proven solutions to common problems. They are not limited to a specific programming language, such as Java, and they are not exclusive to a particular group of languages, like the C family. Design patterns can be applied not only to software development but also to software architecture. For example, there are service-oriented architectural patterns...

While the aim of this chapter wasn’t to cover all of Kotlin’s syntax features—we’ll explore more throughout this book—this chapter is still fairly lengthy. Therefore, it’s a good time to practice what you’ve learned with a short exercise, if you’re interested.

Exercise

Write a function that takes a list of possibly nullable strings, each representing a sentence.

If a string is either null or empty, the function should print Skipped.

Otherwise, the function should capitalize each word in the string.

The function should return a single list containing all the capitalized words.

Example

For the input listOf("hellO wOrlD", null, "fRom", null, "kOtlin"), the function should return listOf("Hello", "World", "From", "Kotlin").

Challenge

Do you see an opportunity to use extension functions in this exercise...

In this chapter, we have covered the main objectives of the Kotlin programming language. We explored how to declare variables, understand basic data types, and handle null values using null safety. We also discussed type inference, which allows the compiler to automatically determine variable types.

We delved into controlling the flow of a program using important commands such as if, when, for, and while. Additionally, we examined the keywords used to define classes and interfaces, including class, interface, data class, and abstract class. We learned how to create new classes, implement interfaces, and utilize class inheritance.

Furthermore, we emphasized the importance of design patterns in Kotlin and discussed why they are used. This knowledge enables you to develop practical and type-safe programs in Kotlin. While there are many other aspects of the language to explore, we will cover them in future chapters as we encounter real-world applications that require their...

1. What is the difference between var and val in Kotlin?
2. How do you extend a class in Kotlin?
3. How do you add functionality to a final class?

Learn more on Discord

Join our community’s Discord space for discussions with the author and other readers:

https://discord.com/invite/xQ7vVN4XSc