<一覧に戻る

多重継承

オブジェクト指向プログラミング（OOP）における多重継承は、1つのクラスが複数のスーパークラス（親クラス）を継承する仕組みです。これにより、サブクラスは複数のスーパークラスから属性やメソッドを引き継ぎ、複雑な機能を持つクラスを柔軟に設計することができます。このセクションでは、Pythonを用いて多重継承の基本概念と実装方法を初心者にもわかりやすく解説します。

多重継承とは？

多重継承は、サブクラスが複数のスーパークラスを持つことで、複数のクラスから機能を継承することを指します。これにより、サブクラスは複数の異なるクラスの特性を組み合わせて新しいクラスを作成することが可能になります。

多重継承の利点

コードの再利用性向上: 複数のクラスから必要な機能を継承することで、コードの重複を避けられます。
柔軟な設計: 異なる機能を持つクラスを組み合わせて、複雑な動作を持つクラスを構築できます。
モジュール性の向上: 機能ごとにクラスを分けて設計することで、メンテナンスが容易になります。

多重継承の注意点

複雑さの増加: 複数のスーパークラスを持つことで、クラス間の関係が複雑になり、理解しづらくなることがあります。
メソッド解決順序（MRO）の理解が必要: 同じメソッド名が複数のスーパークラスに存在する場合、どのメソッドが呼び出されるかを理解する必要があります。
ダイヤモンド継承問題: 複数のスーパークラスが共通のスーパークラスを持つ場合、予期せぬ動作が発生することがあります。

Pythonでの多重継承の基本

Pythonでは、クラス定義時に複数のスーパークラスをカンマで区切って指定することで、多重継承を実現します。以下に基本的な構文と例を示します。

基本構文

class サブクラス(スーパークラス1, スーパークラス2, ...):
    # サブクラスの定義
    pass

サンプルコード

以下に、Flyable と Swimmable という2つのスーパークラスを継承する Duck クラスの例を示します。

class Flyable:
    def fly(self):
        print(f"{self.name} は飛んでいます。")

class Swimmable:
    def swim(self):
        print(f"{self.name} は泳いでいます。")

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name} は鳴きます。")

class Duck(Animal, Flyable, Swimmable):
    def speak(self):
        print(f"{self.name} はガーガーと鳴きます。")

    def quack(self):
        print(f"{self.name} がクワック！")

説明

スーパークラス Flyable と Swimmable:
Flyable クラスは、飛行に関連する機能を提供します。
Swimmable クラスは、水泳に関連する機能を提供します。
スーパークラス Animal:
動物の名前を管理し、基本的な鳴き声を出力する speak メソッドを持ちます。
サブクラス Duck:
Animal, Flyable, Swimmable の3つのスーパークラスを継承しています。
speak メソッドをオーバーライドして、アヒル特有の鳴き声を実装しています。
quack メソッドを追加して、アヒルの特有の動作を定義しています。

メソッド解決順序（MRO）

多重継承では、同じ名前のメソッドが複数のスーパークラスに存在する場合、どのメソッドが呼び出されるかを決定する必要があります。Pythonでは、C3線形化というアルゴリズムに基づいてメソッド解決順序（MRO）を決定します。

MROの確認方法

__mro__ 属性や mro() メソッドを使用して、クラスのMROを確認できます。

print(Duck.__mro__)
# 出力: (<class '__main__.Duck'>, <class '__main__.Animal'>, <class '__main__.Flyable'>, <class '__main__.Swimmable'>, <class 'object'>)

print(Duck.mro())
# 出力: [<class '__main__.Duck'>, <class '__main__.Animal'>, <class '__main__.Flyable'>, <class '__main__.Swimmable'>, <class 'object'>]

サンプルコード

class A:
    def do_something(self):
        print("Aのdo_something")

class B(A):
    def do_something(self):
        print("Bのdo_something")

class C(A):
    def do_something(self):
        print("Cのdo_something")

class D(B, C):
    pass

d = D()
d.do_something()  # 出力: Bのdo_something

print(D.__mro__)
# 出力: (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

説明

クラス D は、クラス B と C を継承しています。
クラス B と C は、どちらもクラス A を継承しており、それぞれ do_something メソッドをオーバーライドしています。
クラス D のインスタンス d が do_something メソッドを呼び出すと、MROに基づいてクラス B の do_something メソッドが実行されます。

ダイヤモンド継承問題

多重継承において、複数のスーパークラスが共通のスーパークラスを持つ場合、ダイヤモンド継承問題が発生することがあります。これにより、スーパークラスのメソッドが複数回呼び出されるなど、予期せぬ動作が発生する可能性があります。

ダイヤモンド継承の例

class A:
    def do_something(self):
        print("Aのdo_something")

class B(A):
    def do_something(self):
        print("Bのdo_something")
        super().do_something()

class C(A):
    def do_something(self):
        print("Cのdo_something")
        super().do_something()

class D(B, C):
    def do_something(self):
        print("Dのdo_something")
        super().do_something()

d = D()
d.do_something()

出力

Dのdo_something
Bのdo_something
Cのdo_something
Aのdo_something

説明

クラス D は、クラス B と C を継承しています。
クラス B と C は、どちらもクラス A を継承しており、それぞれ do_something メソッドをオーバーライドしています。
クラス D の do_something メソッドでは、super() を使用してスーパークラスのメソッドを呼び出しています。
出力を見ると、各クラスの do_something メソッドが順番に呼び出され、クラス A のメソッドが一度だけ実行されています。これは、PythonのMROにより、スーパークラスのメソッドが重複して呼び出されないように制御されているためです。

実践例：形状クラスでの多重継承

以下に、Movable と Drawable という2つのスーパークラスを継承する Shape クラスの例を示します。これにより、形状オブジェクトは移動と描画の機能を持つことができます。

サンプルコード

class Movable:
    def move(self, x, y):
        self.x = x
        self.y = y
        print(f"{self.__class__.__name__} が位置 ({self.x}, {self.y}) に移動しました。")

class Drawable:
    def draw(self):
        print(f"{self.__class__.__name__} を描画しています。")

class Shape(Movable, Drawable):
    def __init__(self, name):
        self.name = name

    def describe(self):
        print(f"これは {self.name} です。")

説明

スーパークラス Movable:
オブジェクトの位置を管理し、移動する move メソッドを提供します。
スーパークラス Drawable:
オブジェクトを描画する draw メソッドを提供します。
サブクラス Shape:
Movable と Drawable の2つのスーパークラスを継承しています。
__init__ メソッドで形状の名前を初期化します。
形状の説明を表示する describe メソッドを追加しています。

使用例

# Shapeクラスのインスタンスを生成
circle = Shape("円")
square = Shape("四角形")

# メソッドの呼び出し
circle.describe()   # 出力: これは 円 です。
circle.move(10, 20) # 出力: Shape が位置 (10, 20) に移動しました。
circle.draw()       # 出力: Shape を描画しています。

square.describe()   # 出力: これは 四角形 です。
square.move(5, 15)  # 出力: Shape が位置 (5, 15) に移動しました。
square.draw()       # 出力: Shape を描画しています。

メソッドオーバーライドと多重継承

多重継承では、サブクラスが複数のスーパークラスからメソッドを継承するため、メソッドオーバーライドが重要な役割を果たします。サブクラスで特定のスーパークラスのメソッドをオーバーライドすることで、必要な動作をカスタマイズできます。

サンプルコード

class Logger:
    def log(self, message):
        print(f"ログ: {message}")

class ErrorLogger(Logger):
    def log(self, message):
        print(f"エラー: {message}")

class Application(ErrorLogger, Movable):
    def __init__(self, name):
        self.name = name

    def run(self):
        self.log(f"{self.name} アプリケーションを起動します。")
        self.move(100, 200)

説明

スーパークラス Logger:
一般的なログ出力機能を提供します。
スーパークラス ErrorLogger:
Logger を継承し、エラーログ専用のメソッドをオーバーライドしています。
サブクラス Application:
ErrorLogger と Movable の2つのスーパークラスを継承しています。
run メソッドで、エラーログを出力し、アプリケーションを特定の位置に移動させています。

使用例

# Applicationクラスのインスタンスを生成
app = Application("MyApp")

# メソッドの呼び出し
app.run()
# 出力:
# エラー: MyApp アプリケーションを起動します。
# Application が位置 (100, 200) に移動しました。

説明

app.run() を呼び出すと、ErrorLogger クラスでオーバーライドされた log メソッドが実行され、エラーメッセージが出力されます。
継承された move メソッドも利用され、アプリケーションが指定された位置に移動します。

注意点：ダイヤモンド継承の回避

多重継承を使用する際、特にダイヤモンド継承問題に注意が必要です。これは、複数のスーパークラスが共通のスーパークラスを持つ場合に発生します。適切な設計とMROの理解が重要です。

ダイヤモンド継承の例

class A:
    def do_something(self):
        print("Aのdo_something")

class B(A):
    def do_something(self):
        print("Bのdo_something")
        super().do_something()

class C(A):
    def do_something(self):
        print("Cのdo_something")
        super().do_something()

class D(B, C):
    def do_something(self):
        print("Dのdo_something")
        super().do_something()

d = D()
d.do_something()

出力

Dのdo_something
Bのdo_something
Cのdo_something
Aのdo_something

説明

クラス D は、クラス B と C を継承しています。
クラス B と C は、どちらもクラス A を継承しており、それぞれ do_something メソッドをオーバーライドしています。
クラス D のインスタンス d が do_something メソッドを呼び出すと、MROに基づいてクラス B、C、A のメソッドが順番に呼び出されます。
PythonのMROにより、クラス A のメソッドが一度だけ実行され、重複して呼び出されることを防いでいます。

実践例：多重継承を用いた複合機能クラス

以下に、Electric と Movable という2つのスーパークラスを継承し、電気自動車の機能を持つ ElectricCar クラスを作成する例を示します。

サンプルコード

class Electric:
    def __init__(self, battery_capacity):
        self.battery_capacity = battery_capacity  # バッテリー容量

    def charge(self):
        print(f"バッテリーを {self.battery_capacity} kWh 充電しました。")

class Movable:
    def __init__(self, speed=0):
        self.speed = speed  # 速度

    def accelerate(self, amount):
        self.speed += amount
        print(f"速度を {amount} km/h 増加させました。現在の速度は {self.speed} km/h です。")

    def brake(self, amount):
        self.speed = max(self.speed - amount, 0)
        print(f"速度を {amount} km/h 減速させました。現在の速度は {self.speed} km/h です。")

class ElectricCar(Electric, Movable):
    def __init__(self, battery_capacity, speed=0, model="Unknown"):
        Electric.__init__(self, battery_capacity)  # Electricクラスのコンストラクタを呼び出す
        Movable.__init__(self, speed)              # Movableクラスのコンストラクタを呼び出す
        self.model = model                        # モデル名

    def display_info(self):
        print(f"モデル: {self.model}, バッテリー容量: {self.battery_capacity} kWh, 速度: {self.speed} km/h")

説明

スーパークラス Electric:
電気自動車のバッテリー容量を管理し、充電する charge メソッドを提供します。
スーパークラス Movable:
車の速度を管理し、加速・減速する accelerate と brake メソッドを提供します。
サブクラス ElectricCar:
Electric と Movable の2つのスーパークラスを継承しています。
__init__ メソッドで両方のスーパークラスのコンストラクタを呼び出し、バッテリー容量と速度を初期化します。
車のモデル名を管理する model 属性を追加しています。
車の情報を表示する display_info メソッドを追加しています。

使用例

# ElectricCarクラスのインスタンスを生成
tesla = ElectricCar(battery_capacity=100, speed=0, model="Tesla Model S")

# メソッドの呼び出し
tesla.display_info()
# 出力: モデル: Tesla Model S, バッテリー容量: 100 kWh, 速度: 0 km/h

tesla.charge()
# 出力: バッテリーを 100 kWh 充電しました。

tesla.accelerate(50)
# 出力: 速度を 50 km/h 増加させました。現在の速度は 50 km/h です。

tesla.brake(20)
# 出力: 速度を 20 km/h 減速させました。現在の速度は 30 km/h です。

tesla.display_info()
# 出力: モデル: Tesla Model S, バッテリー容量: 100 kWh, 速度: 30 km/h

説明

tesla は、ElectricCar クラスから生成された電気自動車のインスタンスです。
display_info メソッドで車の基本情報を表示します。
charge メソッドでバッテリーを充電します。
accelerate メソッドで速度を増加させ、brake メソッドで速度を減速させます。
再度 display_info メソッドを呼び出すことで、最新の車の状態を確認できます。

まとめ

多重継承は、1つのサブクラスが複数のスーパークラスを継承することで、複数の異なるクラスの機能を組み合わせることができます。
利点として、コードの再利用性や柔軟な設計が挙げられますが、注意点としてMROの理解やダイヤモンド継承問題への対策が必要です。
Pythonでは、super() 関数を活用してスーパークラスのメソッドや属性にアクセスすることができます。
実践例として、複数の機能を持つクラスを多重継承で設計することで、複雑なオブジェクトの動作を実現できます。
設計時のポイントとして、クラス間の関係性を明確にし、必要に応じてMROを確認しながらクラスを設計することが重要です。

実際にPythonコードを書いて多重継承を試し、スーパークラスとサブクラスの関係性やMROの仕組みを理解することで、オブジェクト指向プログラミングの柔軟性と強力さを実感できるでしょう。

参考資料

Python公式ドキュメント - クラス
Python入門 - クラスとオブジェクト
[オブジェクト指向プログラミング（OOP）と

前に戻る一覧に戻る

メニュー

User

Python WebAcademy

多重継承

多重継承とは？

多重継承の利点

多重継承の注意点

Pythonでの多重継承の基本

基本構文

サンプルコード

説明

メソッド解決順序（MRO）

MROの確認方法

サンプルコード

説明

ダイヤモンド継承問題

ダイヤモンド継承の例

出力

説明

実践例：形状クラスでの多重継承

サンプルコード

説明

使用例

メソッドオーバーライドと多重継承

サンプルコード

説明

使用例

説明

注意点：ダイヤモンド継承の回避

ダイヤモンド継承の例

出力

説明

実践例：多重継承を用いた複合機能クラス

サンプルコード

説明

使用例

説明

まとめ

参考資料

出力結果：