This chapter will primarily focus on the fundamentals of Kotlin syntax. It is crucial to have a strong understanding of the language before diving into the implementation of design patterns.

We will also briefly explore the problems that design patterns aim to solve and explain why they should be used in Kotlin. This will be beneficial for those who are less familiar with the concept of design patterns. Even experienced engineers can gain interesting insights from this discussion.

It’s important to note that this chapter doesn’t aim to cover the entire range of the language’s vocabulary. Instead, its purpose is to introduce you to fundamental concepts and idioms. In the following chapters, we will gradually introduce more language features as they become relevant to the design patterns we examine.

The main topics covered in this chapter include:

• Basic language syntax and features
• Understanding Kotlin code...

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 athttps://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’snotoriousNull 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 theint type for primitive values andInteger for objects. The former is more memory-efficient, while the latter is more expressive due to its support fornull 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 inChapter 5,Introducing Functional Programming.

Lists

A list in Kotlin representsan ordered collection of elements of the same type. To declare a list, we utilize thelistOf() 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 andwhen.

The if expression

In Java, theif statement is notan expression and does not return a value. Let’sexamine the following function, which returns one of two possible values:

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

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

We can rewrite this method using Java’svar keyword:

public StringgetUnixSocketPolling(boolean isBsd) {varpollingType="epoll";if (isBsd) {        pollingType ="kqueue";    }return pollingType;}

In our previous example, we used a singlereturn 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 toprint the results from the previous section.

Firstly, Kotlin provides a convenientprintln() standard function that simplifies the usage of the bulkierSystem.out.println command from Java. We saw this when we looked at theHello 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 mostuseful types of loops in Kotlin is thefor-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 inChapter 4,Getting Familiar with Behavioral Patterns. For now, let’s see an example of using thefor-each loop with a simple string:

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

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

>W>o>r>d

Thefor-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 keywordclass, similar to in Java. For example, let’s define a class to represent a player in a video game:

classPlayer {// class members and functions}

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

val player = Player()

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

classPlayer //Nobody,stillvalid

However, classes without...

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

Initially, let’s create a class inheriting fromPlayer:

classConfusedPlayer(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’ssuper 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 theActivePlayer class to allow for that:

openclassActivePlayer (...) : Moveable(), DiceRoller {...}

Next, let’s override themove method for theConfusedPlayer:

classConfusedPlayer(name : String): Player(name) {// move...

The last feature we’ll cover inthis 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 thehidePassword() function from the previous section.

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

dataclassPassword(val password: String) {funhidePassword() ="*".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 whatdesign 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 printSkipped.

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 inputlistOf("hellO wOrlD", null, "fRom", null, "kOtlin"), the function should returnlistOf("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 asif,when,for, andwhile. Additionally, we examined the keywords used to define classes and interfaces, includingclass,interface,data class, andabstract 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 betweenvar andval 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