Java道｜抽象クラスのしくみ

Java道｜抽象クラスのしくみ

未完成だからこそ、土台として強い。
抽象クラスを理解すると、共通ルールを守りながら、クラスごとの個性をきれいに育てられます。

12章では、Javaのオブジェクト指向の中でも少し特別なしくみである 抽象クラス と インターフェイス を学んでいきます。

その最初のテーマが、抽象クラスです。

抽象クラスは、普通のクラスと同じようにフィールドやメソッドを持てます。
しかし、普通のクラスと大きく違う点があります。

それは、抽象クラスそのものからはオブジェクトを作成できない という点です。

なぜなら、抽象クラスは「完成品」ではなく、サブクラスのための共通の土台だからです。

鬼滅の刃風にたとえると、抽象クラスは「和風剣士ならこういう共通ルールを持つはずだ」という設計図です。

たとえば、剣士なら次のような共通要素を持っていそうです。

ただし、show() の中身は剣士ごとに違います。

一般隊士なら名前や階級を表示するかもしれません。
柱なら担当区域や呼吸の型も表示したいかもしれません。
医療担当の剣士なら、特技や支援能力を表示したいかもしれません。

このように、共通部分は親クラスにまとめたいけれど、具体的な処理は子クラスごとに変えたい。
そんなときに使うのが抽象クラスです。

抽象クラスとは何か

抽象クラスは、クラスの前に abstract を付けて宣言する特別なクラスです。

abstract class Slayer
{
}

このように abstract class と書くことで、そのクラスは抽象クラスになります。

抽象クラスは、次のような役割を持ちます。

つまり抽象クラスは、全部が未完成というわけではありません。

共通して使える部分は完成させておきます。
一方で、子クラスごとに違う部分は、抽象メソッドとして「ここは子クラスで決めてください」と残しておきます。

鬼滅の刃風にたとえると、抽象クラスは「剣士の共通訓練書」のようなものです。
速度の設定方法など、全員共通の内容は書かれています。
でも、実際にどんな自己紹介をするか、どんな能力を見せるかは、各剣士クラスに任せるイメージです。

↓クリックすると拡大表示されます。

抽象クラスはオブジェクトを作成できない

抽象クラスの大きな特徴は、new を使って直接オブジェクトを作成できないことです。

たとえば、次のような抽象クラスがあるとします。

abstract class Slayer
{
}

この場合、次のようには書けません。

// これはできない
Slayer slayer1 = new Slayer();

抽象クラスは未完成の土台なので、そのまま実体として作ることはできません。

鬼滅の刃風にたとえると、Slayer は「剣士という概念」です。
しかし、ただの「剣士」という概念だけでは、具体的な人物として任務に出せません。

実際に登場させるには、次のような具体的なクラスが必要です。

つまり、抽象クラスはサブクラスを作るための土台にはなります。
しかし、それ自体は完成品ではないため、直接オブジェクト化できません。

抽象メソッドとは何か

抽象クラスで特に大切なのが、抽象メソッドです。

抽象メソッドとは、処理内容を書かずに、メソッドの形だけを宣言するメソッドです。

abstract void show();

このように、メソッドにも abstract を付けます。
そして、メソッドの中身を表す { } は書きません。

これは、
このメソッドは必ず必要です。ただし、具体的な中身はサブクラスで決めてください
という意味です。

鬼滅の刃風にたとえると、親クラスである Slayer は、次のように命じています。

たとえば、WaterSlayer なら水の呼吸や担当区域を表示するかもしれません。
MedicalSlayer なら治療技術や支援能力を表示するかもしれません。

このように、抽象メソッドは「共通ルールとして必要だけれど、親クラスではまだ具体的に決めない処理」です。

抽象クラスの基本の形

抽象クラスは、普通のメンバと抽象メソッドを組み合わせて作れます。

abstract class Slayer
{
    protected int speed;

    public void setSpeed(int s)
    {
        speed = s;
    }

    abstract void show();
}

この例では、speed と setSpeed() は具体的に定義されています。
一方、show() は抽象メソッドです。

整理すると、次のようになります。

つまり抽象クラスは、
共通部分は完成させ、個別部分は子クラスに任せるクラス
です。

以下の条件でイラストを作成してください。

抽象クラスは何のために必要なのか

抽象クラスが必要になる理由は、共通ルールをまとめながら、子クラスごとの違いもきれいに表現したいからです。

たとえば、鬼滅の刃風に Slayer という抽象クラスを考えます。

剣士なら、共通して speed を持ち、速度を設定する setSpeed() を使えるとします。

しかし、show() で表示したい内容はクラスによって違います。

このとき、親クラスにすべての show() を無理に書くと、子クラスごとの違いを表現しにくくなります。

そこで、親クラスでは show() を抽象メソッドにしておきます。

abstract void show();

こうしておけば、サブクラスは必ず show() を定義する必要があります。

つまり、抽象クラスを使うと次のような設計ができます。

サブクラスは抽象メソッドを定義しなければならない

抽象クラスを継承したサブクラスでオブジェクトを作成できるようにするには、抽象メソッドを具体的に定義する必要があります。

つまり、抽象メソッドはサブクラスでオーバーライドして完成させます。

たとえば、親クラスに次の抽象メソッドがあるとします。

abstract void show();

この親クラスを継承した WaterSlayer では、show() の中身を定義します。

public void show()
{
    System.out.println("水の剣士の情報を表示します。");
}

もしサブクラスが抽象メソッドを定義しなければ、そのサブクラスも未完成のままです。
そのため、通常の完成したクラスとしてオブジェクトを作れません。

鬼滅の刃風にたとえると、親クラス Slayer は「剣士なら自己紹介の技 show() を必ず持ちなさい」と約束だけを決めています。
実際に任務に出る WaterSlayer や MedicalSlayer は、その show() の中身を自分で完成させなければなりません。

抽象クラスを定義してみる

ファイル名：Sample1.java

abstract class Slayer
{
    protected int speed;

    public void setSpeed(int s)
    {
        speed = s;
        System.out.println("速度を" + speed + "にしました。");
    }

    abstract void show();
}

class WaterSlayer extends Slayer
{
    private String name;
    private String breathingStyle;

    public WaterSlayer(String n, String bs)
    {
        name = n;
        breathingStyle = bs;
        System.out.println(name + " 水の呼吸「" + breathingStyle + "」の剣士を作成しました。");
    }

    public void show()
    {
        System.out.println("水の剣士の名前は" + name + "です。");
        System.out.println("呼吸の型は" + breathingStyle + "です。");
        System.out.println("速度は" + speed + "です。");
    }
}

class MedicalSlayer extends Slayer
{
    private String name;
    private String healingSkill;

    public MedicalSlayer(String n, String hs)
    {
        name = n;
        healingSkill = hs;
        System.out.println(name + " 治療技術「" + healingSkill + "」の支援剣士を作成しました。");
    }

    public void show()
    {
        System.out.println("支援剣士の名前は" + name + "です。");
        System.out.println("治療技術は" + healingSkill + "です。");
        System.out.println("速度は" + speed + "です。");
    }
}

class Sample1
{
    public static void main(String[] args)
    {
        Slayer[] slayers;
        slayers = new Slayer[2];

        slayers[0] = new WaterSlayer("水月", "水流斬り");
        slayers[0].setSpeed(60);

        slayers[1] = new MedicalSlayer("胡蝶香", "藤花治療");
        slayers[1].setSpeed(50);

        for(int i = 0; i < slayers.length; i++){
            slayers[i].show();
        }
    }
}

実行結果

水月 水の呼吸「水流斬り」の剣士を作成しました。
速度を60にしました。
胡蝶香 治療技術「藤花治療」の支援剣士を作成しました。
速度を50にしました。
水の剣士の名前は水月です。
呼吸の型は水流斬りです。
速度は60です。
支援剣士の名前は胡蝶香です。
治療技術は藤花治療です。
速度は50です。

親クラス Slayer が抽象クラスになっている

このプログラムで中心になるのは、Slayer クラスが抽象クラスになっているところです。

abstract class Slayer

Slayer クラスには、共通フィールドとして speed があります。

protected int speed;

また、速度を設定する setSpeed() も持っています。

public void setSpeed(int s)
{
    speed = s;
    System.out.println("速度を" + speed + "にしました。");
}

この speed と setSpeed() は、WaterSlayer でも MedicalSlayer でも共通して使えます。

一方で、show() は抽象メソッドです。

abstract void show();

つまり Slayer クラスは、次のような設計です。

鬼滅の刃風にたとえると、Slayer クラスは「剣士なら速度を持ち、速度を設定できる。そして必ず自己紹介できる」という共通ルールを決めています。

ただし、自己紹介の中身は剣士ごとに違うので、show() は子クラスに任せています。

WaterSlayer と MedicalSlayer が show() を完成させている

WaterSlayer と MedicalSlayer は、どちらも Slayer を継承したサブクラスです。

class WaterSlayer extends Slayer

class MedicalSlayer extends Slayer

そして、どちらも show() を自分のクラスに合うように定義しています。

WaterSlayer の show() では、水の剣士らしい情報を表示しています。

public void show()
{
    System.out.println("水の剣士の名前は" + name + "です。");
    System.out.println("呼吸の型は" + breathingStyle + "です。");
    System.out.println("速度は" + speed + "です。");
}

MedicalSlayer の show() では、支援剣士らしい情報を表示しています。

public void show()
{
    System.out.println("支援剣士の名前は" + name + "です。");
    System.out.println("治療技術は" + healingSkill + "です。");
    System.out.println("速度は" + speed + "です。");
}

親クラス Slayer は show() という名前だけを決めています。
実際の表示内容は、それぞれのサブクラスが完成させています。

これが、抽象クラスとオーバーライドを組み合わせた設計です。

抽象クラスの配列でまとめて扱える

このプログラムでは、Slayer[] という配列を使っています。

Slayer[] slayers;
slayers = new Slayer[2];

Slayer は抽象クラスなので、次のように直接オブジェクトを作ることはできません。

// これはできない
Slayer slayer = new Slayer();

しかし、Slayer 型の変数や配列を用意することはできます。

そして、その配列には Slayer を継承した具体的なサブクラスのオブジェクトを入れられます。

slayers[0] = new WaterSlayer("水月", "水流斬り");
slayers[1] = new MedicalSlayer("胡蝶香", "藤花治療");

整理すると、次のようになります。

そして、ループでは同じように show() を呼び出しています。

for(int i = 0; i < slayers.length; i++){
    slayers[i].show();
}

呼び出し方は同じです。
しかし、実際に動く show() はオブジェクトの実体によって変わります。

このように、抽象クラスを使うと、共通の型でまとめながら、実体ごとの個性を活かせます。

抽象クラスを使うと、なぜ分かりやすいコードになるのか

抽象クラスを使うと、コードの設計が分かりやすくなります。

理由は大きく2つあります。

1つ目は、共通ルールが見えることです。

Slayer クラスを見るだけで、次のことが分かります。

2つ目は、まとめて扱いやすくなることです。

WaterSlayer と MedicalSlayer は違うクラスです。
しかし、どちらも Slayer のサブクラスなので、Slayer[] に入れてまとめて扱えます。

さらに、Slayer 側で show() を抽象メソッドとして宣言しているため、呼び出す側は安心して show() を呼べます。

鬼滅の刃風にたとえると、司令部は隊士の種類を細かく知らなくても、
「各自、情報を示せ」
と同じ命令を出せます。

水の剣士は水の剣士らしく、支援剣士は支援剣士らしく、自分の情報を表示します。

抽象クラスと普通のクラスの違い

普通のクラスと抽象クラスの違いを整理すると、次のようになります。

普通のクラスは、そのまま実体化できる完成品です。
抽象クラスは、サブクラスに共通ルールを渡すための未完成の設計図です。

鬼滅の刃風にたとえると、普通のクラスは実際に任務へ出られる具体的な剣士です。
抽象クラスは、剣士たちの共通規則をまとめた訓練書のようなものです。

図：抽象クラスとサブクラスの役割分担

↓クリックすると拡大表示されます。

この図が示していること

この図では、抽象クラス Slayer と、そのサブクラスである WaterSlayer、MedicalSlayer の役割分担を表しています。

上部の Slayer は抽象クラスです。
共通フィールド speed と共通メソッド setSpeed() を持っています。

一方で、show() は abstract show() として未完成のままです。
そのため、Slayer から直接オブジェクトを作ることはできません。

下部の WaterSlayer と MedicalSlayer は、Slayer を継承した具体的なクラスです。
それぞれが show() を自分の内容に合わせて完成させています。

この図から分かることは、抽象クラスは共通ルールをまとめ、具体的な処理はサブクラスに任せるための土台だということです。

図：抽象クラス型の配列でまとめて扱う

↓クリックすると拡大表示されます。

この図が示していること

この図では、抽象クラス Slayer 型の配列に、WaterSlayer と MedicalSlayer のオブジェクトを入れている様子を表しています。

Slayer は抽象クラスなので、new Slayer() のように直接オブジェクトは作れません。
しかし、Slayer 型の配列や変数として使うことはできます。

配列の中には、Slayer を継承した具体的なクラスのオブジェクトを入れられます。

ループでは、どちらにも同じように show() を呼び出しています。

slayers[i].show();

しかし、実際に動く show() は、オブジェクトの実体によって変わります。

この図から分かることは、抽象クラスを使うと、共通の型でまとめながら、サブクラスごとの個性ある処理を動かせるということです。

鬼滅の刃風に抽象クラスを整理する

抽象クラスは、鬼滅の刃風にたとえると、
剣士ならこうあるべきという共通ルールをまとめた、未完成の設計図
です。

Slayer クラスは、剣士の共通土台です。

ただし、show() の中身は剣士ごとに違います。

つまり抽象クラスは、共通ルールを決めながら、個性の部分はサブクラスに任せる仕組みです。

この考え方を使うと、

というように、継承と多態性をより整理して使えるようになります。

この内容で押さえておきたいポイント

抽象クラスは、未完成だから弱いのではありません。

共通部分をまとめ、子クラスに必ず作ってほしい処理を示し、サブクラスを同じ型で扱えるようにする。
その意味で、抽象クラスは 未完成だからこそ、共通の土台として強いクラス です。