Kotlin is an object-oriented programming (OOP) language with support for higher-order functions and lambdas. If you don’t know what lambdas are, don’t worry, there is a full chapter dedicated to them. If you have been using a functional language already, you will find functional language-like constructs supported in Kotlin.
Over time, software complexity has increased, and the OOP abstraction has allowed us to model the problem we have to solve in terms of objects. You can view each object as a minicomputer on its own: it has a state and can perform actions. An object through its available actions exhibits some sort of behavior; therefore, there is a clear analogy between objects/entities and real life.The first characteristic of an object-oriented abstraction has been pinned down by Alan Key,one of the creators of the first successful OOP language: Small talk. In his book The Early History Of Small talk, he makes the following points:
- Everything is an object: An object is nothing but a block of memory allocated and configured according to a design/definition. From the problem space you have to solve, you take all the logical entities and translate them into objects in your program.
- Objects communicate by sending and receiving messages (in terms of objects): Your program will be a set of objects performing different actions as a result of calling methods that each one expose.
- Objects have their own memory (in terms of objects): This should be read as, You can create an object by composing other objects.
- Every object is an instance of a class (which must be an object): Think of a class as a blueprint specifying what the type can do.
The class holds the shared behavior for its instances (in the form of objects in a program list): This means all the objects of a particular type can receive the same messages; in other words, they expose the same methods.
Kotlin provides full support for the points above but also supports fully the three pillars of any modern OOP language: encapsulation, inheritance, and polymorphism. Encapsulation means that a group of related fields and methods are treated as an object. Inheritance describes the capability of creating a new class from an existing one. Polymorphism means you can use different classes interchangeably despite the fact that each one implements its
methods differently. Through the content of this chapter, we will get into a bit more detail
about how language constructs support this.
The OOP abstraction is meant to help us alleviate the problems encountered with large code bases. This makes it easier for us to understand, maintain, and evolve code bases and keep them bug-free by providing us with the following:
Simplicity: Program objects model the real world, thus reducing complexity and streamlining the program structure
- Modularity: Each object’s internal workings are decoupled from other parts of the system
- Modifiability: Changes inside an object do not affect any other part of a program if you have done your design right
- Extensibility: An object’s requirements change quite often, and you can quickly respond to them by adding new objects or modifying existing ones
- Reusability: The objects can be used in other programs
In this Lesson you will learn:
How to define and use classes and interfaces
When to choose interfaces over abstract classes
When to choose inheritance over composition