Picture by means of Joshua Eckstein on Unsplash

On this new publish from the Kotlin – Swift comparability collection, we will be able to speak about classes, the principle development block in O.O.P languages.

In Kotlin

We use the reserved key phrase elegance to claim a category:

// elegance declaration
elegance Person {
    //XXX: frame is going right here

A category declaration incorporates a number of portions:

  • a required identify
  • an not obligatory header, in parentheses, after the category identify
  • an not obligatory (however incessantly wanted…) frame, in between curly braces.
Elegance identify

It’s the one necessary phase within the elegance declaration, so the next code is legitimate too:

//XXX: elegance best with identify
elegance Person

Elegance header

It’s used to outline on the identical time:

  • the number one constructor and its parameters
  • the houses contained on every elegance example
//XXX: elegance with header
elegance Person(val firstname : String, val lastname : String, val nick : String = "no_nick")

As proven within the snippet, elegance houses may also be both mutable or immutable. Default values may also be assigned to every assets when required.

The number one constructor differs from secondary constructors because it’s outlined outdoor the category itself. It may be highlighted the use of the reserved key phrase “constructor”:

//XXX: elegance with header the use of key phrase
elegance Person constructor(val firstname : String, val lastname : String, val nick : String) 

Kotlin concise syntax permits us to outline each the constructor and the category houses. Actually, the former snippet may also be rewritten right into a extra Java-style code that does precisely the similar:

  • claim a category named “User”
  • claim a 3-parameter constructor to construct circumstances of this elegance
  • claim 3 String houses and set their values with the arguments won within the constructor
elegance Person constructor(firstname : String, lastname : String, nick : String = "no_nick") {

   //XXX: elegance props
   val firstname : String
   val lastname : String
   val nick : String 

   //XXX: initialization
   init {
      this.firstname = firstname
      this.lastname = lastname
      this.nick = nick

As is continuously performed, the anomaly between parameter and assets names is damaged the use of the implicit reference “this“.

Elegance frame


  • initialization block. Because the number one constructor within the elegance header can not have any statements, we use this block to accomplish further operations
  • houses (when now not declared within the elegance header)
  • secondary constructors (declared throughout the elegance)
  • example strategies

Secondary constructors are typically used when the superclass forces us to take action, by means of overloading the principle constructor. A commonplace instance is the superclass “View” on Android. When inheriting from this elegance or any of its descendants, we need to outline a number of constructors:

elegance CustomTextView : TextView {
   non-public var config : Config

   constructor(cntxt : Context) : tremendous(cntxt) {
      //XXX: code right here

   constructor(cntxtx : Context, attrs : AttributeSet) : tremendous(cntxt, attrs) {
      //XXX: code right here

   //XXX: extra constructor declarations right here...

   amusing customizeView() {
      //XXX: code right here

Moreover, a category frame too can include:

Additional: knowledge classes

Data classes in Kotlin are a unique roughly elegance used to create POJOs:

//XXX: knowledge elegance
knowledge elegance Person(val firstname : String, val lastname : String, val nick : String)

By means of including the key phrase “data” at the start, the category will mechanically include default implementations for:

  • toString()
  • equals()
  • hashCode()

Additionally, to be able to advertise immutability, knowledge classes additionally include different strategies like replica(), so we will create new circumstances in accordance with current gadgets:

val user1 = Person(firstname = "John", lastname = "Dough")
val user2 = user1.replica(firstname = "Jane")//XXX: best alternate price on sure props, mantain the opposite ones

In Swift

The category declaration is the same, the use of the key phrase “class” too:

elegance Person {
    //XXX: frame right here

However, on this case, the category declaration best incorporates:

  • a identify after the key phrase
  • a compulsory frame, in between curly braces.
Elegance identify

Because the frame is necessary too, we can not outline a category by means of best specifying its identify:

//FIXME: error, lacking frame
elegance Person

Elegance frame


  • elegance houses, mutable or immutable
  • initialization blocks
  • example strategies
elegance Person { 
   let firstname : String
   let lastname : String
   let nickname : String

   init(firstname : String, lastname : String, nickname : String) {
      self.firstname = firstname
      self.lastname = lastname
      self.nickname = nickname

   func subscribe() -> Bool {
      //XXX: code right here....
      go back true

On this case, initialization blocks have params, so their syntax it’s sort a mix of constructors and initializers in Kotlin.

Within the initialization block, to be able to connection with the item being construct, we use “self” (as an alternative of this) to be able to spoil the names ambiguity.

Wrapping up…

Elegance declaration syntax and semantics are very an identical in each languages, being headers and initializers blocks the principle variations between the 2 of them.

Kotlin introduces the category headers, so the ensuing code is extra compact and concise. Alternatively, elegance declarations in Swift include some extra boilerplate code.

Alternatively, classes in each languages have init blocks, however their structure is relatively other.

As standard, you’ll discover a pattern code to play with within the following hyperlink:



Please enter your comment!
Please enter your name here