Kotlinでオブジェクトを作る基本：コンストラクタの使い方

Kotlinでオブジェクトを作る基本：コンストラクタの使い方を徹底解説

Kotlinは、Java仮想マシン（JVM）上で動作する静的型付けのプログラミング言語であり、簡潔で表現力豊かな構文と高い安全性を提供します。オブジェクト指向プログラミング言語として、クラスを定義し、そのクラスのインスタンス（オブジェクト）を生成することはKotlin開発の中心的な要素です。そして、オブジェクトを生成する際に、そのオブジェクトの初期状態を設定するために使われるのが「コンストラクタ」です。

この記事では、Kotlinにおけるコンストラクタの役割、種類、使い方、そして関連する初期化のメカニズムについて、初心者から経験者までが深く理解できるよう、約5000語の詳細な解説を行います。

第1章：オブジェクト指向プログラミングの基礎とKotlin

オブジェクト指向プログラミング（OOP）では、「クラス」はオブジェクトの設計図やテンプレートとして機能します。「オブジェクト」はその設計図に基づいて作られた実体であり、データ（プロパティ、属性）と振る舞い（メソッド、関数）を持ちます。

Kotlinでは、クラスを定義するためにclassキーワードを使用します。

kotlin // 非常にシンプルなクラス定義 class Person { // このクラスのオブジェクトが持つプロパティやメソッドを定義する }

このPersonクラスの「オブジェクト」を作成することを「インスタンス化」と呼びます。インスタンス化は、クラス名の後に括弧()を付けて行います。

kotlin fun main() { val person1: Person = Person() // Personクラスの新しいオブジェクト（インスタンス）を作成 val person2 = Person() // 型推論により型宣言は省略可能 println(person1) // オブジェクトの参照情報が出力される (例: Person@XYZabc) println(person2) // person1とは異なる参照情報が出力される }

ここで使われているPerson()が、まさにコンストラクタの呼び出しです。コンストラクタは、オブジェクトがメモリ上に作成される際に実行され、そのオブジェクトの初期状態を設定する特別な関数のようなものです。

第2章：Kotlinにおけるオブジェクト生成の基本（デフォルトコンストラクタ）

先ほどのシンプルなPersonクラスの例では、明示的にコンストラクタを定義していませんでしたが、Person()というコードでオブジェクトを作成できました。これは、Kotlinのクラスが明示的にコンストラクタを定義しない場合、引数を取らないデフォルトのコンストラクタを自動的に提供するためです。

“`kotlin
// コンストラクタを明示的に定義していないクラス
class Empty {
// プロパティもメソッドもコンストラクタも明示的にはない
}

fun main() {
val emptyObject = Empty() // デフォルトコンストラクタが呼び出される
println(emptyObject)
}
“`

このデフォルトコンストラクタは、クラス内に何も記述されていない場合や、明示的にコンストラクタを定義しない場合にのみ存在します。クラス内に何らかのプロパティやメソッドを定義しても、明示的なコンストラクタがなければデフォルトコンストラクタは引き続き提供されます。

“`kotlin
class SimpleData {
var count: Int = 0 // プロパティを定義

fun increment() {
    count++
}

}

fun main() {
val data = SimpleData() // デフォルトコンストラクタが呼び出される
println(data.count) // 0が出力される
data.increment()
println(data.count) // 1が出力される
}
“`

この場合、SimpleDataクラスにはプロパティcountがありますが、コンストラクタは明示されていません。したがって、引数なしのデフォルトコンストラクタが自動的に提供され、オブジェクト作成時にcountプロパティは定義時の初期値である0で初期化されます。

オブジェクトを生成する際に、初期値を渡したり、複雑な初期化処理を行ったりする必要が出てくることがよくあります。そのような場合に、コンストラクタを明示的に定義します。Kotlinには「プライマリコンストラクタ」と「セカンダリコンストラクタ」の2種類のコンストラクタがあります。

第3章：プライマリコンストラクタの詳細

Kotlinのクラス定義において、最も一般的で推奨されるコンストラクタの定義方法が「プライマリコンストラクタ」です。プライマリコンストラクタは、クラスヘッダーの一部として定義されます。

3.1. プライマリコンストラクタの基本構文

プライマリコンストラクタは、クラス名の直後に括弧()を付けて定義します。この括弧の中に、コンストラクタのパラメータを記述します。

kotlin // プライマリコンストラクタを持つクラス class Person(name: String, age: Int) { // このコンストラクタによって渡されるパラメータ 'name' と 'age' を使用して、 // クラスのプロパティなどを初期化できる。 // ただし、このままでは name と age はクラスのプロパティとしてはアクセスできない。 }

このPerson(name: String, age: Int)がプライマリコンストラクタです。オブジェクトを生成する際には、これらのパラメータに値を渡す必要があります。

kotlin fun main() { val person = Person("Alice", 30) // "Alice"と30がコンストラクタに渡される // println(person.name) // コンパイルエラー！ name はプロパティではない }

パラメータnameとageは、この時点ではコンストラクタスコープ内のローカル変数のようなものです。これらの値をオブジェクトのプロパティとして保持したい場合は、クラス本体内でこれらのパラメータを使用してプロパティを初期化する必要があります。

3.2. プライマリコンストラクタパラメータをプロパティとして定義する

Kotlinのプライマリコンストラクタの非常に便利な機能として、コンストラクタパラメータを直接クラスのプロパティとして定義し、初期化することができます。これには、パラメータ名の前にvalまたはvarを付けます。

“`kotlin
// プライマリコンストラクタパラメータをプロパティとして定義
class Person(val name: String, var age: Int) {
// これだけで、nameは不変(val)のプロパティ、ageは可変(var)のプロパティになり、
// コンストラクタによって渡された値で初期化される。
}

fun main() {
val person = Person(“Alice”, 30)
println(“Name: ${person.name}”) // 出力: Name: Alice
println(“Age: ${person.age}”) // 出力: Age: 30

person.age = 31 // var なので変更可能
println("New Age: ${person.age}") // 出力: New Age: 31
// person.name = "Bob" // コンパイルエラー！ val なので変更不可

}
“`

この構文は非常に簡潔で、多くのクラス定義で利用されます。クラスの主な状態がコンストラクタパラメータによって決定される場合に特に有効です。

3.3. `init` 初期化ブロック

プライマリコンストラクタには本体（body）がありません。パラメータの処理やval/varプロパティの初期化はクラスヘッダーで行われます。しかし、オブジェクトの初期化時に追加のロジック（例えば、パラメータの検証、複雑な計算、外部リソースへのアクセスなど）を実行したい場合があります。このような場合に使用するのがinitブロックです。

initブロックは、クラス本体内にinitキーワードを使用して定義します。クラスには複数のinitブロックを持つことができ、それらはクラスヘッダー（プロパティの初期化など）が処理された後、定義された順序で実行されます。

“`kotlin
class Rectangle(width: Int, height: Int) {
// width と height は val/var がついていないので、プロパティではない

val area: Int // プロパティを宣言するが、初期化は init ブロックで行う

init {
    // 最初の init ブロック
    println("Initializing Rectangle...")
    // コンストラクタパラメータを使ってプロパティを初期化
    area = width * height

    // パラメータの検証などを行うことができる
    if (width <= 0 || height <= 0) {
        throw IllegalArgumentException("Width and height must be positive")
    }
}

init {
    // 二番目の init ブロック
    println("Area calculated: $area")
}

// 他のプロパティやメソッド
fun printInfo() {
    println("Rectangle: width=$width, height=$height, area=$area")
}

}

fun main() {
try {
val rect1 = Rectangle(10, 5)
// 出力:
// Initializing Rectangle…
// Area calculated: 50
rect1.printInfo() // 出力: Rectangle: width=10, height=5, area=50

    println("---")

    // エラーになるケース
    // val rect2 = Rectangle(-5, 10) // IllegalArgumentException がスローされる
} catch (e: IllegalArgumentException) {
    println("Error creating rectangle: ${e.message}")
}

}
“`

この例では、プライマリコンストラクタのパラメータwidthとheightをinitブロック内で使用して、プロパティareaを計算・初期化しています。また、パラメータの検証もinitブロック内で行われています。

initブロックは、プライマリコンストラクタを持つクラスでの初期化ロジックを記述するための標準的な方法です。プライマリコンストラクタのパラメータは、initブロック内や、プロパティの初期化子（val area = width * heightのようにプロパティ宣言と同時に初期化する場合）からアクセスできます。

3.4. プライマリコンストラクタとデフォルト引数

Kotlinでは、関数のパラメータと同様に、コンストラクタのパラメータにもデフォルト引数を設定できます。これにより、オブジェクト生成時に一部の引数を省略できるようになり、複数のコンストラクタを用意する必要が減ります（コンストラクタのオーバーロードの代替となります）。

“`kotlin
class Product(
val name: String,
val price: Double = 0.0, // デフォルト引数
val quantity: Int = 1 // デフォルト引数
) {
init {
println(“Created Product: $name, Price: $price, Quantity: $quantity”)
}
}

fun main() {
val product1 = Product(“Laptop”) // priceとquantityはデフォルト値が使われる
// 出力: Created Product: Laptop, Price: 0.0, Quantity: 1

val product2 = Product("Mouse", 25.50) // quantityはデフォルト値が使われる
// 出力: Created Product: Mouse, Price: 25.5, Quantity: 1

val product3 = Product("Keyboard", 75.0, 2) // 全ての引数を指定
// 出力: Created Product: Keyboard, Price: 75.0, Quantity: 2

// 名前付き引数も使用可能
val product4 = Product(name = "Monitor", quantity = 3) // priceはデフォルト値
// 出力: Created Product: Monitor, Price: 0.0, Quantity: 3

}
“`

デフォルト引数は、特定のパラメータが常に同じ値で初期化されることが多い場合に便利です。また、名前付き引数と組み合わせることで、どのパラメータに値を渡しているかを明確にできます。

3.5. プライマリコンストラクタの可視性修飾子

デフォルトでは、プライマリコンストラクタはpublicです。しかし、コンストラクタの可視性を制限したい場合があります（例：外部からの直接のインスタンス化を防ぎたい、ファクトリメソッドを使わせたい）。プライマリコンストラクタに可視性修飾子（public, private, protected, internal）を付けるには、constructorキーワードを明示的に記述する必要があります。

“`kotlin
class SecretAgent private constructor(val codeName: String) {
// プライマリコンストラクタは private なので、外部から直接 new SecretAgent(…) できない

// インスタンス化するためのファクトリメソッドをコンパニオンオブジェクトに定義することが多い
companion object {
    fun create(code: String): SecretAgent {
        // ここで複雑なロジックや検証を行ってからインスタンスを生成できる
        println("Creating agent with code name: $code")
        return SecretAgent(code) // private コンストラクタはこのクラス/コンパニオンオブジェクト内から呼び出せる
    }
}

}

fun main() {
// val agent = SecretAgent(“007”) // コンパイルエラー！ private コンストラクタは呼び出せない

val agent = SecretAgent.create("007") // ファクトリメソッドを使ってインスタンスを取得
// 出力: Creating agent with code name: 007
println("Agent code name: ${agent.codeName}") // 出力: Agent code name: 007

}
“`

可視性修飾子を使用しない場合、constructorキーワードは省略できますが、可視性修飾子を付ける場合は省略できません。

“`kotlin
// 可視性修飾子なし (public constructor が省略されている)
class MyClass(param: String) { … }

// private constructor を明示的に指定
class AnotherClass private constructor(param: String) { … }
“`

第4章：セカンダリコンストラクタの詳細

Kotlinのクラスは、プライマリコンストラクタの他に、1つ以上の「セカンダリコンストラクタ」を持つことができます。セカンダリコンストラクタは、constructorキーワードを使用してクラス本体内に定義します。

4.1. セカンダリコンストラクタの基本構文

セカンダリコンストラクタは、constructorキーワードに続けてパラメータリストを記述し、その後に波括弧{}で囲まれた本体を持ちます。

“`kotlin
class Dog {
var name: String
var age: Int

// セカンダリコンストラクタ その1
constructor(name: String, age: Int) {
    println("Calling secondary constructor 1")
    this.name = name // プロパティにパラメータの値を代入
    this.age = age
}

// セカンダリコンストラクタ その2 (オーバーロード)
constructor(name: String) {
    println("Calling secondary constructor 2")
    this.name = name
    this.age = 0 // デフォルト値を設定
}

fun bark() {
    println("$name says Woof!")
}

}

fun main() {
val dog1 = Dog(“Buddy”, 5) // セカンダリコンストラクタ 1 が呼び出される
// 出力: Calling secondary constructor 1
dog1.bark() // 出力: Buddy says Woof!
println(“Age: ${dog1.age}”) // 出力: Age: 5

println("---")

val dog2 = Dog("Lucy") // セカンダリコンストラクタ 2 が呼び出される
// 出力: Calling secondary constructor 2
dog2.bark() // 出力: Lucy says Woof!
println("Age: ${dog2.age}") // 出力: Age: 0

}
“`

セカンダリコンストラクタは、プロパティの初期化や初期化ロジックをその本体内で記述します。複数のセカンダリコンストラクタを定義することで、異なるパラメータリストを持つコンストラクタを提供し、オブジェクト生成の複数の方法をサポートできます（コンストラクタのオーバーロード）。

4.2. コンストラクタデリゲーション (`this()` および `super()`)

Kotlinにおけるセカンダリコンストラクタの重要なルールとして、「全てのセカンダリコンストラクタは、最終的にプライマリコンストラクタ（もし存在すれば）または直接の親クラスのコンストラクタにデリゲート（委譲）する必要がある」というものがあります。このデリゲーションは、コンストラクタのパラメータリストの後にコロン:を付けて行います。

同じクラスの他のコンストラクタへのデリゲーション: this(...) を使用します。通常、引数の少ないセカンダリコンストラクタから、引数の多い（またはより基本的な）セカンダリコンストラクタやプライマリコンストラクタにデリゲートします。
親クラスのコンストラクタへのデリゲーション: super(...) を使用します。継承を使用する場合に必要となります。

プライマリコンストラクタが存在する場合:
セカンダリコンストラクタは、直接的または間接的にプライマリコンストラクタにデリゲートする必要があります。

“`kotlin
class Circle(val radius: Double) { // プライマリコンストラクタ
init {
println(“Primary constructor: radius = $radius”)
}

// 半径の文字列から Circle を作成するセカンダリコンストラクタ
constructor(radiusString: String) : this(radiusString.toDoubleOrNull() ?: 0.0) {
    // this(...) でプライマリコンストラクタにデリゲートしている
    println("Secondary constructor: radiusString = $radiusString")
    // セカンダリコンストラクタ本体のロジック
    if (radius <= 0) {
         println("Warning: Radius must be positive.")
    }
}

}

fun main() {
val c1 = Circle(10.0) // プライマリコンストラクタが直接呼ばれる
// 出力:
// Primary constructor: radius = 10.0

println("---")

val c2 = Circle("5.0") // セカンダリコンストラクタが呼ばれ、そこからプライマリにデリゲートされる
// 出力:
// Primary constructor: radius = 5.0
// Secondary constructor: radiusString = 5.0

println("---")

val c3 = Circle("invalid") // デリゲート先のプライマリコンストラクタで radius が 0.0 になる
// 出力:
// Primary constructor: radius = 0.0
// Secondary constructor: radiusString = invalid
// Warning: Radius must be positive.

}
“`

この例では、文字列を受け取るセカンダリコンストラクタが、this(...)を使ってDoubleを受け取るプライマリコンストラクタにデリゲートしています。セカンダリコンストラクタの本体は、デリゲーションが完了した後に実行されます。

プライマリコンストラクタが存在しない場合:
セカンダリコンストラクタは、直接または間接的に親クラスのコンストラクタにデリゲートする必要があります。プライマリコンストラクタがないクラスは、複数のセカンダリコンストラクタを持つことができますが、それらのうち少なくとも1つはsuper(...)を使って親クラスのコンストラクタを呼び出す必要があります。

“`kotlin
open class Animal(val name: String) {
init {
println(“Animal created with name: $name”)
}
}

class Cat : Animal { // Cat はプライマリコンストラクタを持たない

var color: String

// セカンダリコンストラクタ 1: 名前と色を受け取る
constructor(name: String, color: String) : super(name) { // 親クラスのコンストラクタにデリゲート
    println("Cat secondary constructor 1")
    this.color = color
}

// セカンダリコンストラクタ 2: 名前だけ受け取る (デフォルト色)
constructor(name: String) : this(name, "Gray") { // 別のセカンダリコンストラクタにデリゲート
    println("Cat secondary constructor 2")
    // color プロパティは this() の呼び出し先で初期化される
}

fun meow() {
    println("$name ($color) says Meow!")
}

}

fun main() {
val cat1 = Cat(“Whiskers”, “White”) // Sec constr 1 -> super() -> Animal init -> Cat sec constr 1 body
// 出力:
// Animal created with name: Whiskers
// Cat secondary constructor 1
cat1.meow() // 出力: Whiskers (White) says Meow!

println("---")

val cat2 = Cat("Mittens") // Sec constr 2 -> this() -> Sec constr 1 -> super() -> Animal init -> Cat sec constr 1 body -> Cat sec constr 2 body
// 出力:
// Animal created with name: Mittens
// Cat secondary constructor 1
// Cat secondary constructor 2
cat2.meow() // 出力: Mittens (Gray) says Meow!

}
“`

この例では、Catクラスはプライマリコンストラクタを持っていません。2つのセカンダリコンストラクタを定義しており、片方は直接super(name)で親クラスAnimalのコンストラクタにデリゲートし、もう片方はthis(name, "Gray")で同じクラスの別のセカンダリコンストラクタにデリゲートしています。このように、デリゲーションは連鎖させることが可能です。

セカンダリコンストラクタを使用する主なケースとしては、Javaとの相互運用性（Javaにはプライマリコンストラクタのような概念がないため）、あるいはプライマリコンストラクタだけでは表現しきれない複雑な初期化ロジックや、非常に異なるパラメータリストを持つ複数の初期化方法を提供したい場合などがあります。ただし、多くの場合、プライマリコンストラクタとデフォルト引数、そしてinitブロックの組み合わせで十分対応できます。

第5章：初期化の順序と実行フロー

オブジェクトが生成される際、コンストラクタやinitブロックは特定の順序で実行されます。この順序を理解することは、特に複雑な初期化ロジックを持つクラスを扱う上で非常に重要です。

初期化の順序は以下のようになります。

プライマリコンストラクタのパラメータの評価: プライマリコンストラクタに渡された引数が評価されます。
クラス本体で宣言されたプロパティの初期化: クラス本体で直接初期化子を持つプロパティ（例: val count: Int = 0）が定義順に初期化されます。
initブロックの実行: クラス本体で定義されたinitブロックが、定義順に実行されます。
(セカンダリコンストラクタが存在する場合) セカンダリコンストラクタの本体の実行: オブジェクト生成時に呼び出されたセカンダリコンストラクタの本体が実行されます。これは、そのセカンダリコンストラクタがthis()またはsuper()によるデリゲーションを完了した後に発生します。

親クラスと子クラスがある場合、この順序は階層的に適用されます。親クラスの初期化が全て完了してから、子クラスの初期化が開始されます。

具体的な実行フローは以下のようになります（親クラスがある場合）：

親クラスのプライマリコンストラクタパラメータ評価。
親クラス本体で宣言されたプロパティの初期化。
親クラスのinitブロックの実行（定義順）。
親クラスのセカンダリコンストラクタ本体の実行（もしデリゲートされた場合）。
子クラスのプライマリコンストラクタパラメータ評価。
子クラス本体で宣言されたプロパティの初期化。
子クラスのinitブロックの実行（定義順）。
子クラスのセカンダリコンストラクタ本体の実行（もし呼び出された場合）。

この順序を示すために、print文を使った例を見てみましょう。

“`kotlin
open class Parent(param1: String) {
val parentProperty = “Parent property initialized with: $param1”

init {
    println("Parent init 1: param1=$param1")
    println("Parent init 1: parentProperty='${this.parentProperty}'") // this. は省略可
}

constructor(param1: String, param2: Int) : this(param1) { // セカンダリからプライマリへデリゲート
    println("Parent secondary constructor: param1=$param1, param2=$param2")
}

init {
    println("Parent init 2: parentProperty='${parentProperty}'")
}

}

class Child(param1: String, param3: Boolean) : Parent(param1) { // 子のプライマリから親のプライマリへデリゲート

val childProperty = "Child property initialized with: $param3"

init {
    println("Child init 1: param1=$param1") // 親のコンストラクタパラメータにアクセスできる
    println("Child init 1: param3=$param3")
    println("Child init 1: childProperty='${childProperty}'")
    println("Child init 1: parentProperty='${parentProperty}'") // 親の初期化が終わっているのでアクセス可能
}

constructor(param1: String, param2: Int, param3: Boolean) : this(param1, param3) { // 子のセカンダリから子のプライマリへデリゲート
    println("Child secondary constructor: param1=$param1, param2=$param2, param3=$param3")
    // ここでは parentProperty にアクセスできるが、初期化順序に注意が必要な場合もある
}

init {
    println("Child init 2: childProperty='${childProperty}'")
}

}

fun main() {
println(“— Creating Child instance —“)
val child = Child(“ValueA”, 123, true)
// Execution trace:
// Child Sec Constr(ValueA, 123, true) -> this(ValueA, true)
// Child Primary Constr(ValueA, true) -> super(ValueA)
// Parent Primary Constr(ValueA)
// Parent Property Init (parentProperty = “Parent property initialized with: ValueA”)
// Parent init 1 (param1=ValueA, parentProperty=’Parent property initialized with: ValueA’)
// Parent init 2 (parentProperty=’Parent property initialized with: ValueA’)
// (Parent initialization complete)
// Child Property Init (childProperty = “Child property initialized with: true”)
// Child init 1 (param1=ValueA, param3=true, childProperty=’Child property initialized with: true’, parentProperty=’Parent property initialized with: ValueA’)
// Child init 2 (childProperty=’Child property initialized with: true’)
// Child Secondary Constructor Body (param1=ValueA, param2=123, param3=true)

/* Expected Output:
--- Creating Child instance ---
Parent init 1: param1=ValueA
Parent init 1: parentProperty='Parent property initialized with: ValueA'
Parent init 2: parentProperty='Parent property initialized with: ValueA'
Child init 1: param1=ValueA
Child init 1: param3=true
Child init 1: childProperty='Child property initialized with: true'
Child init 1: parentProperty='Parent property initialized with: ValueA'
Child init 2: childProperty='Child property initialized with: true'
Child secondary constructor: param1=ValueA, param2=123, param3=true
*/

}
“`

この例からもわかるように、初期化は親クラスから子クラスへ、そして各クラス内ではプロパティ初期化子 -> initブロック（定義順） -> セカンダリコンストラクタ本体（もし存在し、それが呼び出された場合）の順で厳密に実行されます。特に、initブロックやセカンダリコンストラクタ本体からプロパティや親クラスのメンバーにアクセスする場合、そのメンバーが既に初期化されている順序であることを理解しておくことが重要です。

第6章：継承とコンストラクタ

Kotlinでクラスが別のクラスを継承する場合、サブクラス（子クラス）のコンストラクタは、スーパータイプ（親クラス）のコンストラクタを呼び出す必要があります。これは、親クラスが持つプロパティや初期化ロジックが適切に設定されるために不可欠です。

サブクラスのクラスヘッダーで、親クラスの型の後に括弧を付けて親クラスのコンストラクタ呼び出しを記述します。

“`kotlin
// 親クラス（継承可能にするために open を付ける）
open class Animal(val name: String) {
init {
println(“Initializing Animal: $name”)
}
}

// 子クラス：プライマリコンストラクタを持ち、親のプライマリコンストラクタを呼び出す
class Dog(name: String, val breed: String) : Animal(name) {
// Animal(name) で親クラスのコンストラクタに name パラメータを渡している
init {
println(“Initializing Dog: ${this.name} (breed: $breed)”) // this.name は親クラスのプロパティ
}
}

fun main() {
val myDog = Dog(“Buddy”, “Golden Retriever”)
// 出力:
// Initializing Animal: Buddy
// Initializing Dog: Buddy (breed: Golden Retriever)

println("Dog name: ${myDog.name}") // 親クラスのプロパティにアクセス
println("Dog breed: ${myDog.breed}") // 子クラスのプロパティにアクセス

}
“`

この例では、Dogクラスのプライマリコンストラクタはパラメータnameとbreedを受け取ります。クラスヘッダーの: Animal(name)の部分で、受け取ったnameパラメータを親クラスAnimalのコンストラクタに渡しています。これにより、Animalクラスのnameプロパティが初期化され、そのinitブロックが実行された後に、Dogクラス自身の初期化が実行されます。

プライマリコンストラクタを持たない子クラスの場合:
プライマリコンストラクタを持たない子クラスの場合、全てのセカンダリコンストラクタは、直接または間接的にsuper(...)を使って親クラスのコンストラクタを呼び出す必要があります。

“`kotlin
open class Food(val type: String) {
init {
println(“Creating food of type: $type”)
}
}

class Fruit : Food { // プライマリコンストラクタなし
var isSweet: Boolean

// セカンダリコンストラクタ1: タイプと甘さを受け取る
constructor(type: String, isSweet: Boolean) : super(type) { // 親のコンストラクタを呼び出し
    println("Fruit secondary constructor 1")
    this.isSweet = isSweet
}

// セカンダリコンストラクタ2: タイプだけ受け取る (甘さはデフォルトで true)
constructor(type: String) : this(type, true) { // 同じクラスの別のコンストラクタにデリゲート
    println("Fruit secondary constructor 2")
    // isSweet は this() の呼び出し先 (セカンダリコンストラクタ1) で初期化される
}

fun describe() {
    println("This is a ${if (isSweet) "sweet" else "sour"} $type.")
}

}

fun main() {
val apple = Fruit(“Apple”, true) // Sec constr 1 -> super() -> Food init -> Fruit sec constr 1 body
// 出力:
// Creating food of type: Apple
// Fruit secondary constructor 1
apple.describe() // 出力: This is a sweet Apple.

println("---")

val lemon = Fruit("Lemon") // Sec constr 2 -> this() -> Sec constr 1 -> super() -> Food init -> Fruit sec constr 1 body -> Fruit sec constr 2 body
// 出力:
// Creating food of type: Lemon
// Fruit secondary constructor 1
// Fruit secondary constructor 2
lemon.describe() // 出力: This is a sweet Lemon. <- ここはちょっとおかしい例ですね。レモンは普通酸っぱい。初期値 true が不適切でした。修正しましょう。

// 修正版の Fruit クラス定義（デフォルトで isSweet = false にする）
/*
class Fruit : Food { // プライマリコンストラクタなし
    var isSweet: Boolean

    constructor(type: String, isSweet: Boolean) : super(type) { // 親のコンストラクタを呼び出し
        println("Fruit secondary constructor 1")
        this.isSweet = isSweet
    }

    constructor(type: String) : this(type, false) { // デフォルトで isSweet = false を渡す
        println("Fruit secondary constructor 2")
    }

    fun describe() {
        println("This is a ${if (isSweet) "sweet" else "sour"} $type.")
    }
}

fun main() {
    val apple = Fruit("Apple", true)
    // ... 出力同じ ...
    apple.describe() // 出力: This is a sweet Apple.

    println("---")

    val lemon = Fruit("Lemon") // Sec constr 2 -> this() -> Sec constr 1 -> super() -> Food init -> Fruit sec constr 1 body -> Fruit sec constr 2 body
    // 出力:
    // Creating food of type: Lemon
    // Fruit secondary constructor 1
    // Fruit secondary constructor 2
    lemon.describe() // 出力: This is a sour Lemon. <- OK
}
*/

}
“`

修正後の例のように、プライマリコンストラクタを持たない子クラスの場合でも、セカンダリコンストラクタを使って親クラスのコンストラクタを適切に呼び出す必要があります。

継承階層がある場合、コンストラクタの呼び出しと初期化の順序は常に親から子へと進むことを忘れないでください。

抽象クラスやインターフェースも、クラス定義の形式は取りますが、直接インスタンス化することはできません。したがって、これらの型にコンストラクタが存在する場合（抽象クラスのコンストラクタなど）、それはあくまでそれを継承/実装する具象クラスがsuper()を使って呼び出すためのものであり、単体でAbstractClass()やInterface()のように呼び出すことはありません。インターフェースは状態を持つことが限定的であるため、通常コンストラクタを持ちません。

第7章：コンストラクタの応用トピック

7.1. データクラスとコンストラクタ

Kotlinのdata classは、主にデータを保持するためのクラスを簡潔に定義するためのものです。データクラスは、プライマリコンストラクタに定義されたプロパティに基づいて、equals(), hashCode(), toString(), copy()といった便利なメソッドを自動生成します。

データクラスは必ずプライマリコンストラクタを持つ必要があります。そして、プライマリコンストラクタのパラメータのうち、valまたはvarで宣言されたものが、これらの自動生成されるメソッドに使用されます。

“`kotlin
data class User(val id: Int, val name: String, var age: Int) {
// データクラスのプライマリコンストラクタ
// id, name, age はプロパティとして定義され、equals, hashCode, toString, copy に使われる

// データクラスも init ブロックやセカンダリコンストラクタを持つことができる
init {
    println("User $name created.")
}

// セカンダリコンストラクタ (プライマリにデリゲートする必要がある)
constructor(id: Int, name: String) : this(id, name, 0) {
    println("User secondary constructor used.")
}

}

fun main() {
val user1 = User(1, “Alice”, 30)
// 出力: User Alice created.
println(user1) // 出力: User(id=1, name=Alice, age=30) – toString() が自動生成される

val user2 = User(1, "Alice", 30)
println(user1 == user2) // 出力: true - equals() が自動生成される (id, name, age を比較)

val user3 = User(2, "Bob") // セカンダリコンストラクタを使用
// 出力:
// User Bob created.
// User secondary constructor used.
println(user3) // 出力: User(id=2, name=Bob, age=0)

}
“`

データクラスの場合でも、セカンダリコンストラクタやinitブロックの初期化順序は通常のクラスと同じです。ただし、データクラスの主要な目的であるデータ保持の性質を最大限に活用するためには、必要なプロパティをプライマリコンストラクタにvalまたはvarとして定義することが推奨されます。

7.2. シールクラスとコンストラクタ

シールクラス（sealed class）は、そのサブクラスを厳密に制限するためのクラス階層を定義するのに使用されます。シールクラス自体は、インスタンス化することはできません（抽象クラスに似ています）。したがって、シールクラスのコンストラクタは、それを継承するサブクラスのコンストラクタからのみ呼び出されることになります。

シールクラスのコンストラクタの可視性は、デフォルトでprotectedです。これは、シールクラスのサブクラスがそのコンストラクタを呼び出せるようにするためです。明示的に可視性修飾子を指定することも可能ですが、通常はprotectedまたはprivateが適切です（publicにすると、シールクラスの意図する「制限された階層」が破られる可能性があるため）。

“`kotlin
sealed class Result {
// シールクラス自体はインスタンス化できない
// constructor() // protected by default

data class Success(val data: String) : Result() // サブクラスは親のコンストラクタを呼び出す必要がある
data class Error(val code: Int, val message: String) : Result() // サブクラスも同様
object Loading : Result() // object はインスタンスが一つだけなので、コンストラクタ呼び出しは内部的に行われる

}

// Result クラス自体を new することはできない
// val result = Result() // コンパイルエラー
“`

シールクラスのサブクラスは、通常のクラスと同様にコンストラクタを持ち、親であるシールクラスのコンストラクタにデリゲートする必要があります。

7.3. オブジェクト宣言とインスタンス生成の違い

Kotlinには、クラスのインスタンスを生成する以外に、特定のパターン（シングルトンなど）を簡潔に実現するための「オブジェクト宣言（object）」という構文があります。

“`kotlin
// オブジェクト宣言 (シングルトン)
object AppConfig {
val apiUrl = “https://api.example.com”
val timeout = 30 // seconds

init {
    println("AppConfig object initialized")
}

}

// クラス定義とインスタンス生成
class Logger {
init {
println(“Logger instance created”)
}
}

fun main() {
println(“— Accessing Object —“)
println(AppConfig.apiUrl) // オブジェクト名.プロパティの形式で直接アクセス
// 出力:
// AppConfig object initialized <– 最初のアクセス時に init ブロックが実行される
// https://api.example.com

println(AppConfig.timeout) // 2回目のアクセスでは init は実行されない

println("--- Creating Instance ---")
val logger1 = Logger() // new Logger() と同じ
// 出力: Logger instance created

val logger2 = Logger() // 新しいインスタンスが作成されるたびに init が実行される
// 出力: Logger instance created

println(logger1 === logger2) // 出力: false (異なるインスタンス)
println(AppConfig === AppConfig) // 出力: true (常に同じインスタンス)

}
“`

オブジェクト宣言は、クラス定義と同時にそのクラスの単一のインスタンスを生成する構文です。オブジェクト宣言にはコンストラクタを定義することはできません（シングルトンインスタンスはJVMによって遅延初期化されるため、コンストラクタ呼び出しのタイミングを開発者が制御するものではないからです）。初期化ロジックはinitブロックに記述します。これは、クラスのコンストラクタを呼び出して複数のインスタンスを生成する通常のクラスとは根本的に異なります。

7.4. コンパニオンオブジェクトとファクトリメソッド

コンストラクタはオブジェクト生成の標準的な方法ですが、オブジェクト生成のプロセスが複雑な場合や、複数の生成方法に明確な名前を付けたい場合、あるいはサブタイプや既存のインスタンスを返したい場合などには、ファクトリメソッドがよく使用されます。

Kotlinでは、クラス内にcompanion objectを定義し、その中にファクトリメソッド（通常はクラス名と同じ、あるいは意味のある名前を持つ静的な関数）を定義するのが一般的なパターンです。コンパニオンオブジェクトは、そのクラスの単一のインスタンスのようなもので、クラス名を使って直接メンバーにアクセスできます（Javaのstaticメンバーに近い）。

“`kotlin
class NetworkRequest private constructor(val url: String, val method: String) {
// プライマリコンストラクタを private にして、直接インスタンス化を防ぐ

// ファクトリメソッドを定義するコンパニオンオブジェクト
companion object {
    // GET リクエスト用のファクトリメソッド
    fun createGetRequest(url: String): NetworkRequest {
        // 複雑な検証やデフォルト値の設定など
        if (!url.startsWith("http")) {
             println("Warning: URL might be invalid.")
        }
        return NetworkRequest(url, "GET") // private コンストラクタを呼び出せる
    }

    // POST リクエスト用のファクトリメソッド
    fun createPostRequest(url: String): NetworkRequest {
         return NetworkRequest(url, "POST") // private コンストラクタを呼び出せる
    }
}

override fun toString(): String {
    return "Request(method='$method', url='$url')"
}

}

fun main() {
// val request1 = NetworkRequest(…) // コンパイルエラー！ private コンストラクタは呼び出せない

val request2 = NetworkRequest.createGetRequest("https://api.example.com/data") // ファクトリメソッドを使用
// 出力: Warning: URL might be invalid. (URLに http が含まれているので warning は出ないはず。例として残しておく)
println(request2) // 出力: Request(method='GET', url='https://api.example.com/data')

val request3 = NetworkRequest.createPostRequest("https://api.example.com/submit")
println(request3) // 出力: Request(method='POST', url='https://api.example.com/submit')

}
“`

このパターンでは、クラスのコンストラクタは実装の詳細として隠蔽され、外部からはファクトリメソッドという明確なインターフェースを通じてオブジェクトが生成されます。これは、特定の条件に基づいて異なるサブクラスのインスタンスを返したい場合や、インスタンスのキャッシュを管理したい場合などにも非常に有効です。

第8章：ベストプラクティスと注意点

Kotlinのコンストラクタには柔軟性がありますが、効果的かつ安全に使用するためのいくつかのベストプラクティスがあります。

プライマリコンストラクタを優先する: ほとんどの場合、クラスの主要な初期状態はプライマリコンストラクタで表現するのが最もKotlinらしい書き方です。val/varキーワードを使ってプロパティを定義し、initブロックで追加の検証や初期化ロジックを記述します。これにより、コードが簡潔で読みやすくなります。
デフォルト引数を活用する: コンストラクタのオーバーロードが必要な場合、セカンダリコンストラクタを複数定義する代わりに、プライマリコンストラクタにデフォルト引数を持たせることを検討しましょう。これにより、コンストラクタの数を減らし、メンテナンスを容易にできます。ただし、パラメータの数が非常に多い場合や、初期化ロジックが大きく異なる場合は、複数のセカンダリコンストラクタやファクトリメソッドの方が適切かもしれません。
initブロックで検証や複雑な初期化を行う: コンストラクタパラメータを使ってプロパティを初期化するだけでなく、その値の検証（例: 値が負でないか、文字列が空でないかなど）や、複数のパラメータを使った計算などはinitブロックで行いましょう。例外をスローして無効な状態のオブジェクトが作成されるのを防ぐことができます。
セカンダリコンストラクタは慎重に使う: セカンダリコンストラクタは、Javaとの相互運用性や、プライマリコンストラクタでは表現しにくい特別な初期化シナリオのために予約しておくと良いでしょう。セカンダリコンストラクタを使用する場合は、必ずthis()またはsuper()でデリゲーションを行い、初期化の連鎖を明確にしましょう。
初期化順序に注意する: initブロックやセカンダリコンストラクタ本体からプロパティにアクセスする際は、そのプロパティが初期化されているか確認しましょう。Kotlinはコンパイル時にある程度のチェックを行いますが、実行時エラー（例: 遅延初期化プロパティへの未初期化アクセス）が発生する可能性はゼロではありません。特に継承階層がある場合は、親クラスの初期化が子クラスの初期化より先に行われることを理解しておくことが重要です。
不変性（Immutability）を優先する: 可能であれば、コンストラクタパラメータとして受け取った値をvalプロパティとして保持し、オブジェクトの状態が作成後に容易に変更されないようにしましょう。これにより、コードの予測可能性が高まり、並行処理時の問題などを回避しやすくなります。
ファクトリメソッドを検討する: オブジェクト生成が複雑な場合、生成に名前を付けたい場合、あるいはコンストラクタ以外の方法でインスタンスを提供したい場合（シングルトン、ファクトリパターンなど）は、プライマリコンストラクタをprivateにして、コンパニオンオブジェクト内のファクトリメソッドを通じてインスタンスを提供するパターンが強力です。

まとめ

Kotlinのコンストラクタは、オブジェクト指向プログラミングにおけるオブジェクトの初期化という重要な役割を担っています。Kotlinは、プライマリコンストラクタとセカンダリコンストラクタという2つの異なるアプローチを提供し、それぞれが異なるシナリオに対応しています。

プライマリコンストラクタは、クラスヘッダーで簡潔に定義され、クラスの主要な状態を表現するのに最適です。val/varを使ったプロパティ定義と、initブロックを組み合わせて使用します。デフォルト引数は、プライマリコンストラクタの柔軟性を高めます。
セカンダリコンストラクタは、クラス本体でconstructorキーワードを使って定義され、複数の初期化方法を提供したり、Javaとの相互運用を行ったりする際に役立ちます。セカンダリコンストラクタは、必ず他のコンストラクタ（this()またはsuper()）にデリゲートする必要があります。
初期化順序は厳密に定められており、プロパティ初期化子 -> initブロック -> セカンダリコンストラクタ本体、そして親から子への順で実行されます。
継承においては、サブクラスのコンストラクタは親クラスのコンストラクタを呼び出す必要があります。
データクラス、シールクラス、オブジェクト宣言、コンパニオンオブジェクトといったKotlinの他の機能も、コンストラクタの概念と密接に関連しています。

これらのコンストラクタの概念と使い方をマスターすることで、Kotlinで堅牢かつイディオマティックなクラスを設計し、オブジェクトを効果的に生成できるようになります。実際の開発では、これらの知識を活かして、生成しようとしているオブジェクトの性質や必要な初期化ロジックに応じて、適切なコンストラクタのスタイルを選択してください。

この記事が、Kotlinにおけるコンストラクタの理解を深める一助となれば幸いです。