Classes are the foundational type in Kotlin. In Kotlin, a class is a template that provides a state, a behavior, and a type to instances (more on that later).
To define a class, only a name is required:
class VeryBasic
VeryBasic
is not very useful, but is still a valid Kotlin syntax.
The VeryBasic
class doesn't have any state or behavior; nonetheless, you can declare values of type VeryBasic
, as shown in the following code:
fun main(args: Array<String>) { val basic: VeryBasic = VeryBasic() }
As you can see, the basic
value has a VeryBasic
type. To express it differently, basic
is an instance of VeryBasic
.
In Kotlin, types can be inferred; so, the previous example is equivalent to the following code:
fun main(args: Array<String>) { val basic = VeryBasic() }
By being a VeryBasic
instance, basic
has a copy of the VeryBasic
type's state and behavior, namely, none. So sad.
As discussed previously, classes can have a state. In Kotlin, a class's state is represented by properties. Let's have a look at the blueberry cupcake example:
class BlueberryCupcake { var flavour = "Blueberry" }
The BlueberryCupcake
class has an has-a property flavour
of type String
.
Of course, we can have instances of the BlueberryCupcake
class:
fun main(args: Array<String>) { val myCupcake = BlueberryCupcake() println("My cupcake has ${myCupcake.flavour}") }
Now, because we declare the flavour
property as a variable, its internal value can be changed at runtime:
fun main(args: Array<String>) { val myCupcake = BlueberryCupcake() myCupcake.flavour = "Almond" println("My cupcake has ${myCupcake.flavour}") }
That is impossible in real life. Cupcakes do not change their flavor (unless they become stale). If we change the flavour
property to a value, it cannot be modified:
class BlueberryCupcake { val flavour = "Blueberry" } fun main(args: Array<String>) { val myCupcake = BlueberryCupcake() myCupcake.flavour = "Almond" //Compilation error: Val cannot be reassigned println("My cupcake has ${myCupcake.flavour}") }
Let's declare a new class for almond cupcakes:
class AlmondCupcake { val flavour = "Almond" } fun main(args: Array<String>) { val mySecondCupcake = AlmondCupcake() println("My second cupcake has ${mySecondCupcake.flavour} flavour") }
There is something fishy here. BlueberryCupcake
and AlmondCupcake
are identical in structure; only an internal value is changed.
In real life, you don't have different baking tins for different cupcake flavors. The same good quality baking tin can be used for various flavors. In the same way, a well-designed Cupcake
class can be used for different instances:
class Cupcake(flavour: String) { val flavour = flavour }
The Cupcake
class has a constructor with a parameter, flavour
, that is assigned to a flavour
value.
Because this is a very common idiom, Kotlin has a little syntactic sugar to define it more succinctly:
class Cupcake(val flavour: String)
Now, we can define several instances with different flavors:
fun main(args: Array<String>) { val myBlueberryCupcake = Cupcake("Blueberry") val myAlmondCupcake = Cupcake("Almond") val myCheeseCupcake = Cupcake("Cheese") val myCaramelCupcake = Cupcake("Caramel") }
In Kotlin, a class's behavior is defined by methods. Technically, a method is a member function, so, anything that we learn about functions in the following chapters also applies to the methods:
class Cupcake(val flavour: String) { fun eat(): String { return "nom, nom, nom... delicious $flavour cupcake" } }
The eat()
method returns a String
value. Now, let's call the eat()
method, as shown in the following code:
fun main(args: Array<String>) { val myBlueberryCupcake = Cupcake("Blueberry") println(myBlueberryCupcake.eat()) }
The following expression is the output of the preceding code:
Nothing mind-blowing, but this is our first method. Later on, we'll do more interesting stuff.