Other than IntelliJ IDEA, this chapter does not require any specific installations.

The code for this chapter can be downloaded from the following GitHub repository: https://github.com/PacktPublishing/Hands-On-Object-Oriented-Programming-with-Kotlin/tree/master/src/main/kotlin/Chapter02.

In our day-to-day life, we deal with a number of different objects. Some of these objects talk to us, some move on the road, and some fly in the sky. We naturally observe everything about the characteristics and behaviors of these objects. As an example, let's think about an object with the following properties: it has a couple of doors, four wheels, one steering wheel, brakes, gears, and an engine, it moves on the road, stops when the brakes are applied, and turns left or right when the steering wheel moves. Based on these attributes and behaviors, we can carry out a classification of this object – it belongs to a class called Car. In programming, the technique to design and build an application by focusing on objects that interact with each other is known as object-oriented programming. In the object-oriented paradigm, class and object...

Old programming languages, such as Assembly or FORTRAN, are not object-oriented languages. Instead, these are procedural programming languages, languages in which a program is written in one long procedure. The data and the logic are coupled together in one place and a program contains a list of routines or subroutines to instruct the computer step by step. This approach is also known as a top-down approach, because instructions are executed one after the other. Procedural programming comes with a number of drawbacks:

• There is no information-hiding mechanism; data is exposed to the whole system
• Data and functions are stored in separate memory locations
• It is difficult to map real-world objects
• The code cannot be reused; each module or instruction set requires its own tightly coupled routine
• The code cannot be extended; it is difficult to...

In Kotlin, a class can be defined with the class keyword. Let's take a look at how to declare a class and how to add attributes to it. In Kotlin, a class can be declared as follows:

class Person 

Compared to other programming languages, creating a class in Kotlin is very easy. All we need to do is open our IDE and create a person class with three attributes—name, age, and height. The name is a variable of the String type, age is a variable of the Integer type, and height is a variable of the Double type:

class Person {
    var name: String
    var age : Int
    var height : Double
 }

We have now declared a Person class with three attributes enclosed in brackets. After writing this code, we will notice that compiler has immediately thrown a Property not initialized error, because we haven't decided that how these properties will be initialized. Let...

Each class contains different attributes. The Person class, for example, contains the name, age, and height attributes. When a Person class is declared in Java or another programming language, these attributes are called fields of the class. When these fields are accessed by their corresponding getter and setter methods, they are called properties. To understand this concept in detail, create a Person class in Java, as follows:

public class Person {

    String name;
    int age;
    double height;

    Person(String n, int a, double h){
        name = n;
        age = a;
        height = h;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public...

When an object is created, all class members have to have an initial value. We can either initialize a property directly or the initial values can be provided by a constructor. A constructor is a special type of function that is used to initialize the properties of the class.

A constructor is invoked when the object is created, or, more specifically, when the space is allocated in the memory. This special function has two important characteristics:

• Constructors can be declared with the constructor keyword
• Constructors don't contain any return types, not even Units

In this section, we will learn about all of the different kinds of constructors that are provided by Kotlin. Let's start with the default constructor.

During the application's development, classes are used quite often as a data-holder, not to carry out complex tasks. These classes only contain properties for reading and writing purposes. The person class is a simple example of a class used as a data-holder. If the sole responsibility of the class is to handle data, programmers may want the class to be able to carry out additional functionalities:

• The data should be in a well-presented format
• We should be able to compare object properties
• We should be able to clone existing objects

All these functionalities can be written by the programmer. Alternatively, an advanced IDE could generate this code automatically. Either way, the project would be filled with boilerplate code. Just as it automatically generates getters and setters, Kotlin assumes the responsibility for generating all of these functions...

In this section, we will have a quick look at how behaviors and functions can be implemented. We will continue with our Person class, which has three behaviors—speak, eat, and walk.

As we know, class behaviors are represented by functions. We can declare a function within the class body:

1. Create a class with a primary constructor and add the speak() function by using fun keyword. When a function is declared in the class body, it becomes class behavior:

class Person (val name: String, var age : Int , var height : Double) {
    fun speak() {
        println("My name is $name , i am $age years old and I am $height feet tall")
    }
}

fun main(args: Array<String>) {
    val abid = Person("Abid", 40, 6.0)
    abid.speak()
}

2. Create an object of the Person class and call the speak function using the . operator. Execute this program and...

In this chapter, we learned about object-oriented programming and why it is better than procedural programming. We started the chapter by exploring classes and learning how to declare them. We also discussed the properties and behavior of classes, and why properties are known as first-class citizens. Then, we had a detailed discussion about data classes, constructors, and how parameterized constructors help us to write clean code. In the last section of this chapter, we covered functions and function overloading. In the next chapter, we will look at some more advanced topics and their implementations.

1. What is the difference between a class and an object?
2. What is an attribute and the behavior of the class?
3. What is a constructor and how many types of constructors are available?
4. What is function overloading?
5. What are data classes and why are they beneficial?

Learning Object-Oriented Programming by Gastón C. Hillar published by Packt: https://www.packtpub.com/application-development/learning-object-oriented-programming.