Javaにおける継承とコンポジションの使い分け: 実践的ガイド

継承とコンポジションは、オブジェクト指向プログラミングの設計において、クラス間の関係を構築するための基本的な手法です。Javaプログラムを設計する際、これらの手法をどのように使い分けるかは、コードの再利用性、メンテナンス性、拡張性に大きな影響を与えます。適切に選択することで、シンプルで柔軟な設計が可能になりますが、誤った選択をすると複雑な構造やバグの温床となりかねません。本記事では、Javaにおける継承とコンポジションの基本的な概念を理解し、それぞれの使いどころについて具体的な例を通じて解説します。これにより、最適な設計を行い、より良いソフトウェアを開発するための指針を得られるでしょう。

継承とは

継承は、オブジェクト指向プログラミングにおいて、新しいクラスを既存のクラスから派生させる手法です。Javaでは、extendsキーワードを用いてクラス間の継承関係を定義します。これにより、サブクラスは親クラスのフィールドやメソッドを自動的に継承し、再利用できるようになります。

継承の利点

継承の主な利点は、コードの再利用と共通の機能を持つクラス群を容易に構築できる点です。親クラスで定義されたメソッドをサブクラスで再利用することで、コードの冗長性を減らし、保守性を高めることが可能です。また、サブクラスは親クラスのメソッドをオーバーライドして独自の実装を行うこともできます。

継承の欠点

一方で、継承にはいくつかの欠点も存在します。継承によってクラス間に強い結びつきが生じ、親クラスに依存した設計が発生する可能性があります。これにより、親クラスに変更が加わった際にサブクラス全体に影響を及ぼすことがあります。また、継承を多用するとクラス階層が複雑化し、コードの理解やメンテナンスが難しくなることもあります。

継承は、適切に使用すれば強力な手法となりますが、使いすぎると逆にシステムの複雑さを増大させるリスクがあるため、慎重な設計が求められます。

コンポジションとは

コンポジションは、オブジェクト指向プログラミングにおいて、クラスが他のクラスのインスタンスを持つことで機能を拡張する手法です。Javaでは、あるクラスが別のクラスのフィールドとしてインスタンスを保持することで、継承とは異なる方法でコードの再利用や機能の組み合わせを実現します。

コンポジションの利点

コンポジションの最大の利点は、柔軟で拡張性の高い設計が可能になることです。クラス間の結合度が低くなるため、1つのクラスを変更しても他のクラスに影響を与えにくく、メンテナンスが容易です。また、動的にオブジェクトの構成を変更できるため、特定の機能や動作を状況に応じて変更することが可能です。

継承との違い

継承は「is-a」関係、つまりサブクラスが親クラスの一種であることを表しますが、コンポジションは「has-a」関係、すなわちクラスが他のクラスの一部または機能を所有していることを示します。この違いにより、コンポジションはより柔軟で多様な構造を持つオブジェクトを設計する際に適しています。

コンポジションは、複雑なシステムの設計において、必要に応じて機能を組み合わせたり変更したりする際に非常に有効です。特に、クラス間の結合度を低く保ちながら、コードの再利用を促進したい場合に適しています。

継承の具体的な例とコード

Javaでの継承を理解するために、簡単な例を見てみましょう。ここでは、動物を表すAnimalクラスと、それを継承したDogクラスを使って説明します。

Animalクラスの定義

Animalクラスは、すべての動物に共通するプロパティとメソッドを持っています。

class Animal {
    String name;

    void eat() {
        System.out.println(name + " is eating.");
    }

    void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

このクラスは、nameというプロパティを持ち、eatとsleepというメソッドを定義しています。これらはすべての動物に共通する動作です。

Dogクラスの定義

次に、Animalクラスを継承するDogクラスを定義します。Dogクラスは、Animalクラスのすべてのプロパティとメソッドを継承しつつ、新たなメソッドを追加します。

class Dog extends Animal {

    void bark() {
        System.out.println(name + " is barking.");
    }
}

Dogクラスでは、barkという新しいメソッドが追加されています。Dogクラスのインスタンスは、Animalクラスから継承したeatやsleepメソッドも利用可能です。

コードの実行例

これらのクラスを使って、実際にオブジェクトを作成し、メソッドを呼び出してみましょう。

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

このコードを実行すると、以下のような出力が得られます。

Buddy is eating.
Buddy is sleeping.
Buddy is barking.

まとめ

この例では、DogクラスがAnimalクラスを継承することで、共通の機能を再利用しつつ、犬特有の動作を追加する方法を示しました。このように継承を使うことで、コードの再利用性を高めると同時に、特定のクラスに固有の機能を追加することができます。しかし、クラス間の強い結びつきを生じるため、設計時にはその影響を考慮する必要があります。

コンポジションの具体的な例とコード

コンポジションを使用すると、オブジェクトを柔軟に組み合わせることができます。ここでは、動物を表すAnimalクラスと、それに対して特定の動作を持たせるためのBehaviorクラスを使った例を見ていきます。

Behaviorクラスの定義

まず、動物の特定の行動を表すBehaviorクラスを定義します。このクラスは、動物が行える一般的な動作をメソッドとして持ちます。

class Behavior {
    void eat(String name) {
        System.out.println(name + " is eating.");
    }

    void sleep(String name) {
        System.out.println(name + " is sleeping.");
    }

    void bark(String name) {
        System.out.println(name + " is barking.");
    }
}

このクラスには、eat、sleep、barkの各メソッドがあり、いずれも動物の名前を引数として受け取り、その動作を出力します。

Animalクラスの定義

次に、Behaviorクラスのインスタンスを使用して、Animalクラスを定義します。Animalクラスは、Behaviorクラスのインスタンスをフィールドとして保持し、それを使って動作を行います。

class Animal {
    String name;
    Behavior behavior;

    Animal(String name) {
        this.name = name;
        this.behavior = new Behavior();
    }

    void eat() {
        behavior.eat(name);
    }

    void sleep() {
        behavior.sleep(name);
    }

    void bark() {
        behavior.bark(name);
    }
}

このAnimalクラスは、コンストラクタで動物の名前を受け取り、Behaviorクラスのインスタンスを作成します。動物が行う動作はすべて、このBehaviorインスタンスを介して行われます。

コードの実行例

次に、Animalクラスを使ってオブジェクトを作成し、動作を呼び出してみましょう。

public class Main {
    public static void main(String[] args) {
        Animal dog = new Animal("Buddy");
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

このコードを実行すると、以下のような出力が得られます。

Buddy is eating.
Buddy is sleeping.
Buddy is barking.

まとめ

この例では、AnimalクラスがBehaviorクラスをインスタンスとして保持することで、継承を使用せずに動作を組み合わせました。このようにコンポジションを使うことで、動作を動的に追加・変更できる柔軟な設計が可能になります。コンポジションは、オブジェクト間の結合度を低く保ちながら、機能の再利用を実現するための強力な手法です。特に、異なる動作を持つオブジェクトを作成したい場合や、動的に機能を追加したい場合に有効です。

継承を選ぶべき場合

継承は、クラス間に「is-a」の関係がある場合に最適です。つまり、あるクラスが別のクラスの一種であり、その親クラスの全ての特徴を受け継ぐ必要がある場合に使用するべきです。ここでは、継承を選択するべき具体的なシナリオをいくつか紹介します。

共通の動作を持つクラス群の設計

例えば、Vehicle（車両）という親クラスを持ち、そのサブクラスとしてCarやMotorcycleを作成する場合、これらのクラスは共通の動作（例えばstartEngineやstopEngine）を持っています。このような場合、Vehicleクラスでその共通の動作を定義し、サブクラスで継承するのが適切です。

class Vehicle {
    void startEngine() {
        System.out.println("Engine started.");
    }

    void stopEngine() {
        System.out.println("Engine stopped.");
    }
}

class Car extends Vehicle {
    // Car-specific methods can be added here
}

class Motorcycle extends Vehicle {
    // Motorcycle-specific methods can be added here
}

このように、継承を使用することで、共通の動作を簡単に再利用でき、コードの冗長性を減らすことができます。

型安全性の確保

継承を使用することで、親クラス型の変数にサブクラスのインスタンスを代入できるため、型安全性を確保できます。例えば、複数の異なるサブクラスのインスタンスを一つのコレクションに格納したい場合、共通の親クラス型を使用することでこれを実現できます。

List<Vehicle> vehicles = new ArrayList<>();
vehicles.add(new Car());
vehicles.add(new Motorcycle());

この例では、Vehicle型のリストにCarとMotorcycleのインスタンスを追加できます。これにより、異なる種類のオブジェクトを統一的に扱うことができます。

テンプレートメソッドパターンの実装

テンプレートメソッドパターンを使う場合も、継承が適しています。このパターンでは、親クラスに基本的な処理の流れを定義し、サブクラスで特定のステップをオーバーライドすることで、共通の処理の流れを保ちながら、具体的な動作を変更できます。

abstract class Game {
    void play() {
        start();
        playTurn();
        end();
    }

    abstract void start();
    abstract void playTurn();
    abstract void end();
}

class Chess extends Game {
    void start() { System.out.println("Chess game started."); }
    void playTurn() { System.out.println("Chess move made."); }
    void end() { System.out.println("Chess game ended."); }
}

このパターンにより、共通のプロセスを再利用しつつ、異なる動作を実装できます。

まとめ

継承は、クラス間に強い関連性があり、共通の動作やデータを再利用したい場合に適しています。また、型安全性を確保したい場合や、テンプレートメソッドパターンなどの設計パターンを使用する際にも有効です。ただし、継承を多用するとクラス間の結合度が高くなり、柔軟性が失われることがあるため、慎重に使用することが重要です。

コンポジションを選ぶべき場合

コンポジションは、クラス間に「has-a」の関係がある場合に適しています。つまり、あるクラスが他のクラスのインスタンスを所有し、そのクラスの機能を利用する形で設計を行うときに使用します。ここでは、コンポジションを選択するべき具体的なシナリオを紹介します。

動的な機能追加が必要な場合

コンポジションは、オブジェクトに動的に機能を追加したり変更したりする必要がある場合に非常に有効です。例えば、ゲームキャラクターが異なる武器を装備する場合、それぞれの武器が別のクラスで実装されており、キャラクターはその武器クラスを所有する形で機能を持ちます。

class Weapon {
    void use() {
        System.out.println("Using weapon.");
    }
}

class Sword extends Weapon {
    @Override
    void use() {
        System.out.println("Swinging a sword.");
    }
}

class Gun extends Weapon {
    @Override
    void use() {
        System.out.println("Firing a gun.");
    }
}

class Character {
    private Weapon weapon;

    void setWeapon(Weapon weapon) {
        this.weapon = weapon;
    }

    void attack() {
        weapon.use();
    }
}

この例では、CharacterクラスはWeaponクラスのインスタンスを持ち、SwordやGunのような異なる武器を動的に装備できます。これにより、継承を使わずに柔軟に機能を切り替えることが可能です。

クラスの結合度を低く保ちたい場合

コンポジションは、クラス間の結合度を低く保つことができ、変更に強い設計を実現します。例えば、Loggerクラスを使ってログ出力を行う場合、Loggerをコンポジションで取り入れることで、ログ出力の仕組みを他のクラスに依存させずに済みます。

class Logger {
    void log(String message) {
        System.out.println("Log: " + message);
    }
}

class UserService {
    private Logger logger = new Logger();

    void createUser(String username) {
        logger.log("Creating user: " + username);
        // Create user logic
    }
}

このように、Loggerを持つことでUserServiceクラスは独立性を保ちながら、必要な機能を実装しています。

異なる機能の組み合わせが必要な場合

複数の異なる機能を持つオブジェクトを設計する場合、コンポジションを使ってそれぞれの機能を組み合わせることが可能です。例えば、スマートフォンのように多機能なデバイスを設計する際に、CameraやGPSのような機能を別々のクラスとして持ち、それをコンポジションで組み合わせます。

class Camera {
    void takePhoto() {
        System.out.println("Photo taken.");
    }
}

class GPS {
    void findLocation() {
        System.out.println("Location found.");
    }
}

class Smartphone {
    private Camera camera = new Camera();
    private GPS gps = new GPS();

    void takePhoto() {
        camera.takePhoto();
    }

    void useGPS() {
        gps.findLocation();
    }
}

この例では、SmartphoneクラスがCameraとGPSクラスを所有しており、これによりスマートフォンとしての機能を構築しています。

まとめ

コンポジションは、柔軟性が求められる設計やクラス間の結合度を低く保ちたい場合に適しています。動的に機能を追加したり、異なる機能を組み合わせたりする場面では、コンポジションが非常に効果的です。また、システムの一部を変更しても他の部分に影響を与えにくい設計を実現するため、メンテナンス性が高く、将来的な拡張にも対応しやすいです。

継承とコンポジションの併用

継承とコンポジションは、それぞれ異なる状況で有効ですが、これらを併用することで、さらに強力で柔軟な設計を実現できます。特に、システム全体の構造が複雑になり、異なるレベルでのコード再利用や柔軟性が求められる場合には、この併用が効果的です。

併用の基本的な考え方

継承とコンポジションを併用する際の基本的な考え方は、「is-a」と「has-a」の関係を明確にすることです。クラスの階層構造がしっかりとした継承関係で構築され、同時に各クラスが必要な機能をコンポジションで持つことで、コードの再利用性と柔軟性が両立します。

具体例: UIフレームワークの設計

例えば、UIフレームワークを設計する場合、基本的なUIコンポーネント（ボタンやテキストボックスなど）は共通のUIComponentクラスから継承し、その共通の機能を再利用します。一方で、各コンポーネントの具体的な振る舞い（クリックイベントやデータバインディングなど）はコンポジションで追加します。

// 基本的なUIコンポーネントのクラス
abstract class UIComponent {
    void render() {
        // 共通の描画ロジック
        System.out.println("Rendering UI component.");
    }
}

// ボタンクラス
class Button extends UIComponent {
    private ClickEvent clickEvent;

    Button(ClickEvent clickEvent) {
        this.clickEvent = clickEvent;
    }

    void click() {
        clickEvent.execute();
    }
}

// クリックイベントを表すクラス
class ClickEvent {
    void execute() {
        System.out.println("Button clicked!");
    }
}

この例では、ButtonクラスがUIComponentクラスを継承し、基本的な描画機能を再利用しています。同時に、ClickEventクラスをコンポジションとして持つことで、クリック動作を独立した形で管理しています。

設計の柔軟性を高める

このような設計では、新しいUIコンポーネントを作成する際に、共通の機能を継承しつつ、特定の動作をコンポジションで追加できます。これにより、新しいコンポーネントの作成が容易になり、システムの拡張が柔軟に行えるようになります。

また、コンポジションを用いることで、既存のコンポーネントに新しい機能を後から追加することも簡単になります。例えば、ボタンに新しいクリックイベントを追加したい場合、新しいClickEventクラスを作成し、Buttonに渡すだけで対応できます。

まとめ

継承とコンポジションを併用することで、クラス間の関係を明確にしながら、柔軟で再利用可能なコードを作成することができます。このアプローチは、複雑なシステムや大規模なプロジェクトで特に有効であり、拡張性と保守性を高めるための強力な設計手法です。適切に使い分けることで、堅牢で柔軟なシステムを構築することが可能となります。

デザインパターンにおける継承とコンポジションの使い分け

継承とコンポジションは、多くのデザインパターンにおいて重要な役割を果たしています。これらの手法を効果的に使用することで、柔軟で再利用可能な設計が可能になります。ここでは、代表的なデザインパターンにおける継承とコンポジションの使い分けについて解説します。

テンプレートメソッドパターン: 継承の活用

テンプレートメソッドパターンは、処理の共通部分を親クラスに定義し、具体的な部分をサブクラスに委ねるパターンです。このパターンでは、継承を使って共通の処理を再利用しつつ、サブクラスで特定の処理をオーバーライドすることで、柔軟性を持たせることができます。

abstract class Game {
    void play() {
        start();
        playTurn();
        end();
    }

    abstract void start();
    abstract void playTurn();
    abstract void end();
}

class Chess extends Game {
    void start() { System.out.println("Chess game started."); }
    void playTurn() { System.out.println("Chess move made."); }
    void end() { System.out.println("Chess game ended."); }
}

この例では、Gameクラスが共通の処理の流れを定義し、Chessクラスがその具体的な処理を提供しています。継承を使うことで、コードの再利用が促進され、共通の流れが保たれます。

ストラテジーパターン: コンポジションの活用

ストラテジーパターンは、特定のアルゴリズムをクラスとして分離し、それをコンポジションによってクラスに注入するパターンです。これにより、アルゴリズムの選択や変更が柔軟に行えます。

interface PaymentStrategy {
    void pay(int amount);
}

class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

class PayPalPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal.");
    }
}

class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

この例では、PaymentStrategyインターフェースを実装した具体的な支払い方法クラスがあり、ShoppingCartクラスがそのインスタンスを持ちます。これにより、支払い方法を動的に切り替えることができ、柔軟な設計が可能です。

デコレーターパターン: 継承とコンポジションの併用

デコレーターパターンは、オブジェクトに動的に新しい機能を追加するために、継承とコンポジションを組み合わせたパターンです。元のクラスを継承しつつ、新しい機能をコンポジションで追加することで、拡張性のある設計を実現します。

interface Coffee {
    String getDescription();
    double getCost();
}

class SimpleCoffee implements Coffee {
    public String getDescription() {
        return "Simple coffee";
    }

    public double getCost() {
        return 2.0;
    }
}

class MilkDecorator implements Coffee {
    private Coffee coffee;

    MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    public String getDescription() {
        return coffee.getDescription() + ", milk";
    }

    public double getCost() {
        return coffee.getCost() + 0.5;
    }
}

この例では、MilkDecoratorがCoffeeインターフェースを実装し、元のCoffeeオブジェクトをコンポジションで保持します。これにより、新しい機能（ミルクの追加）を柔軟に追加できます。

まとめ

デザインパターンにおける継承とコンポジションの使い分けは、柔軟で再利用可能なコード設計を実現するために不可欠です。テンプレートメソッドパターンのように共通の流れを継承で管理する場面や、ストラテジーパターンのようにアルゴリズムをコンポジションで分離する場面など、それぞれのパターンに最適な手法を選択することで、強固で柔軟なシステムを構築できます。また、デコレーターパターンのように両者を併用することで、さらなる柔軟性と拡張性を持たせることも可能です。

避けるべきアンチパターン

継承とコンポジションは強力な設計手法ですが、使い方を誤ると、かえってコードの複雑さや保守性の低下を招く危険があります。ここでは、継承やコンポジションを誤って使用することで生じるアンチパターンと、その回避策について解説します。

過剰な継承: 深いクラス階層の問題

過剰な継承は、クラス階層が深くなりすぎることにより、システムの複雑さを増大させるアンチパターンです。多くのレベルの継承があると、特定のクラスの振る舞いを理解するために、親クラスやその上位クラスまでさかのぼって確認する必要が生じます。これにより、コードの可読性が低下し、バグが発生しやすくなります。

回避策

継承の深さを制限し、共通の機能が少ないクラスに対してはコンポジションを使用することを検討してください。継承は「is-a」関係が明確である場合にのみ使用し、無理にクラスを階層化しないように注意します。

God Object（神オブジェクト）: 多すぎる責務の集中

God Objectは、単一のクラスが過剰な責務を持ち、システム全体のロジックを一手に引き受けてしまうアンチパターンです。コンポジションを使用する場合に、すべての機能や操作を1つのクラスに集約してしまうと、この問題が発生します。結果として、クラスが肥大化し、保守が困難になります。

回避策

SOLID原則の一つである単一責任の原則（SRP）を守り、各クラスは一つの責務のみを持つように設計します。必要に応じて、責務を分割し、小さなクラスに分けてコンポジションで組み合わせることで、コードの可読性と保守性を向上させます。

脆弱な基底クラス: 基底クラスの設計ミス

継承の際、基底クラス（親クラス）の設計が不適切だと、サブクラスでの問題が発生しやすくなります。基底クラスに多くの機能を詰め込みすぎたり、抽象度が低すぎたりすると、サブクラスでのオーバーライドが煩雑になり、コードが予測しにくい動作をすることがあります。

回避策

基底クラスは可能な限り抽象的で、シンプルな設計を心掛けましょう。基底クラスにあまりに多くの機能を追加しないようにし、サブクラスでの拡張を容易にするための柔軟性を持たせるようにします。共通の機能は、必要に応じて別のクラスとして切り出し、コンポジションで再利用できるように設計することも有効です。

レゴブロックのようなコンポジション: 無秩序なクラスの組み合わせ

コンポジションの利点は、柔軟に機能を組み合わせられる点にありますが、無秩序にクラスを組み合わせると、設計が無駄に複雑化し、結果として管理が困難になります。特に、関連性の低いクラスや責務が不明確なクラスを無計画に組み合わせると、システムの整合性が崩れる恐れがあります。

回避策

コンポジションを使用する際には、各クラスが持つべき明確な責務を定義し、それに基づいて機能を組み合わせるようにします。また、各クラスがどのように協力して動作するかを設計段階でしっかりと計画し、システム全体の整合性を保つことが重要です。

まとめ

継承とコンポジションは強力なツールですが、適切に使用しないとシステムの設計を複雑化させるリスクがあります。過剰な継承や責務の集中、基底クラスの設計ミス、無秩序なコンポジションの使用などは避け、設計原則に基づいた慎重なクラス設計を心掛けることが重要です。これにより、保守性が高く、柔軟なシステムを構築することができます。

実践的な演習問題

ここでは、継承とコンポジションの理解を深めるための実践的な演習問題をいくつか用意しました。これらの問題を解くことで、継承とコンポジションの使い分けや適用方法を具体的に体験できます。

問題1: 継承を使ったクラスの設計

以下の条件を満たすクラス階層を設計してください。

• 親クラスShapeを定義し、共通のメソッドdrawを持つ。
• Shapeクラスを継承するCircleクラスとRectangleクラスを作成し、それぞれのdrawメソッドをオーバーライドして、異なる形状を描画する。

ヒント: Shapeクラスは抽象クラスとして定義し、具体的な形状の描画はサブクラスで実装します。

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

class Rectangle extends Shape {
    void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

この問題を通じて、継承を使用して共通のインターフェースを持つクラスを設計する方法を理解します。

問題2: コンポジションを使った機能の追加

以下の条件を満たすクラスを設計してください。

• クラスPrinterを定義し、その中にPrintStrategyインターフェースを使用して、異なる印刷方法（例えば、TextPrinterとImagePrinter）を実装する。
• PrinterクラスにPrintStrategyをセットし、printメソッドを呼び出すと、選択した印刷方法が実行されるようにする。

ヒント: PrintStrategyインターフェースを定義し、それを実装する具体的なクラスを作成します。Printerクラスはこのインターフェースを持つオブジェクトをコンポジションで保持します。

interface PrintStrategy {
    void print();
}

class TextPrinter implements PrintStrategy {
    public void print() {
        System.out.println("Printing text.");
    }
}

class ImagePrinter implements PrintStrategy {
    public void print() {
        System.out.println("Printing image.");
    }
}

class Printer {
    private PrintStrategy printStrategy;

    void setPrintStrategy(PrintStrategy printStrategy) {
        this.printStrategy = printStrategy;
    }

    void print() {
        printStrategy.print();
    }
}

この問題を通じて、コンポジションを利用して動的に機能を追加・変更する方法を学びます。

問題3: 継承とコンポジションの併用

以下の条件を満たすクラスを設計してください。

• 動物を表すAnimalクラスを定義し、共通のメソッドmakeSoundを持つ。
• Animalクラスを継承するDogとCatクラスを作成し、それぞれのmakeSoundメソッドをオーバーライドする。
• 各動物が食事をする動作を追加するために、EatBehaviorインターフェースを定義し、それをDogとCatクラスにコンポジションで組み込む。

ヒント: EatBehaviorインターフェースは、eatメソッドを定義し、DogやCatクラスにそれぞれ異なる食事動作を実装します。

interface EatBehavior {
    void eat();
}

class DogEatBehavior implements EatBehavior {
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

class CatEatBehavior implements EatBehavior {
    public void eat() {
        System.out.println("Cat is eating.");
    }
}

abstract class Animal {
    abstract void makeSound();
}

class Dog extends Animal {
    private EatBehavior eatBehavior;

    Dog(EatBehavior eatBehavior) {
        this.eatBehavior = eatBehavior;
    }

    void makeSound() {
        System.out.println("Woof!");
    }

    void eat() {
        eatBehavior.eat();
    }
}

class Cat extends Animal {
    private EatBehavior eatBehavior;

    Cat(EatBehavior eatBehavior) {
        this.eatBehavior = eatBehavior;
    }

    void makeSound() {
        System.out.println("Meow!");
    }

    void eat() {
        eatBehavior.eat();
    }
}

この問題では、継承とコンポジションを併用することで、柔軟で拡張可能な設計を実践します。

まとめ

これらの演習問題を通じて、継承とコンポジションの適切な使い方を学び、実際の開発でこれらの手法をどのように適用できるかを理解します。問題を解きながら、各手法の利点と欠点を体験し、より効果的なオブジェクト指向設計を身につけることができます。

まとめ

本記事では、Javaにおける継承とコンポジションの使い分けについて詳しく解説しました。継承は共通の機能を持つクラス群に対してコードの再利用を促進するために適していますが、過剰な継承はシステムの複雑さを増大させるリスクがあります。一方、コンポジションはクラス間の結合度を低く保ち、動的な機能追加や変更に柔軟に対応するために有効です。また、これらの手法を適切に組み合わせることで、強力で拡張性の高い設計が可能になります。継承とコンポジションの特性を理解し、具体的な場面で最適な手法を選択することで、保守性が高く、柔軟なシステムを構築するための重要なスキルを習得できます。