Kotlinの抽象クラス・インターフェースの違いと使い分けを初心者向けにやさしく解説！

1. 抽象クラスとは？Kotlinでの基本

1. 抽象クラスとは？Kotlinでの基本

Kotlinの抽象クラス（abstract class）とは、「共通の機能や動きをまとめておくけれど、そのままでは使えないクラス」のことです。あくまで“設計図”のような存在で、実際に動かすには子クラスで具体的な中身を書き足します。

たとえば「動物」という大きなグループを考えると、どの動物も眠りますが、鳴き方は動物ごとに違いますよね。このとき、「眠る」処理は共通で、「鳴く」処理だけそれぞれの動物に任せるような形が抽象クラスです。

abstract class Animal {
    // 鳴き方は動物によって違うので、中身は書かずに約束だけ
    abstract fun makeSound()

    // 眠る動作は共通なので、そのまま使える
    fun sleep() {
        println("眠っています")
    }
}

抽象クラスのポイントは、abstractを付けた関数には中身がないこと。これが「設計図だけがある状態」です。実際に使うには、子クラスで具体的な処理を必ず書く必要があります。

もう少しイメージしやすい例を見てみましょう。

class Cat : Animal() {
    override fun makeSound() {
        println("ニャーと鳴いています")
    }
}

fun main() {
    val cat = Cat()
    cat.makeSound()  // 子クラスで作った処理
    cat.sleep()      // 親クラスの共通機能
}

ニャーと鳴いています
眠っています

このように、抽象クラスは「共通の機能を持ちつつ、部分的に子クラスへ任せる」ために使われます。コードを整理しやすくなるので、Kotlinでしっかり覚えておきたい仕組みです。

2. 抽象クラスを継承して使う

2. 抽象クラスを継承して使う

抽象クラスは、そのままでは使えない“設計図”なので、実際に動かすには子クラスで継承します。そして、abstractが付いた関数は、必ず子クラス側で中身を書く必要があります。これをoverrideと呼びます。

イメージとしては「親がざっくりルールを決めて、子が具体的なやり方を決める」ようなものです。では、先ほどのAnimalを使って、犬のクラスを作ってみましょう。

class Dog : Animal() {
    override fun makeSound() {
        println("ワンワン！")
    }
}

makeSound()に中身が追加され、「犬が鳴くときの処理」が完成しました。この時点でようやく実行できる形になっています。

fun main() {
    val dog = Dog()
    dog.makeSound()  // 子クラスで作った処理
    dog.sleep()      // 親クラスの共通機能
}

ワンワン！
眠っています

ここで注目したいのは、子クラスで書き直した関数と、親クラスのまま使える関数が共存していることです。Kotlinでは、このように「共通部分は親に置き、違う部分だけ子クラスごとに作る」という書き方ができるので、コードの重複を減らし、読みやすく整理できます。

3. インターフェースとは？Kotlinでの基本

3. インターフェースとは？Kotlinでの基本

インターフェース（interface）は、「このクラスは、こんな動きができますよ」と約束するためのしくみです。たとえば、空を飛ぶ動きを持たせたいとき、クラスごとに飛び方は違っていても「飛ぶ」という機能だけは共通しますよね。そんなときにインターフェースが役立ちます。

インターフェースでは、処理の中身を書かず、「この関数を必ず作ってくださいね」というルールだけ提示します。クラス側はそのルールを守って処理を追加するだけなので、あとから別のクラスにも同じ機能を付けやすくなります。

イメージとしては「使う時に中身を入れる、空っぽの関数を渡す契約書」です。

interface Flyable {
    fun fly() // この関数を必ず作る約束
}

これだけでは実際に動きませんが、あくまで「飛ぶ機能がありますよ」という宣言です。ほかのクラスがこのインターフェースを使うことで、好きな飛び方を自由に書き足せます。

4. インターフェースの実装方法

4. インターフェースの実装方法

インターフェースは「この機能を必ず持っています」と宣言するだけなので、実際に動かすにはクラス側で中身を書き足します。使うときは:を付けてインターフェース名を書くだけなので、とてもシンプルです。「鳥は飛べる」という設定で考えてみましょう。

class Bird : Flyable {
    // Flyableで約束しているfly関数の中身をここで作る
    override fun fly() {
        println("パタパタ飛んでいます")
    }
}

overrideは「親で決められた約束を、ここでちゃんと実装します」という意味です。これを書かないとエラーになり、プログラムは動きません。

fun main() {
    val bird = Bird()
    bird.fly()   // Birdに書いた動作が実行される
}

パタパタ飛んでいます

このように、インターフェースを実装すると、決められた関数が必ず存在するので、どのクラスでも同じ名前の機能が安心して使えます。「決まった形の機能を追加したいとき」にとても便利です。

5. 抽象クラスとインターフェースの違い

5. 抽象クラスとインターフェースの違い

ここで、Kotlinの抽象クラスとインターフェースの違いを初心者向けに整理します。同じ「共通ルール」を作りますが、得意分野が少し違います。

• 抽象クラス：共通の性質をまとめる設計図。プロパティ（状態）と関数（振る舞い）の両方を持て、共通処理も書けます。コンストラクタや初期化も扱えます。
• インターフェース：できること（能力）を約束する契約書。基本は「この関数を用意してね」というルールだけを示します（処理は実装側で用意）。
• 継承数：クラスは抽象クラスを1つだけ継承可。インターフェースは複数同時に実装できます。
• 使い分けの目安：共通のデータや初期化が必要なら抽象クラス／「飛べる・歩ける」など能力を後付けしたいならインターフェース。

短いサンプルでイメージしましょう。車という共通の性質（メーカー名や起動方法）は抽象クラス、充電できる能力はインターフェースで表します。

abstract class Vehicle(val brand: String) {
    abstract fun start()            // 車ごとに違う起動方法
    fun info() = println("メーカー: $brand") // 共通処理
}

interface Chargeable {
    fun charge()                    // 充電できる能力の約束
}

class EV : Vehicle("Nissan"), Chargeable {
    override fun start() { println("ボタンで起動") }
    override fun charge() { println("急速充電中...") }
}

fun main() {
    val car = EV()
    car.info()   // 抽象クラスの共通処理
    car.start()  // 具体的な起動方法
    car.charge() // 能力（インターフェース）
}

メーカー: Nissan
ボタンで起動
急速充電中...

このように、「共通の土台」=抽象クラス、「後から付け足す能力」=インターフェースと覚えると判断しやすく、クラス設計がすっきり整理できます。

6. インターフェースの複数実装ができる例

6. インターフェースの複数実装ができる例

Kotlinでは、インターフェースをいくつも同時に実装できます。

interface Walkable {
    fun walk()
}

class Human : Walkable, Flyable {
    override fun walk() {
        println("歩いています")
    }

    override fun fly() {
        println("想像の中で飛んでいます")
    }
}

fun main() {
    val person = Human()
    person.walk()
    person.fly()
}

歩いています
想像の中で飛んでいます

このように、WalkableとFlyableという2つのインターフェースを同時に使えます。

7. どちらを使うべき？使い分けのポイント

7. どちらを使うべき？使い分けのポイント

Kotlinで抽象クラスとインターフェースを使い分けるときは、次のようなポイントで判断します。

• 共通のプロパティ（状態）を持たせたい → 抽象クラス
• 複数の動作ルールを柔軟に追加したい → インターフェース
• 他のクラスをすでに継承している → インターフェース（多重継承が可能だから）

どちらも「共通ルール」を決めるためのものですが、役割と使い方が少しずつ違います。

8. 抽象クラスとインターフェースの使い方を身近な例で

8. 抽象クラスとインターフェースの使い方を身近な例で

例えば、「家電」という抽象クラスがあり、共通で電源を入れる関数とメーカー名という情報があるとします。

一方、「ネット接続できる機能」はどんな家電でも持てるように、インターフェースとして用意します。

abstract class Appliance(val brand: String) {
    abstract fun turnOn()
}

interface NetworkCapable {
    fun connectToWifi()
}

class SmartTV(brand: String) : Appliance(brand), NetworkCapable {
    override fun turnOn() {
        println("$brandのテレビを起動します")
    }

    override fun connectToWifi() {
        println("Wi-Fiに接続しました")
    }
}

fun main() {
    val tv = SmartTV("ソニー")
    tv.turnOn()
    tv.connectToWifi()
}

ソニーのテレビを起動します
Wi-Fiに接続しました

このように、抽象クラスとインターフェースを組み合わせることで、柔軟で分かりやすい設計ができます。

まとめ

まとめ

Kotlinのクラス設計において、「抽象クラス」と「インターフェース」は非常に重要なキーワードです。今回の記事では、それぞれの役割や違い、使い分けの考え方を初心者向けにやさしく解説しました。

抽象クラスは、共通する処理や状態（プロパティ）を持ちつつ、子クラスで処理内容を具体的に実装させたいときに使います。一方でインターフェースは、「何ができるか」という動作（関数）のルールだけを定めたいときに利用します。つまり、抽象クラス＝共通の設計図＋機能実装、インターフェース＝行動の契約書と覚えておくとわかりやすいです。

特にKotlinでは、クラスはひとつの抽象クラスしか継承できませんが、インターフェースは複数同時に実装できるという特徴があるため、柔軟な設計が求められる現場ではよく併用されます。以下は、抽象クラスとインターフェースを組み合わせた実践的なコード例です。

abstract class Vehicle(val name: String) {
    abstract fun start()
    fun stop() {
        println("$name を停止します")
    }
}

interface Electric {
    fun charge()
}

class EVCar(name: String) : Vehicle(name), Electric {
    override fun start() {
        println("$name のエンジンを起動します")
    }

    override fun charge() {
        println("$name を充電中です")
    }
}

fun main() {
    val tesla = EVCar("テスラ")
    tesla.start()
    tesla.charge()
    tesla.stop()
}

テスラ のエンジンを起動します
テスラ を充電中です
テスラ を停止します

このように、抽象クラスによって共通の処理（startやstopなど）を提供し、インターフェースによって追加の動作（charge）を柔軟に定義できる設計は、現実のアプリ開発でも多く見られます。

プログラミング初心者のうちは、「継承って難しい」「overrideって何？」と感じるかもしれませんが、動物や乗り物、家電などの例でイメージをつかみながら学ぶと理解しやすくなります。また、「プロパティが必要なら抽象クラス」「動作だけならインターフェース」といった判断基準を持っておくと、設計の幅がぐっと広がります。

Kotlinでオブジェクト指向を学ぶには、まずこの2つの違いと使い方をしっかり理解することが大切です。今回の内容をもとに、実際のプロジェクトでも応用してみてください。

この記事を読んだ人からの質問

この記事を読んだ人からの質問

プログラミング初心者からのよくある疑問／質問を解決します

Kotlinの抽象クラスとインターフェースの違いがまだよく分かりません。簡単に言うとどう違うのですか？

抽象クラスは「共通の機能や状態を持つ親クラス」として使い、インターフェースは「複数のクラスに共通の機能ルールを与える契約書のようなもの」です。

Kotlinで抽象クラスを使う具体的なメリットは何ですか？

Kotlinで抽象クラスを使うと、複数の子クラスに共通する処理やプロパティをひとつの親クラスにまとめることができ、コードの再利用や保守がしやすくなります。

Kotlinの抽象クラスはプロパティも持てるのですか？

はい、抽象クラスでは状態を保持するプロパティも定義できるため、クラス間で共通の値や設定を使いたいときに便利です。

Kotlinのインターフェースではプロパティは使えないのですか？

Kotlinのインターフェースでもプロパティは定義できますが、状態（値）を持つことはできません。定義はできますが初期化はできず、あくまで「存在のルール」の提示です。