Javaの抽象クラスとインターフェースの違いとその具体的な適用例

Javaにおいて、抽象クラスとインターフェースは、オブジェクト指向プログラミングの中核を成す重要な概念です。これらはどちらもクラス設計において多態性を実現するための手段ですが、それぞれ異なる役割と特徴を持ちます。本記事では、これらの概念の違いと具体的な適用例を通じて、どのような場合にどちらを使用すべきかを理解する手助けをします。Javaプログラムの設計において、適切な選択をするための知識を深めましょう。

抽象クラスの基本概念

抽象クラスとは、インスタンス化ができないクラスの一種で、サブクラスに共通の機能やデータを提供するためのテンプレートとして使用されます。抽象クラスは、完全なメソッドの他に、実装が未定義の抽象メソッドを含むことができ、これにより、サブクラスに特定のメソッドの実装を強制することが可能です。

抽象クラスの定義

抽象クラスは、abstractキーワードを使用して定義されます。クラスの一部のメソッドだけを具体的に実装し、他のメソッドはサブクラスで実装するように強制する場合に用いられます。

abstract class Animal {
    String name;

    void breathe() {
        System.out.println("This animal breathes air.");
    }

    abstract void makeSound(); // 抽象メソッド
}

この例では、Animalクラスが抽象クラスとして定義されており、makeSoundメソッドは抽象メソッドとして宣言されています。このメソッドは、具体的なサブクラス（例えばDogやCat）で実装する必要があります。

抽象クラスの特徴

• 継承：抽象クラスは、他のクラスに継承されることを前提として作られています。
• 部分実装：一部のメソッドは具体的に実装され、一部は抽象的に残されます。
• メンバ変数の利用：インスタンス変数を持つことができ、サブクラスでその値を共有したり、共通のメソッドを持つことができます。

抽象クラスは、サブクラス間で共通の機能を提供しつつ、特定の機能は各サブクラスで異なる実装を必要とする場合に非常に有効です。

インターフェースの基本概念

インターフェースは、クラスが実装すべきメソッドの契約を定義するためのテンプレートです。インターフェースには、実装されるべきメソッドのシグネチャ（メソッド名、引数、戻り値の型）だけが宣言され、具体的な実装は行われません。これにより、異なるクラス間で一貫した動作を保証することができます。

インターフェースの定義

インターフェースは、interfaceキーワードを使用して定義されます。インターフェース内で宣言されるメソッドは、すべて自動的にabstract（抽象）であり、具体的な実装は持ちません。また、インターフェースに含まれる変数は、すべてstaticかつfinalです。

interface AnimalBehavior {
    void eat(); // 抽象メソッド
    void sleep(); // 抽象メソッド
}

この例では、AnimalBehaviorというインターフェースが定義されています。このインターフェースを実装するクラスは、eatおよびsleepメソッドを必ず実装しなければなりません。

インターフェースの特徴

• 多重継承の回避：Javaではクラスの多重継承がサポートされていませんが、インターフェースを使うことで、複数のインターフェースを実装することができます。これにより、多様な機能を一つのクラスに統合することが可能です。
• 柔軟性：インターフェースを実装することで、異なるクラス間で共通の動作を保証し、クラス間の互換性を保ちながら異なる機能を持つことができます。
• 実装の強制：インターフェースを実装したクラスは、インターフェース内のすべてのメソッドを具体的に実装する必要があります。これにより、クラス間で一定のメソッドが必ず提供されることが保証されます。

インターフェースは、複数のクラスに共通の機能を持たせたい場合や、異なるクラスが同じ一連の動作を提供する必要がある場合に特に有効です。

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

Javaにおいて、抽象クラスとインターフェースは共に多態性を実現する手段として利用されますが、それぞれ異なる特性を持っています。ここでは、両者の主な違いを詳しく見ていきます。

継承と実装の違い

抽象クラスは、クラスの継承を通じて機能を提供しますが、インターフェースは、クラスが特定のメソッド群を実装するための契約を提供します。抽象クラスではextendsキーワードを使って継承しますが、インターフェースではimplementsキーワードを使用します。

// 抽象クラスの例
abstract class Animal {
    abstract void makeSound();
}

// インターフェースの例
interface AnimalBehavior {
    void eat();
    void sleep();
}

このように、抽象クラスとインターフェースは異なるキーワードを使ってクラスに適用されます。

メソッドの実装に関する違い

抽象クラスは、抽象メソッドと具象メソッドの両方を持つことができますが、インターフェースは基本的にメソッドのシグネチャのみを持ちます（ただし、Java 8以降では、インターフェースにもデフォルトメソッドや静的メソッドを含めることができます）。

abstract class Animal {
    void breathe() {
        System.out.println("This animal breathes air.");
    }
    abstract void makeSound();
}

interface AnimalBehavior {
    void eat();
    void sleep();
}

この例では、Animalクラスがbreatheという具体的なメソッドを持っている一方で、AnimalBehaviorインターフェースはメソッドの実装を持たず、契約だけを定義しています。

複数の継承の違い

Javaでは、クラスは一つのクラスしか継承できませんが、インターフェースは複数実装することが可能です。これにより、クラスは一つの親クラスから機能を継承しつつ、複数のインターフェースから契約を引き継ぐことができます。

class Dog extends Animal implements AnimalBehavior {
    void makeSound() {
        System.out.println("Woof!");
    }
    public void eat() {
        System.out.println("Dog is eating.");
    }
    public void sleep() {
        System.out.println("Dog is sleeping.");
    }
}

この例では、DogクラスがAnimalクラスを継承しつつ、AnimalBehaviorインターフェースも実装していることがわかります。

使用する場面の違い

• 抽象クラスの使用：クラス間で共通の機能や状態を持たせたい場合に使用します。例えば、同じ基本機能を持つが一部機能が異なるクラス群を定義する際に適しています。
• インターフェースの使用：異なるクラスが共通の動作を実装することを保証したい場合に使用します。これにより、異なる型のオブジェクトでも同じメソッドを呼び出すことができます。

抽象クラスとインターフェースの選択は、クラス設計の目的や使用する状況に応じて適切に判断することが重要です。

抽象クラスの適用例

抽象クラスは、共通の機能を持つクラス間でのコードの再利用を促進しつつ、サブクラスに特定の実装を強制する場合に非常に役立ちます。ここでは、抽象クラスを使用した実際の適用例を示します。

動物の種類に応じた鳴き声の実装

たとえば、動物を表現するプログラムを考えてみましょう。このプログラムでは、すべての動物が共通の機能（呼吸するなど）を持ちつつ、種類によって異なる鳴き声を持つことができます。ここで、Animalという抽象クラスを定義し、具体的な動物クラス（例えばDogやCat）をそのサブクラスとして実装します。

abstract class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    void breathe() {
        System.out.println(name + " is breathing.");
    }

    abstract void makeSound(); // 抽象メソッド
}

class Dog extends Animal {
    Dog(String name) {
        super(name);
    }

    @Override
    void makeSound() {
        System.out.println(name + " says: Woof!");
    }
}

class Cat extends Animal {
    Cat(String name) {
        super(name);
    }

    @Override
    void makeSound() {
        System.out.println(name + " says: Meow!");
    }
}

このコードでは、Animalクラスが抽象クラスとして定義されており、makeSoundメソッドが抽象メソッドとして宣言されています。この抽象メソッドは、DogやCatなどのサブクラスで具体的に実装されています。

抽象クラスのメリット

この例のように、抽象クラスを使用することで以下のようなメリットが得られます：

• 共通のコードを再利用：breatheメソッドのように、すべてのサブクラスで共通して使用されるコードを一度だけ実装することで、コードの重複を減らし、メンテナンス性を向上させます。
• 一部のメソッドのみをサブクラスに実装させる：makeSoundメソッドのように、サブクラスに特定のメソッドの実装を強制することで、統一されたインターフェースを持ちながら、クラスごとに異なる動作を持たせることができます。

拡張性と柔軟性

新しい動物の種類を追加する場合も、単にAnimalクラスを継承した新しいサブクラスを作成し、makeSoundメソッドを実装するだけで済みます。例えば、Birdクラスを追加する場合は以下のようにします。

class Bird extends Animal {
    Bird(String name) {
        super(name);
    }

    @Override
    void makeSound() {
        System.out.println(name + " says: Tweet!");
    }
}

このように、抽象クラスは共通の機能を持ちながら、クラスごとに異なる動作を持たせる必要がある場合に非常に有効です。また、新しいクラスを追加する際のコードの再利用や拡張性にも優れています。

インターフェースの適用例

インターフェースは、異なるクラスが共通の動作を提供することを保証するために使用されます。これにより、異なるクラスが同じインターフェースを実装することで、共通のメソッドを提供し、ポリモーフィズムを実現することができます。ここでは、インターフェースを利用した具体的な適用例を示します。

動作インターフェースの実装

例えば、複数の動物が異なる種類の動きをするプログラムを考えます。このプログラムでは、動物が異なる移動方法（歩く、飛ぶ、泳ぐ）を持つことができます。Movableというインターフェースを定義し、これを各動物クラスが実装することで、共通の移動メソッドを提供することができます。

interface Movable {
    void move();
}

class Dog implements Movable {
    @Override
    public void move() {
        System.out.println("Dog is walking.");
    }
}

class Bird implements Movable {
    @Override
    public void move() {
        System.out.println("Bird is flying.");
    }
}

class Fish implements Movable {
    @Override
    public void move() {
        System.out.println("Fish is swimming.");
    }
}

このコードでは、Movableインターフェースが定義され、そのmoveメソッドがDog、Bird、Fishクラスでそれぞれ異なる形で実装されています。これにより、異なる動物が異なる方法で移動するという動作を共通のインターフェースを通じて実現しています。

インターフェースのメリット

インターフェースを使用することで得られる主なメリットは以下の通りです：

• 柔軟な設計：インターフェースを実装するクラスは、複数のインターフェースを同時に実装できるため、柔軟な設計が可能です。例えば、動物が異なる動作（移動、音を出すなど）を持つ場合、それぞれのインターフェースを実装することで、複雑な動作を定義できます。
• コードの一貫性：異なるクラス間で共通のインターフェースを実装することで、同じメソッドを呼び出すことができ、コードの一貫性と可読性が向上します。

実装の柔軟性

インターフェースを使用することで、将来的に異なるクラスが同じ動作を提供する際にも柔軟に対応できます。新しいクラスを追加する場合は、そのクラスがインターフェースを実装するだけで、共通の動作を提供することができます。

例えば、新しいCatクラスを追加し、Movableインターフェースを実装する場合、以下のように実装します。

class Cat implements Movable {
    @Override
    public void move() {
        System.out.println("Cat is sneaking.");
    }
}

このように、インターフェースを使用することで、異なるクラスが同じ操作を提供しつつ、それぞれ独自の動作を持たせることが可能です。これは、コードの再利用性を高め、異なるクラス間で共通の動作を保証するために非常に有効です。

抽象クラスとインターフェースの使い分け

Javaプログラミングにおいて、抽象クラスとインターフェースはそれぞれ異なる目的で使用されますが、どのような状況でどちらを選択すべきかを理解することが重要です。ここでは、抽象クラスとインターフェースの使い分けについて具体的なガイドラインを示します。

共通の状態やメソッドを持たせる必要がある場合：抽象クラス

抽象クラスは、共通の状態（インスタンス変数）やメソッドをサブクラスに持たせたい場合に使用されます。例えば、複数のクラスが共通のフィールドや一部共通のメソッド実装を持つ必要がある場合、抽象クラスが適しています。

abstract class Vehicle {
    int speed;

    void setSpeed(int speed) {
        this.speed = speed;
    }

    abstract void move();
}

この例では、Vehicle抽象クラスが共通のフィールドspeedとその設定メソッドを提供し、異なる種類の乗り物がこのクラスを継承して特定の移動方法を実装することができます。

複数の動作を持たせたい場合：インターフェース

インターフェースは、異なるクラスが同じ動作を提供することを保証したい場合に適しています。特に、複数の異なる動作（例えば、MovableとEatable）をクラスに持たせたい場合には、インターフェースを使用します。

interface Movable {
    void move();
}

interface Eatable {
    void eat();
}

class Dog implements Movable, Eatable {
    @Override
    public void move() {
        System.out.println("Dog is walking.");
    }

    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

この例では、DogクラスがMovableとEatableという複数のインターフェースを実装し、それぞれ異なる動作を提供しています。

拡張性と保守性を考慮した選択

プロジェクトが拡張されることを考慮する場合、柔軟な設計が求められます。インターフェースは、複数の実装を提供する必要がある場合や、異なるクラスに共通の動作を持たせたい場合に役立ちます。一方で、抽象クラスは、クラス間で共通のフィールドや既定のメソッド実装を提供する必要がある場合に使用されます。

具体的な使い分けのガイドライン

• 抽象クラスを使用：
• サブクラス間で共通の状態やメソッドを持たせたい場合
• 一部のメソッドを具体的に実装し、他のメソッドはサブクラスに実装を強制したい場合
• クラスの階層構造を設計する際
• インターフェースを使用：
• 異なるクラスに同じ動作を持たせたい場合
• クラスが複数の異なる動作を持つ必要がある場合（多重継承が必要な場合）
• 実装を提供せず、メソッドのシグネチャのみを定義したい場合

実際の開発シナリオにおける選択

実際の開発シナリオでは、抽象クラスとインターフェースを適切に使い分けることで、コードの可読性と保守性を向上させることができます。プロジェクトの要件に応じて、どちらが最適かを判断し、適切な設計を行うことが重要です。

このように、抽象クラスとインターフェースはそれぞれ異なる強みを持っており、使用する場面に応じて適切に使い分けることが、柔軟で拡張性の高いプログラムを作成するための鍵となります。

共通点と相違点の整理

抽象クラスとインターフェースは、Javaプログラミングにおいて多態性を実現するための重要な要素ですが、それぞれの使い方には明確な違いがあります。ここでは、両者の共通点と相違点を整理し、図解を交えて理解を深めます。

共通点

• 多態性の実現：どちらも多態性（ポリモーフィズム）を実現するために使用されます。これにより、異なるクラスが同じインターフェースや抽象クラスを基にした同様の振る舞いを持つことができます。
• メソッドの強制実装：どちらもサブクラスや実装クラスに特定のメソッドを実装させることを強制できます。抽象クラスでは抽象メソッドを使用し、インターフェースではメソッドシグネチャを定義します。
• 再利用性の向上：共通の機能やメソッドを定義することで、コードの再利用性を向上させ、冗長なコードを減らすことができます。

相違点

• 継承と実装：抽象クラスは単一継承でのみ使用でき、他のクラスから継承されることが前提です。一方、インターフェースは複数のインターフェースを実装することが可能で、クラスが複数の異なる動作を持つことができます。
• 具体的な実装：抽象クラスは具体的なメソッド実装を含むことができますが、インターフェースは基本的にメソッドのシグネチャのみを定義します（ただし、Java 8以降ではデフォルトメソッドや静的メソッドも含めることができます）。
• 状態の保持：抽象クラスはインスタンス変数を持つことができ、クラス内で状態を保持することができますが、インターフェースはインスタンス変数を持てず、状態を保持しません。

図解による比較

以下の図は、抽象クラスとインターフェースの主要な違いを視覚的に示しています。

+--------------------+----------------------+-----------------------+
|                    |  抽象クラス          |  インターフェース     |
+--------------------+----------------------+-----------------------+
|  継承可能性        |  単一クラスのみ継承   |  複数のインターフェース|
|                    |                      |  を実装可能           |
+--------------------+----------------------+-----------------------+
|  メソッドの実装    |  具体的なメソッド実装 |  基本的に無し (Java 8  |
|                    |  を含むことができる   |  以降はデフォルト     |
|                    |                      |  メソッドを持てる)    |
+--------------------+----------------------+-----------------------+
|  インスタンス変数  |  保持可能            |  保持不可             |
+--------------------+----------------------+-----------------------+
|  使用場面          |  共通の状態や         |  共通の動作を         |
|                    |  一部の共通メソッドを |  クラス間で共有する   |
|                    |  持たせたい場合       |  必要がある場合       |
+--------------------+----------------------+-----------------------+

まとめ

抽象クラスとインターフェースは、それぞれの設計目的や使い方に応じて使い分ける必要があります。抽象クラスは共通の状態や一部の実装を提供する際に有効であり、インターフェースは異なるクラスが同じ動作を提供する必要がある場合に適しています。これらの特性を理解し、適切な場面で使い分けることで、Javaプログラムの設計がより効率的かつ柔軟になります。

デザインパターンにおける役割

抽象クラスとインターフェースは、オブジェクト指向設計の中で重要なデザインパターンを実現するための基盤となります。ここでは、それぞれが特定のデザインパターンでどのような役割を果たすかを解説します。

抽象クラスとファクトリーメソッドパターン

ファクトリーメソッドパターンは、オブジェクトの生成をサブクラスに委譲するパターンで、抽象クラスを用いて実装されることが一般的です。抽象クラスは、オブジェクトの生成方法を定義し、その具体的な生成処理をサブクラスに任せることで、クライアントコードから生成の詳細を隠蔽します。

abstract class Creator {
    abstract Product createProduct();

    void operation() {
        Product product = createProduct();
        product.use();
    }
}

class ConcreteCreatorA extends Creator {
    @Override
    Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteCreatorB extends Creator {
    @Override
    Product createProduct() {
        return new ConcreteProductB();
    }
}

この例では、Creatorという抽象クラスが定義され、具体的なプロダクト生成はConcreteCreatorAやConcreteCreatorBが実装しています。このように、ファクトリーメソッドパターンでは、抽象クラスを使ってオブジェクトの生成手順を統一しながら、サブクラスで具体的な生成方法を決定します。

インターフェースとストラテジーパターン

ストラテジーパターンは、アルゴリズムをクラスとしてカプセル化し、実行時に動的に選択するパターンです。インターフェースは、このパターンで異なるアルゴリズムを提供するために利用されます。インターフェースを実装する各クラスが、特定のアルゴリズムを定義します。

interface Strategy {
    void execute();
}

class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy A");
    }
}

class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy B");
    }
}

class Context {
    private Strategy strategy;

    void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    void performAction() {
        strategy.execute();
    }
}

この例では、Strategyインターフェースが定義され、それを実装するConcreteStrategyAやConcreteStrategyBが具体的なアルゴリズムを提供しています。クライアントコードは、Contextクラスに異なるストラテジーを注入することで、実行時にアルゴリズムを変更できます。

インターフェースと抽象クラスの組み合わせによるデザインパターン

多くのデザインパターンでは、インターフェースと抽象クラスを組み合わせて使用することで、柔軟かつ再利用性の高い設計を実現します。例えば、テンプレートメソッドパターンでは、抽象クラスが基本的な処理の流れを定義し、その一部をサブクラスに実装させることで柔軟性を確保します。

また、インターフェースを用いて共通の操作を定義し、具体的な処理は抽象クラスとそのサブクラスで実装することで、異なるアルゴリズムや操作を統一的に扱うことが可能です。

デザインパターンの選択と適用

プロジェクトの設計において、適切なデザインパターンを選択することは、ソフトウェアの拡張性、保守性、再利用性を高める鍵となります。抽象クラスとインターフェースの特性を理解し、それらを適切に組み合わせることで、設計の柔軟性を最大限に引き出すことができます。

このように、抽象クラスとインターフェースは、それぞれの特性を生かしてデザインパターンを実現するための重要な要素となります。これらを効果的に活用することで、堅牢で拡張性のあるソフトウェア設計を行うことができます。

抽象クラスとインターフェースの組み合わせ

抽象クラスとインターフェースは、個別に使用されるだけでなく、組み合わせて使用することで、より柔軟で再利用性の高い設計を実現することができます。ここでは、両者を組み合わせて使う際の具体的なケースとその効果について解説します。

複雑なオブジェクト階層の設計

例えば、ソフトウェアで様々な種類の図形を描画する機能を持つ場合、図形の基本的な共通機能を抽象クラスに持たせつつ、特定の動作をインターフェースで定義することができます。これにより、基本機能を共有しながら、特定の図形に応じた振る舞いを柔軟に定義できます。

// 図形の基本機能を提供する抽象クラス
abstract class Shape {
    String color;

    Shape(String color) {
        this.color = color;
    }

    abstract void draw(); // 各図形に特有の描画メソッド
}

// 動きを定義するインターフェース
interface Movable {
    void move(int x, int y);
}

// 円形の図形クラス（抽象クラスとインターフェースを組み合わせ）
class Circle extends Shape implements Movable {
    int radius;

    Circle(String color, int radius) {
        super(color);
        this.radius = radius;
    }

    @Override
    void draw() {
        System.out.println("Drawing a " + color + " circle with radius " + radius);
    }

    @Override
    public void move(int x, int y) {
        System.out.println("Moving the circle to position (" + x + ", " + y + ")");
    }
}

// 四角形の図形クラス
class Rectangle extends Shape implements Movable {
    int width, height;

    Rectangle(String color, int width, int height) {
        super(color);
        this.width = width;
        this.height = height;
    }

    @Override
    void draw() {
        System.out.println("Drawing a " + color + " rectangle with width " + width + " and height " + height);
    }

    @Override
    public void move(int x, int y) {
        System.out.println("Moving the rectangle to position (" + x + ", " + y + ")");
    }
}

この例では、Shape抽象クラスが図形の基本的な情報（色など）と描画機能を提供し、Movableインターフェースが図形の移動に関する動作を定義しています。CircleやRectangleなどの具象クラスは、これらを組み合わせて使用することで、色や形の情報を持ちつつ、移動機能を実装することができます。

メリットと効果

このように抽象クラスとインターフェースを組み合わせることで、以下のメリットがあります：

• 高い再利用性：基本機能を抽象クラスで提供し、異なる動作をインターフェースで定義することで、コードの再利用性を高めます。
• 柔軟な設計：インターフェースを使うことで、異なるクラスが共通の操作を持ちながら、抽象クラスによって共通の基本機能を共有できるため、柔軟な設計が可能です。
• 拡張性：新たな図形クラスや動作を追加する場合も、既存の抽象クラスやインターフェースを再利用することで、容易に拡張できます。

実際の開発における応用例

実際の開発現場では、例えばUIコンポーネントやゲームオブジェクトの設計において、抽象クラスとインターフェースを組み合わせて使用することが一般的です。これにより、基礎となる共通機能を提供しつつ、各コンポーネントやオブジェクトが特有の動作や振る舞いを持つことができます。

このように、抽象クラスとインターフェースを適切に組み合わせることで、クラス設計の柔軟性と拡張性を大幅に向上させることができます。これらの技術を効果的に活用することが、堅牢でメンテナンス性の高いソフトウェア開発の鍵となります。

演習問題と解答例

ここまでの内容を理解し、実践的なスキルを磨くために、抽象クラスとインターフェースに関する演習問題を用意しました。問題に取り組みながら、Javaにおけるこれらの概念の使い方を深く理解しましょう。

演習問題 1: 動物クラスの設計

以下の要件に従って、Animal抽象クラスとMovableインターフェースを使用したJavaクラスを設計してください。

• Animal抽象クラスは、すべての動物に共通するメソッドeat（食べる）を持ち、各動物固有の鳴き声を出すmakeSoundメソッドを抽象メソッドとして定義してください。
• Movableインターフェースは、move（移動する）メソッドを持ちます。
• DogとBirdクラスを作成し、それぞれAnimalクラスを継承し、Movableインターフェースを実装してください。
• 各クラスでmakeSoundメソッドとmoveメソッドを具体的に実装してください。

解答例

// 抽象クラス Animal
abstract class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

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

    abstract void makeSound();
}

// インターフェース Movable
interface Movable {
    void move();
}

// Dogクラス
class Dog extends Animal implements Movable {
    Dog(String name) {
        super(name);
    }

    @Override
    void makeSound() {
        System.out.println(name + " says: Woof!");
    }

    @Override
    public void move() {
        System.out.println(name + " is running.");
    }
}

// Birdクラス
class Bird extends Animal implements Movable {
    Bird(String name) {
        super(name);
    }

    @Override
    void makeSound() {
        System.out.println(name + " says: Tweet!");
    }

    @Override
    public void move() {
        System.out.println(name + " is flying.");
    }
}

// テスト実行クラス
public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog("Buddy");
        dog.eat();
        dog.makeSound();
        ((Movable) dog).move();

        Animal bird = new Bird("Tweety");
        bird.eat();
        bird.makeSound();
        ((Movable) bird).move();
    }
}

演習問題 2: 家電製品クラスの設計

以下の条件に基づいて、家電製品を管理するクラスを設計してください。

• Applianceという抽象クラスを作成し、turnOnとturnOffというメソッドを具体的に実装します。
• Electricというインターフェースを作成し、consumePowerというメソッドを定義します。
• TVとRefrigeratorというクラスを作成し、Applianceクラスを継承し、Electricインターフェースを実装してください。
• TVクラスでは電力消費が1時間当たり100W、Refrigeratorクラスでは150Wとします。

解答例

// 抽象クラス Appliance
abstract class Appliance {
    String brand;

    Appliance(String brand) {
        this.brand = brand;
    }

    void turnOn() {
        System.out.println(brand + " appliance is now ON.");
    }

    void turnOff() {
        System.out.println(brand + " appliance is now OFF.");
    }
}

// インターフェース Electric
interface Electric {
    void consumePower();
}

// TVクラス
class TV extends Appliance implements Electric {
    TV(String brand) {
        super(brand);
    }

    @Override
    public void consumePower() {
        System.out.println(brand + " TV consumes 100W per hour.");
    }
}

// Refrigeratorクラス
class Refrigerator extends Appliance implements Electric {
    Refrigerator(String brand) {
        super(brand);
    }

    @Override
    public void consumePower() {
        System.out.println(brand + " Refrigerator consumes 150W per hour.");
    }
}

// テスト実行クラス
public class Main {
    public static void main(String[] args) {
        TV tv = new TV("Sony");
        tv.turnOn();
        tv.consumePower();
        tv.turnOff();

        Refrigerator fridge = new Refrigerator("LG");
        fridge.turnOn();
        fridge.consumePower();
        fridge.turnOff();
    }
}

演習問題のポイント

これらの演習問題では、抽象クラスとインターフェースの違いや、それぞれが持つ利点を理解し、具体的にどのように使い分けるかを学ぶことができます。また、設計の際にこれらを組み合わせることで、コードの柔軟性や拡張性が向上することを実感できるでしょう。

以上の演習を通じて、抽象クラスとインターフェースの理解がさらに深まり、実際の開発で効果的に活用できるようになるはずです。

まとめ

本記事では、Javaにおける抽象クラスとインターフェースの違いとその具体的な適用例について詳しく解説しました。抽象クラスは共通の状態や部分的な実装を提供する際に使用され、インターフェースはクラスが同じ動作を共有するために使用されます。また、両者を組み合わせることで、より柔軟で拡張性の高い設計が可能となります。

さらに、デザインパターンにおける役割や、実際のプログラムでの使い分けについても紹介し、理解を深めるための演習問題を通じて実践的なスキルを養いました。これらの知識を活用し、より効果的なJavaプログラミングを行いましょう。