前回はKotlinの基本文法と関数について解説しました。今回はKotlinにおけるオブジェクト指向プログラミングを実現するクラスと、それを取り巻く機能を紹介します。

クラスの定義とインスタンスの生成

KotlinはJavaと同じくクラスベースのオブジェクト指向言語です。すなわち、まずクラスがあり、それからインスタンスを生成し利用するというスタイルです。

メンバをいっさい持たないクラスの定義例をリスト1に示します。Javaと同様classキーワードが必要です。

class MyClass

このMyClassクラスをインスタンス化してみましょう（リスト2⁠）⁠。

val obj = MyClass()
println(obj) // => MyClass@604e9f7f

MyClass()によりMyClassクラスのインスタンスが生成されます。newのようなキーワードは必要ありません（Kotlinではnewはキーワードではありません⁠）⁠。リスト2ではMyClassクラスのインスタンスを生成して、その参照を変数objに代入しています。それをprintlnするとクラス名とハッシュコードが出力されます。

メソッド

メソッドを持ったクラスを定義しましょう。リスト3のGreeterクラスはgreetメソッドを持っています。このようにクラスはメンバを波括弧（{}）で括る必要があります。メソッドはfunキーワードを使って関数のように記述します。

class Greeter {
  fun greet() {
    println("Hello!")
  }
}

リスト4のようにGreeterクラスをインスタンス化して、そのインスタンスに対してgreetメソッドを呼び出します。

val greeter = Greeter()
greeter.greet() // => Hello!

プロパティ

クラスはプロパティを持つことができます。プロパティとは、平たく言えばJavaにおけるフィールドとそのアクセサ（setterやgetter）が一緒になったものと説明できます。

リスト5のUserクラスはidとnameという名前のプロパティを持っています。インスタン化してプロパティに値を設定したり取得したりしてみましょう。

var id: Long = 0
  var name: String = ""
  }

リスト6の2行目ではnameプロパティに値を設定しています。そして3行目でnameプロパティとidプロパティの値を取得しています。Javaにおけるフィールドに直接アクセスしているように見えますが、実際には（デフォルトで生成された）setterやgetterを介してアクセスしています。

val taro = User()
taro.name = "Taro"
println("${taro.name}(${taro.id})") // = > Taro(0)

setterやgetterをカスタマイズしたい場合はリスト7のように、関数に似た記法を用いて自由に処理を盛り込めます。誌面の都合上、詳細は割愛させていただきます。公式ドキュメントをご覧ください。

class User {
  var id: Long = 0

  var name: String = ""
  // 値が設定されるときにログを出力する
  set(value) {
    println("set: $value")
    $name = value
  }
  // 値が取得されるときにログを出力する
  get() {
    println("get")
    return $name
  }
}

コンストラクタ引数

クラス名の後に続けてコンストラクタの引数リストを宣言できます。ここで受け取った引数でもってプロパティを初期化することができます。

リスト8はもっとシンプルになります。

class User(id: Long, name: String) {
  val id = id
  val name = name
}

リスト9のようにコンストラクタ引数の名前の前にvalやvarを付けることでプロパティの定義も兼ねることができ、スッキリした見た目にできます。

class User(val id: Long, val name: String)

継承

Javaやそのほかの言語にもあるように、クラスは別のクラスを継承できます。継承すると継承元クラス（スーパクラス）の型のサブ型となり、またスーパクラスのメンバを自クラスのもののように扱うことができるようになります。

このことをシンプルな例から確認しましょう。まずスーパクラスとなるFooクラスを定義します（リスト10⁠）⁠。

open class Foo {
  fun foo() {
  println("Foo")
  }
}

Fooクラスは、コンストラクタ引数、プロパティを持たず、fooメソッドを持ったクラスです。さらに注目すべきポイントはopenという修飾子が付いていることです。Kotlinでは、クラスが継承可能であることをopen修飾子を付けて明示する必要があります。逆を言えばopenが付いていないクラスは継承できません[1]⁠。

リスト11にFooを継承したBarクラスを定義します。

class Bar: Foo() {
  fun bar() {
    println("Bar")
  }
}

クラス名の後に続けてコロン（:⁠）⁠、スーパクラスのコンストラクタ呼び出しを記述します。今回、Fooクラスはコンストラクタ引数がないのでFoo()となっています。

ではBarのインスタンスからスーパクラスで定義したメソッドを呼び出せるか確かめてみましょう（リスト12⁠）⁠。そしてBarは、Fooのサブ型なのでval foo: Foo = barは有効なコードです。

val bar: Bar = Bar()
bar.foo() // => Foo
bar.bar() // => Bar

抽象クラス

インスタンス化できない抽象クラスというものを定義できます。abstract修飾子をクラスに付けるだけです。抽象クラスは抽象メンバを持つことができ、これを継承する具象クラスでの実装を義務づけることができます。

リスト13のGreeter抽象クラスは抽象プロパティnameと抽象メソッドgreetを持っています。これらの抽象メンバはシグネチャだけで実装を持たないことがわかります。Greeterの具象サブクラスをリスト14に定義します。ここでは各抽象メンバをoverride修飾子付きでオーバライドしています。Kotlinではオーバライドする際にはoverride修飾子が必須です。ちなみに、abstractなクラスはopenなしで継承可能なクラスとなります。

abstract class Greeter {
  abstract val name: String
  abstract fun greet()
}

class JapaneseGreeter(
    override val name: String
  ): Greeter() {

  override fun greet() {
    println("こんにちは,私は${name}です")
  }
}

インターフェース

Javaのようにインターフェースを定義することもできます。インターフェースは実装を持つことができますが、プロパティの初期値を持てなかったり、コンストラクタを持てない点などで抽象クラスと異なります。

Kotlinでインターフェースを定義するにはtraitキーワード[2]を用います（リスト15⁠）⁠。

trait Greeter {
  val name: String
  fun greet()
}

インターフェースでは抽象メンバにabstractを付ける必要はありません。インターフェースを実装するにはクラス名の後に続けてコロンとインターフェース名を記述するだけです。クラスの継承とは異なり、コンストラクタ呼び出しはありません。リスト16とリスト14の違いはGreeterかGreeter()かだけです。

class JapaneseGreeter(
    override val name: String
  ): Greeter {

  override fun greet() {
    println("こんにちは,私は${name}です")
  }
}

ところで、インターフェースはデフォルトの実装を持てます（リスト17⁠）⁠。

trait Foo {
  fun say() {
    println("foo")
  }
}

// sayをオーバライドする義務はない
class FooImpl: Foo

ここでFooインターフェースの具象メソッドであるsayと同じ名前（と引数型）を具象メソッドとして持つほかのインターフェースBarがあったとき、FooとBar両方を実装するクラスのsayメソッドは、デフォルトでどちらの実装を使用するのでしょうか（リスト18⁠）⁠。

trait Bar {
  fun say() {
    println("bar")
  }
}

その答えは、デフォルトではどちらの実装も使用しません。正確に言うとFooとBarの実装クラスは、sayメソッドのオーバライドの義務が発生します（リスト19⁠）⁠。

// これはコンパイルエラーとなる
class FooBar1: Foo, Bar

// sayをオーバライドしているのでOK
class FooBar2: Foo, Bar {
  override fun say() {
    println("foobar")
  }
}

インターフェースのデフォルト実装を使用したい場合は、オーバライドしたメソッド内で明示的に呼び出します（リスト20⁠）⁠。このようにしてKotlinでは具象メソッドの衝突の問題を解決しています。

class FooBar: Foo, Bar {
  override fun say() {
    // Fooのsay実装を使用する
  super<Foo>.say()
  }
}

委譲

既存のクラスに機能を追加したい状況に直面したことのある人は多いはずです。

たとえばStringクラスに自身が表現する文字列を対象に挨拶するようなhelloというメソッドを追加したいとしましょう。

アプローチの1つとして委譲による実現を採用します。

リスト21のGreetableCharSeqのようなクラスを定義すれば、helloメソッドが追加されたCharSequence[3]を得ることができます。

class GreetableCharSeq(val cs: CharSequence): CharSequence {
  // 追加したいメソッド
  fun hello() {
    println("Hello, $cs")
  }

  // 実装を委譲する
  override fun charAt(index: Int): Char = cs.charAt(index)
  override fun length(): Int = cs.length()

  // その他多数のメソッド...
}

リスト22は、CharSequenceの実装クラスとしてStringクラスのインスタンスである"World"をコンストラクタに渡してGreetableCharSeqをインスタンス化しています。実行すると期待どおりHello, Worldと出力されます。

val greetable = GreetableCharSeq("World")
greetable.hello() // => Hello, World

helloメソッドの追加に成功しました！ しかし1つ問題があります。それはリスト21の「実装を委譲する」「⁠その他多数のメソッド...」のコメントのとおり、今回はとくに関心のないメソッドに関してもオーバライドして、委譲して、という一連の苦痛な作業が強いられることです。

安心してください！ Kotlinではこの問題の解決策を言語機能として提供しています。リスト21を書き直したリスト23をご覧ください。

class GreetableCharSeq(val cs: CharSequence): CharSequence by cs {
  // 追加したいメソッド
  fun hello() {
    println("Hello, $cs")
  }
  // 以上
}

: CharSequenceの部分が: CharSequence bycsに変わりました。by csは、コンストラクタ引数として受け取ったCharSequence型のcsに委譲する、という意味になります。この記述のおかげで、独自にオーバライドする必要のないメソッドをコーディングせずに済みます。

この機能の別の例とちょっとした解説を筆者のブログに書いていますのでご参照ください。

拡張関数

前節のようなhelloメソッドを追加するためだけに新しいクラスを定義するのは大変ですし、インスタンス化のオーバヘッドも気になります。メソッドを既存クラスに追加するという観点では少し異なりますが、リスト24のようなアプローチのほうがよさそうです。

fun hello(s: String) {
  println("Hello, $s")
}

hello("World") // => Hello, World

実は、まさにこのように展開され、かつ「既存クラスにメソッド追加」のように見える機能がKotlinには用意されています。拡張関数（Extension Function）と呼ばれる言語機能です。

リスト25を見ると、本当にhelloメソッドがStringに追加されたかのように見えます。実際にはstatic void hello(String s)に相当するコードをコンパイラは生成します。重要なのは動的に生成されるのではなく、静的に解決されるということです。型安全、低コストを期待できます。

fun String.hello() {
  println("Hello, $this")
}

"World".hello() // => Hello, World

演算子オーバロード

Kotlinには演算子オーバロードと呼ばれるしくみがあります。既存の演算子をほかの型に対しても使えるように拡張する機能です。たとえば独自にRationalというクラスを定義したとします。この有理数を表現するクラスのインスタンス同士、加算や乗算などできると便利です。この時にメソッド呼び出しによる記法ではなく、演算子を用いてa + bのように記述できるようにしてくれるのが演算子オーバロードです。

演算子は、特定のシグネチャを持ったメソッドと対応しています。Rational同士に対して使える+演算子は、Rationalのfun plus(rational: Rational): Rationalというようなシグネチャのメソッドを定義することで使えるようになります。

具体例を示すにあたって話を簡単にするためにリスト26のようなMyIntクラスを定義します。Int値を1つだけ持っている単純なクラスです。

class MyInt(val value: Int) {
  fun plus(myInt: MyInt): MyInt =
    MyInt(value + myInt.value)
}

plusメソッドにより、自身と他のMyIntと加算ができます。そして、このplusメソッドにより+演算子が使えるようになります（リスト27⁠）⁠。

// 普通のメソッド呼び出しによる記法
val sum = MyInt(3).plus(MyInt(5))
println(sum.value) // => 8

// 演算子を使った記法
val sum2 = MyInt(2) + MyInt(7)
println(sum2.value) // => 9

リスト28にもう1つ面白い例を示しましょう。演算子に対応するメソッドは、拡張関数として定義しても有効です。リスト28では拡張関数としてStringBuilderにplusAssignメソッドを追加しています。このシグネチャは+=演算子に対応します（リスト29⁠）⁠。そのほかの演算子と、そのメソッドシグネチャについては公式ドキュメントに掲載されている対応表を参照してください。

fun StringBuilder.plusAssign(any: Any) {
  append(any)
}

val sb = StringBuilder()
sb += "I"
sb += " am"
sb += " Taro"
println(sb) // => I am Taro

まとめ

今回はKotlinにおけるクラスとその周辺機能について紹介しました。

クラスやメソッドの定義、インスタンスの生成などはJavaのそれらと似ていますが、クラスはフィールドとアクセサが一緒になったようなプロパティを持てるという点でJava より強力です。

インターフェースは実装を持てる点で抽象クラスに似ています。同名の具象メソッドの衝突問題を回避するためのルールが用意されています。

既存の型の機能強化をしたい場合には委譲や拡張関数などの言語機能を使用すると便利です。

特定のシグネチャを持ったメソッドを定義することで演算子が使えるようになる演算子オーバロードを紹介しました。演算子を使用することで可読性の向上を期待できます。

次回はKotlinのユニークな機能であるNULL安全についてじっくり解説します。

本誌最新号をチェック！
Software Design 2022年9月号

2022年8月18日発売
B5判／192ページ
定価1,342円
（本体1,220円＋税10%）

• 第1特集
  MySQL アプリ開発者の必修5科目
  不意なトラブルに困らないためのRDB基礎知識
• 第2特集
  「知りたい」「⁠使いたい」「⁠発信したい」をかなえる
  OSSソースコードリーディングのススメ
• 特別企画
  企業のシステムを支えるOSとエコシステムの全貌
  ［特別企画］Red Hat Enterprise Linux 9最新ガイド
• 短期連載
  今さら聞けないSSH
  ［前編］リモートログインとコマンドの実行
• 短期連載
  MySQLで学ぶ文字コード
  ［最終回］文字コードのハマりどころTips集
• 短期連載
  新生「Ansible」徹底解説
  ［4］Playbookの実行環境（基礎編）