Kotlin用語集【レベル４】～オブジェクト指向編②～

記事内に商品プロモーションを含む場合があります

このサイトではKotlinの基本的文法を33個定義して練習問題を作成しています。

このページではレベル4の7個の基本的文法について、その言葉の意味や使用例を紹介します。

【レベル１のKotlinの基本的文法】
コメントの書き方、変数と定数、基本データ型、算術演算と論理演算、入力と出力、import文、配列、分岐処理（if、if～else、when）、繰り返し処理（for、while、do～while）、Null安全、スマートキャスト

Kotlin用語集【レベル１】～基礎文法＋制御構造編～ このサイトではKotlinの基本的文法を33個定義して練習問題を作成しています。 このページではレベル１の11個の基本的文...

【レベル２のKotlinの基本的文法】
関数の定義と呼び出し、関数の戻り値、関数のオーバーロード、ラベルとジャンプ、例外処理、クラスの定義と使用、インスタンス、コンストラクタ、プロパティ、クラスの継承、クラスの拡張

Kotlin用語集【レベル２】～オブジェクト指向編①～ このサイトではKotlinの基本的文法を33個定義して練習問題を作成しています。 このページではレベル２の11個の基本的文...

【レベル３のKotlinの基本的文法】
コレクションの基礎、リストコレクション（MutableList、ArrayList）、セットコレクション（HashSet、MutableSet、TreeSet）、マップコレクション（HashMap、MutableMap、TreeMap）

Kotlin用語集【レベル３】～コレクション編～ このサイトではKotlinの基本的文法を33個定義して練習問題を作成しています。 このページではレベル3の4個の基本的文法...

【レベル４のKotlinの基本的文法】
１．メンバ関数
２．ゲッターとセッター
３．カプセル化
４．クラスメンバ
５．抽象クラス
６．インターフェース
７．データクラス

この用語集を作成するにあたりAIを活用しています。

問題ないことは確認していますが、もし間違いや表現の違和感などありましたら、ご指摘頂けると大変助かります。またKotlinの公式サイトの情報も並行して活用しましょう。

初心者のためのKotlin練習問題集（全38問を無料公開中！） プログラミングは教科書を読んでいるだけでは習得できない！ この記事では、Kotlinの学習を始めた初心者に役立つ練習問題を...

メンバ関数





Kotlinの「メンバ関数」とは何か、以下に紹介します。

１．「メンバ関数」とは

「メンバ関数」とは、クラスやオブジェクトに属する関数のことを指します。メンバ関数は、そのクラスのインスタンス（オブジェクト）によって呼び出され、クラス内のプロパティにアクセスしたり、クラスの状態を変更するために使用されます。

Kotlinでは、メンバ関数はクラス内で定義され、そのクラスのインスタンスを通じて呼び出すことができます。

２．「メンバ関数」の使用例とその解説

以下に、Kotlinでメンバ関数を使用する例を示します。このコードでは、クラスの定義、メンバ関数の定義、メンバ関数の呼び出し方法を示しています。

// クラスの定義
class Person(val name: String, var age: Int) {

    // メンバ関数の定義
    fun introduce() {
        println("こんにちは、私の名前は$nameです。年齢は$age歳です。")
    }

    // メンバ関数の定義
    fun haveBirthday() {
        age += 1
        println("誕生日おめでとう！$age歳になりました。")
    }
}

fun main() {
    // Personクラスのインスタンスを作成
    val person = Person("太郎", 20)

    // メンバ関数の呼び出し
    person.introduce() // こんにちは、私の名前は太郎です。年齢は20歳です。
    person.haveBirthday() // 誕生日おめでとう！21歳になりました。
    person.introduce() // こんにちは、私の名前は太郎です。年齢は21歳です。
}
  1. クラスの定義:
    • class Person(val name: String, var age: Int)は、名前(name)と年齢(age)というプロパティを持つPersonクラスを定義しています。
  2. メンバ関数の定義:
    • fun introduce()は、Personクラスのメンバ関数で、オブジェクトの名前と年齢を出力します。
    • fun haveBirthday()は、年齢を1つ増やし、その結果を出力するメンバ関数です。
  3. メンバ関数の呼び出し:
    • val person = Person("太郎", 20)は、Personクラスのインスタンスを作成します。
    • person.introduce()は、personオブジェクトのintroduceメンバ関数を呼び出します。
    • person.haveBirthday()は、personオブジェクトのhaveBirthdayメンバ関数を呼び出し、年齢を増やします。
    • 再度person.introduce()を呼び出して、更新された年齢を出力します。

このように、メンバ関数を使用することで、クラスのインスタンスが持つデータを操作したり、そのデータに基づいた動作を定義することができます。

メンバ関数は、クラスの状態や振る舞いをカプセル化し、オブジェクト指向プログラミングの重要な要素となっています。

ゲッターとセッター

Kotlinの「ゲッターとセッター」とは何か、以下に紹介します。

「ゲッターとセッター」とは

Kotlinの「ゲッター（getter）とセッター（setter）」とは、クラスのプロパティにアクセスするためのメソッドです。ゲッターはプロパティの値を取得し、セッターはプロパティの値を設定します。

Kotlinでは、プロパティに対して自動的にゲッターとセッターが生成されますが、カスタムゲッターやカスタムセッターを定義してプロパティのアクセス方法をカスタマイズすることもできます。

「ゲッターとセッター」の使用例とその解説

以下に、Kotlinでゲッターとセッターを使用する例を示します。

このコードでは、プロパティのカスタムゲッターとカスタムセッターを定義し、それらを使用してプロパティにアクセスする方法を示しています。

class Person {
    // プライマリコンストラクタで初期化するプロパティ
    var name: String = "未設定"
        get() {
            // カスタムゲッター
            println("ゲッターが呼び出されました")
            return field
        }
        set(value) {
            // カスタムセッター
            println("セッターが呼び出されました")
            field = value
        }

    // バッキングフィールドを使用したプロパティ
    private var _age: Int = 0
    var age: Int
        get() {
            println("年齢のゲッターが呼び出されました")
            return _age
        }
        set(value) {
            if (value >= 0) {
                println("年齢のセッターが呼び出されました")
                _age = value
            } else {
                println("年齢は0以上でなければなりません")
            }
        }
}

fun main() {
    // Personクラスのインスタンスを作成
    val person = Person()

    // ゲッターとセッターを使用してプロパティにアクセス
    person.name = "太郎" // セッターが呼び出されました
    println(person.name) // ゲッターが呼び出されました // 太郎

    person.age = 25 // 年齢のセッターが呼び出されました
    println(person.age) // 年齢のゲッターが呼び出されました // 25

    person.age = -5 // 年齢は0以上でなければなりません
}
  1. プロパティのカスタムゲッターとカスタムセッター:
    • var name: Stringプロパティにはカスタムゲッターとカスタムセッターが定義されています。ゲッターが呼び出されると「ゲッターが呼び出されました」というメッセージを表示し、セッターが呼び出されると「セッターが呼び出されました」というメッセージを表示します。
    • プロパティの値はfieldというバッキングフィールドを通じて取得および設定されます。
  2. バッキングフィールドを使用したプロパティ:
    • private var _age: Intはプライベートなバッキングフィールドで、var age: Intプロパティの値を格納します。
    • ageプロパティのゲッターは、呼び出されたときに「年齢のゲッターが呼び出されました」というメッセージを表示し、バッキングフィールドの値を返します。
    • ageプロパティのセッターは、値が0以上の場合に「年齢のセッターが呼び出されました」というメッセージを表示してバッキングフィールドに値を設定します。値が0未満の場合、「年齢は0以上でなければなりません」というメッセージを表示します。
  3. プロパティのアクセス:
    • person.name = "太郎"は、nameプロパティのセッターを呼び出します。
    • println(person.name)は、nameプロパティのゲッターを呼び出します。
    • person.age = 25は、ageプロパティのセッターを呼び出します。
    • println(person.age)は、ageプロパティのゲッターを呼び出します。
    • person.age = -5は、ageプロパティのセッターを呼び出しますが、値が0未満であるためエラーメッセージを表示します。

このように、Kotlinのゲッターとセッターを使用することで、プロパティへのアクセスをカスタマイズし、適切なデータ管理とバリデーションを行うことができます。

カプセル化

Kotlinの「カプセル化」とは何か、以下に紹介します。

「カプセル化」とは

カプセル化（Encapsulation）とは、オブジェクト指向プログラミングにおける基本概念の一つで、データ（プロパティ）とそれに関連するメソッド（関数）を一つの単位であるクラスにまとめ、外部から直接アクセスできないようにすることです。

カプセル化により、データの隠蔽が実現され、クラスの内部構造を隠すことで安全性が向上します。

Kotlinでは、プロパティをprivateやprotectedで定義し、必要に応じてゲッター（getter）やセッター（setter）を用いてアクセスを制御します。

「カプセル化」の使用例とその解説

以下に、Kotlinでカプセル化を実現する例を示します。

このコードでは、クラスのプロパティをカプセル化し、ゲッターとセッターを用いてプロパティにアクセスする方法を示しています。

class BankAccount {
    // プライベートプロパティ：外部から直接アクセスできない
    private var balance: Int = 0

    // 残高を取得するゲッター
    fun getBalance(): Int {
        return balance
    }

    // 残高を設定するセッター（バリデーション付き）
    fun deposit(amount: Int) {
        if (amount > 0) {
            balance += amount
            println("入金: $amount 円")
        } else {
            println("有効な金額を入力してください")
        }
    }

    // 残高を減らすメソッド（バリデーション付き）
    fun withdraw(amount: Int) {
        if (amount > 0 && amount <= balance) {
            balance -= amount
            println("出金: $amount 円")
        } else {
            println("出金できません。残高不足または無効な金額です")
        }
    }
}

fun main() {
    // BankAccountクラスのインスタンスを作成
    val account = BankAccount()

    // 残高を取得（初期値は0円）
    println("初期残高: ${account.getBalance()} 円")

    // 入金処理
    account.deposit(1000) // 入金: 1000 円
    println("現在の残高: ${account.getBalance()} 円") // 現在の残高: 1000 円

    // 出金処理
    account.withdraw(500) // 出金: 500 円
    println("現在の残高: ${account.getBalance()} 円") // 現在の残高: 500 円

    // 無効な入金
    account.deposit(-200) // 有効な金額を入力してください

    // 無効な出金
    account.withdraw(600) // 出金できません。残高不足または無効な金額です
}
  1. プライベートプロパティの定義:
    • private var balance: Intは、balanceプロパティをプライベートに設定し、外部から直接アクセスできないようにします。
  2. ゲッターの定義:
    • fun getBalance(): Intは、balanceプロパティの値を取得するためのゲッターです。このメソッドを通じてのみ、残高を外部に公開します。
  3. セッターの定義（入金処理）:
    • fun deposit(amount: Int)は、balanceプロパティに値を追加するためのセッターです。入金額が正の値であることを確認し、条件を満たす場合のみbalanceを更新します。
  4. 残高を減らすメソッド（出金処理）:
    • fun withdraw(amount: Int)は、balanceプロパティから値を減らすためのメソッドです。出金額が正の値であり、かつ残高内であることを確認し、条件を満たす場合のみbalanceを更新します。
  5. メソッドの使用:
    • account.deposit(1000)およびaccount.withdraw(500)を用いて、プロパティに対して安全に操作を行います。また、無効な操作が行われた場合、適切なメッセージを表示します。

このように、カプセル化を使用することで、データの整合性を保ちつつ、安全にプロパティにアクセスし操作することができます。

クラスメンバ

Kotlinの「クラスメンバ」とは何か、以下に紹介します。

「クラスメンバ」とは

クラスメンバとは、クラス内に定義されるプロパティ（変数）やメソッド（関数）、ネストされたクラスなどのことを指します。

クラスメンバはそのクラスのインスタンスに属し、インスタンスごとに異なる値や動作を持つことができます。

Kotlinでは、クラスメンバとしてプロパティ、メソッド、ネストされたクラス、オブジェクトなどを定義することができます。

「クラスメンバ」の使用例とその解説

以下に、Kotlinでクラスメンバを使用する例を示します。

このコードでは、プロパティとメソッドをクラスメンバとして定義し、それらを使用してクラスのインスタンスを操作する方法を示しています。

// クラスの定義
class Car(val make: String, val model: String, var year: Int) {

    // プロパティ（クラスメンバ）
    var speed: Int = 0

    // メソッド（クラスメンバ）
    fun accelerate(amount: Int) {
        speed += amount
        println("加速しました。現在の速度は$speed km/hです。")
    }

    // メソッド（クラスメンバ）
    fun brake(amount: Int) {
        speed = if (speed - amount < 0) 0 else speed - amount
        println("減速しました。現在の速度は$speed km/hです。")
    }
}

fun main() {
    // Carクラスのインスタンスを作成
    val myCar = Car("Toyota", "Corolla", 2020)

    // プロパティにアクセス
    println("車の情報: ${myCar.make} ${myCar.model} ${myCar.year}")

    // メソッドを呼び出して操作
    myCar.accelerate(30) // 加速しました。現在の速度は30 km/hです。
    myCar.brake(10) // 減速しました。現在の速度は20 km/hです。
}
  1. クラスの定義:
    • class Car(val make: String, val model: String, var year: Int)は、自動車のメーカー、モデル、製造年を表すプロパティを持つCarクラスを定義しています。
  2. プロパティの定義（クラスメンバ）:
    • var speed: Int = 0は、速度を表すプロパティで、初期値を0に設定しています。このプロパティはクラスメンバとして定義されています。
  3. メソッドの定義（クラスメンバ）:
    • fun accelerate(amount: Int)は、速度を増加させるためのメソッドです。引数として増加させる値を受け取り、プロパティspeedにその値を加算します。
    • fun brake(amount: Int)は、速度を減少させるためのメソッドです。引数として減少させる値を受け取り、プロパティspeedからその値を減算します。速度が負の値にならないように調整します。
  4. インスタンスの作成とメンバへのアクセス:
    • val myCar = Car("Toyota", "Corolla", 2020)は、Carクラスのインスタンスを作成し、プロパティに初期値を設定します。
    • println("車の情報: ${myCar.make} ${myCar.model} ${myCar.year}")は、インスタンスのプロパティにアクセスして車の情報を出力します。
    • myCar.accelerate(30)およびmyCar.brake(10)は、インスタンスのメソッドを呼び出して速度を操作します。

このように、クラスメンバを使用することで、クラスのインスタンスに対してデータの管理や操作を行うことができます。

クラスメンバを適切に定義し活用することで、オブジェクト指向プログラミングの利点を最大限に引き出すことができます。

抽象クラス

Kotlinの「抽象クラス」とは何か、以下に紹介します。

「抽象クラス」とは

抽象クラス（Abstract Class）とは、他のクラスに継承されることを目的として設計されたクラスのことです。

抽象クラス自体はインスタンス化できませんが、抽象メソッドを持つことができ、これらのメソッドはサブクラスで具体的に実装される必要があります。

抽象クラスは共通の機能を提供し、サブクラスがそれを拡張して具体的な機能を実装するためのテンプレートとして機能します。

「抽象クラス」の使用例とその解説

以下に、Kotlinで抽象クラスを使用する例を示します。

このコードでは、抽象クラスの定義とそれを継承するサブクラスの実装方法を示しています。

// 抽象クラスの定義
abstract class Animal(val name: String) {

    // 抽象メソッド（具体的な実装はサブクラスで行う）
    abstract fun makeSound()

    // 具象メソッド（共通の機能を提供する）
    fun introduce() {
        println("こんにちは、私は$nameです。")
    }
}

// 抽象クラスを継承するサブクラスの定義
class Dog(name: String) : Animal(name) {
    // 抽象メソッドの具体的な実装
    override fun makeSound() {
        println("ワンワン！")
    }
}

class Cat(name: String) : Animal(name) {
    // 抽象メソッドの具体的な実装
    override fun makeSound() {
        println("ニャー！")
    }
}

fun main() {
    // Dogクラスのインスタンスを作成
    val dog = Dog("ポチ")
    dog.introduce() // こんにちは、私はポチです。
    dog.makeSound() // ワンワン！

    // Catクラスのインスタンスを作成
    val cat = Cat("タマ")
    cat.introduce() // こんにちは、私はタマです。
    cat.makeSound() // ニャー！
}
  1. 抽象クラスの定義:
    • abstract class Animal(val name: String)は、抽象クラスAnimalを定義しています。このクラスは、名前を保持するプロパティと共通の機能を提供する具象メソッドを持っています。
    • abstract fun makeSound()は、抽象メソッドであり、具体的な実装はサブクラスで行われます。
  2. 具象メソッドの定義:
    • fun introduce()は、共通の機能を提供する具象メソッドです。このメソッドは全てのサブクラスで共通に使用されます。
  3. サブクラスの定義:
    • class Dog(name: String) : Animal(name)は、Animal抽象クラスを継承するDogクラスを定義しています。
    • override fun makeSound()は、抽象メソッドmakeSoundの具体的な実装を提供します。Dogクラスでは「ワンワン！」と出力します。
    • class Cat(name: String) : Animal(name)は、Animal抽象クラスを継承するCatクラスを定義しています。
    • override fun makeSound()は、抽象メソッドmakeSoundの具体的な実装を提供します。Catクラスでは「ニャー！」と出力します。
  4. メイン関数での使用:
    • val dog = Dog("ポチ")は、Dogクラスのインスタンスを作成します。
    • dog.introduce()は、具象メソッドを呼び出して自己紹介を出力します。
    • dog.makeSound()は、抽象メソッドの具体的な実装を呼び出して犬の鳴き声を出力します。
    • val cat = Cat("タマ")は、Catクラスのインスタンスを作成します。
    • cat.introduce()とcat.makeSound()も同様に、猫の自己紹介と鳴き声を出力します。

このように、抽象クラスを使用することで、共通の機能を持つテンプレートを定義し、サブクラスごとに具体的な動作を実装することができます。

これにより、コードの再利用性が向上し、クラス設計がより柔軟になります。

インターフェース

Kotlinの「インターフェース」とは何か、以下に紹介します。

「インターフェース」とは

インターフェース（Interface）とは、クラスやオブジェクトが実装すべきメソッドのシグネチャ（メソッド名、引数、戻り値の型）を定義したものです。

インターフェースは、実装の詳細を持たず、クラスがどのようなメソッドを持つべきかを指定します。

Kotlinでは、クラスは複数のインターフェースを実装することができ、これにより多重継承の問題を避けながら、コードの再利用性と柔軟性を高めることができます。

「インターフェース」の使用例とその解説

以下に、Kotlinでインターフェースを使用する例を示します。

このコードでは、インターフェースの定義と、それを実装するクラスの方法を示しています。

// インターフェースの定義
interface Animal {
    // 抽象メソッドの定義
    fun makeSound()
    
    // 具象メソッドの定義（デフォルト実装）
    fun sleep() {
        println("動物が眠っています。")
    }
}

// インターフェースを実装するクラスの定義
class Dog : Animal {
    // インターフェースの抽象メソッドをオーバーライドして実装
    override fun makeSound() {
        println("ワンワン！")
    }
}

// インターフェースを実装する別のクラスの定義
class Cat : Animal {
    // インターフェースの抽象メソッドをオーバーライドして実装
    override fun makeSound() {
        println("ニャー！")
    }
}

fun main() {
    // Dogクラスのインスタンスを作成
    val dog = Dog()
    dog.makeSound() // ワンワン！
    dog.sleep() // 動物が眠っています。

    // Catクラスのインスタンスを作成
    val cat = Cat()
    cat.makeSound() // ニャー！
    cat.sleep() // 動物が眠っています。
}
  1. インターフェースの定義:
    • interface Animalは、Animalという名前のインターフェースを定義しています。
    • fun makeSound()は抽象メソッドで、実装クラスはこのメソッドを具体的に実装する必要があります。
    • fun sleep()は具象メソッドで、デフォルトの実装を提供します。実装クラスはこのメソッドをオーバーライドすることもできます。
  2. インターフェースを実装するクラスの定義:
    • class Dog : Animalは、Animalインターフェースを実装するDogクラスを定義しています。
    • override fun makeSound()は、Animalインターフェースの抽象メソッドを具体的に実装しています。このメソッドは「ワンワン！」と出力します。
  3. インターフェースを実装する別のクラスの定義:
    • class Cat : Animalは、Animalインターフェースを実装するCatクラスを定義しています。
    • override fun makeSound()は、Animalインターフェースの抽象メソッドを具体的に実装しています。このメソッドは「ニャー！」と出力します。
  4. メイン関数での使用:
    • val dog = Dog()は、Dogクラスのインスタンスを作成します。
    • dog.makeSound()は、DogクラスのmakeSoundメソッドを呼び出し、「ワンワン！」と出力します。
    • dog.sleep()は、Animalインターフェースのデフォルト実装であるsleepメソッドを呼び出し、「動物が眠っています。」と出力します。
    • val cat = Cat()は、Catクラスのインスタンスを作成します。
    • cat.makeSound()およびcat.sleep()も同様に、Catクラスのメソッドを呼び出して対応するメッセージを出力します。

このように、インターフェースを使用することで、クラスが実装すべきメソッドを強制し、複数のクラス間で共通のメソッドを持つことができます。

これにより、コードの一貫性が保たれ、再利用性が向上します。

データクラス

Kotlinの「データクラス」とは何か、以下に紹介します。

「データクラス」とは

データクラス（data class）とは、Kotlinでデータの保持を目的としたクラスです。

通常のクラスとは異なり、データクラスは主にデータの保持と操作を簡単に行えるように設計されています。データクラスは、以下の標準的な機能を自動的に提供します：

  • equals() メソッド
  • hashCode() メソッド
  • toString() メソッド
  • copy() メソッド
  • コンポーネント関数（componentN()）

これにより、データクラスは少ないコードで効率的にデータを扱うことができ、コードの簡潔さと可読性が向上します。

「データクラス」の使用例とその解説

以下に、Kotlinでデータクラスを使用する例を示します。

このコードでは、データクラスの定義とその標準機能を活用する方法を示しています。

// データクラスの定義
data class User(val name: String, val age: Int)

fun main() {
    // Userクラスのインスタンスを作成
    val user1 = User("Alice", 25)

    // データクラスの自動生成されたメソッドの使用例

    // toString() メソッド
    println(user1) // 出力: User(name=Alice, age=25)

    // equals() メソッド
    val user2 = User("Alice", 25)
    println(user1 == user2) // 出力: true

    // copy() メソッド
    val user3 = user1.copy(name = "Bob")
    println(user3) // 出力: User(name=Bob, age=25)

    // componentN() メソッドの使用例
    val (name, age) = user1
    println("名前: $name, 年齢: $age") // 出力: 名前: Alice, 年齢: 25
}
  1. データクラスの定義:
    • data class User(val name: String, val age: Int)は、名前と年齢を持つデータクラスUserを定義しています。このクラスはデータの保持を主な目的としています。
  2. toString() メソッド:
    • データクラスは、自動的にtoString()メソッドを生成します。println(user1)はUserオブジェクトの内容を文字列として出力します。
  3. equals() メソッド:
    • データクラスは、自動的にequals()メソッドを生成します。user1 == user2は、二つのUserオブジェクトが同じデータを持っているかを比較します。この例では、両方のオブジェクトが同じ名前と年齢を持っているため、結果はtrueとなります。
  4. copy() メソッド:
    • データクラスは、自動的にcopy()メソッドを生成します。user1.copy(name = "Bob")は、user1のデータを基に、新しい名前を持つ新しいUserオブジェクトを作成します。この例では、user3は名前が”Bob”で、年齢が25の新しいUserオブジェクトとなります。
  5. componentN() メソッドの使用例:
    • データクラスは、自動的にコンポーネント関数（componentN()）を生成します。val (name, age) = user1は、user1のプロパティを個別の変数に分解します。この例では、nameは”Alice”、ageは25となります。

このように、データクラスを使用することで、少ないコードで効率的にデータを操作でき、コードの簡潔さと可読性を大幅に向上させることができます。

<<用語集３ 問題集Top ー

この記事への意見・コメント

この用語集を作成するにあたりAIを活用しています。

問題ないことは確認していますが、もし間違いや表現の違和感などありましたら、ご指摘頂けると大変助かります。またKotlinの公式サイトの情報も並行して活用しましょう。