Java ポリモーフィズム(多様性) 〜実装をしてみる〜

イントロダクション

前回の学習を踏まえて、抽象クラス、インターフェースを使用して簡単なプログラムを作成してみようと考えています。

頭で理解しても、実践が伴わなければものになりません。

前回の学習ポイント

継承関係を作り、下の図のようなクラス関係を作成しました。

そして、RpgCharacterクラスは、抽象クラスです。

以下のような手順で作成しました。

!. 通常のlクラスを作成する(RpgCharacter)

必要なプロパティ(属性を追加する)
それぞれのGeter&Setterを作成
このクラスを継承するすべてのクラスに共通するであろうメソッドを作成
```
/** にげる */
public void escape() {
System.out.println(this.name + "は逃げ出した");
}
```
実装する各クラスによって別の処理をさせたいので、抽象メソッドを作成
```
/** 抽象メソッド「たたかう」 */
public void attack(Monster monst);
```
RpgCharacterクラスを継承して、Wizardクラスなどのクラスを作成する

このように、クラス関係を作ると、RpgCharacterクラスを継承したクラスを全てRpgCharacterクラス型の変数で各クラスオブジェクトを使用することができる。
＜RpgCharacterクラス型の変数でいろんなクラスを使う＞

public static void main(String[] args) {
        RpgCharacter[] party = new RpgCharacter[2];
        party[0] = new RpgHero("太郎");
        party[1] = new RpgWizard("二郎");

        System.out.println("こんにちは、良いパーティですね。");
        for (int i = 0; i < party.length; i++) {
            System.out.println(party[i].getName() + "さん");
        }
    }

ポリモーフィズムの実装

前回学習したものを実装して、「動くもの」を作成しようというところです。

実装する手順を考える

実装するのには、それなりの時間がかかりますが、やってみることの意義はすごく大きいです。

今回は、キャラクターを作成する処理から実装していこうと考えています。

＜作成するものVersion1＞

勇者とモンスターが１回ずつ攻撃する
それぞれの攻撃に対して、各キャラクターのHPを減算する

メインメソッドの実装

ここでは、プログラムをイチから作成する方向で、話を進めていきます。

作成したプログラムは下のような実行結果が得られるように、実装します。

まずは、プログラムを実行するためのクラス(BattleSample.java)を作成します。エラーが出る部分はコメントアウトします。

つまるところは、どのような処理を呼び出したいかを実装します。ちなみにコメントのみでも良いです。

バージョン１の実装

＜BattleSample.java-バージョン1＞

public static void main(String[] args) {
    //勇者クラスの生成 
    RpgHero hero = new RpgHero("勇者");
    // モンスタークラスの生成
    Slime slime = new Slime("スライムA");

    // 勇者の攻撃
    hero.attack(slime);
    // モンスターの攻撃
    slime.attack(hero);
}

このように、勇者クラスと、スライムクラスをインスタンス化してそれぞれのメソッド(コマンド)を呼び出してやるだけのシンプルな実装です。

これで、勇者とスライムの攻防がコンソール(標準出力)へ出力されます。

問題は、RpgHeroクラスとSlimeクラスができていないという部分です(前回の実装を行った人は作成済みです)

RpgHeroクラスを作る

このクラスは、下の図にあるように、RpgCharacterクラスを継承した形で、実装します。

なので、先にRpgCharacterクラスを作成する必要がありますので、こちらのクラスの製造に着手します。

RpgCharacterクラスの製造

このクラスは、湯者だけではなく魔法使いや、盗賊、戦士などのプレーヤー側のキャラクターに共通する部分を実装する
想定で、設計しました。

なので、下のように共通するもの(属性・振る舞い)を実装します。

つまり、現状では、通常のクラスになります。

public class RpgCharacter {
    /** 名前 */
    protected String name;
    /** HP */
    protected int hp;
    /** MP */
    protected int mp;
    /** 性別 */
    protected int sex;
    /** 年齢 */
    protected int age;
    /** 誕生日 */
    protected String birthDay;
　　　・
　　　・
　　　・
}

上の状態では、属性(フィールド変数)を定義した状態です。

このほかに追加したいものもあるので、一度内容を確認します。

＜RpgCharacterクラスの設計1＞

属性、名前を持っている
属性、MPを持っている
属性、年齢を持っている
属性、性別を持っている
属性、誕生日を持っている

個の状態では、共通するプロパティ(属性)のみが定義されています。ほかにも考えれば出てきそうですが。。。

そして、共通するコマンド(メソッド)を定義します。

＜RpgCharacterクラスの設計2＞

属性、名前を持っている
属性、MPを持っている
属性、年齢を持っている
属性、性別を持っている
属性、誕生日を持っている
振る舞い、にげるを持っている

作成した設計を元に、そのクラスを実装します。

＜RpgCharacter＞バージョン１

public class RpgCharacter {
    /** 名前 */
    protected String name;
    /** HP */
    protected int hp;
    /** MP */
    protected int mp;
    /** 性別 */
    protected int sex;
    /** 年齢 */
    protected int age;
    /** 誕生日 */
    protected String birthDay;

    /** にげる */
    public void escape() {
        System.out.println(this.name + "は逃げ出した");
    }

フィールド変数には、本来「private」修飾氏をつけるのですが、今回は、子クラスを作成するための親クラスとして作成しているので、「protected」をつけて、継承関係のあるクラスであれば参照可能な形にしています。

そして、Getter, Setterは省略していますので、それぞれのメソッドが実装されているていで話を進めます。

この状態では、「たたかう」メソッドを強制的に継承する子クラスに実装させることができないので、下のような、抽象メソッドを追加します。

    /** たたかう */
    public abstract void attack(RpgCharacter character);

このようにすると、「抽象メソッドは抽象クラス、インターフェースでないともていない」ので、RpgCharacterクラスを通常のクラスから「抽象クラス」に変更します。

public abstract class RpgCharacter {
    /** 名前 */
    protected String name;
    /** HP */
    protected int hp;
    /** MP */
    protected int mp;
    /** 攻撃力 */
    protected int attackPower;
    /** 防御力 */
    protected int diffencePower;
    /** 性別 */
    protected int sex;
    /** 年齢 */
    protected int age;
    /** 誕生日 */
    protected String birthDay;

    /** 使用できるコマンドのメニューを開く */
    public abstract void showMenu();
    /** たたかう */
    public abstract void attack(RpgCharacter character);
    /** にげる */
    public void escape() {
        System.out.println(this.name + "は逃げ出した");
    }

そして、このクラスをインスタンス化するとき(newするとき)にデフォルトの値を設定するための

コンストラクタを定義(実装)します。引数に名前だけを与えた場合「コンストラクタ１」と、引数にすべてのプロパティ(属性)を与えた場合「コンストラクタ2」を定義しました。

    /** コンストラクタ1 */
    public RpgCharacter(String name) {
        this.name = name;
        this.hp = 10;
        this.mp = 0;
    }

    /** コンストラクタ2 */
    public RpgCharacter(String name, int sex, int age, String birthDay) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.birthDay = birthDay;
    }

RpgHeroを作る

ここでRpgHeroクラスの製造に戻ります。

ここまできたら、シンプルにRpgCharacterクラスを継承したRpgHeroクラスを作成するだけです。抽象メソッドのオーバーライドがありますが。。。

public class RpgHero extends RpgCharacter {
    /** コンストラクタ */
    public RpgHero(String name) {
        super(name);
    }
    /** コンストラクタ */
    public RpgHero(String name, int sex, int age, String birthDay) {
        super(name, sex, age, birthDay);
    }

    @Override
    public void attack(RpgCharacter monst) {
        System.out.println(this.name + "の攻撃");
        int damage = getAttackPower() - monst.getDiffencePower();
        System.out.println(monst.getName() + "へ" + damage + "のダメージ");
        monst.setHp(monst.getHp() - damage);
    }
}

継承したクラス(子クラス)から親クラスのコンストラクタ、メソッド、フィールドを呼び出したい場合は「super」をつけてやります。

同様に自分のクラス(子クラス)で保持するもの(コンストラクタ、メソッド、フィールド)を呼び出したい場合は「this」をつけてやります。

そして「@Override」というアノテーションがついているメソッドは、抽象メソッドを「オーバーライド」していることを明示的に示しています。

これと同様に、MonsterクラスとSlimeクラスも作成してしまいましょう。

Monsterクラスの製造

public class Monster extends RpgCharacter {

    /**
     * @param name
     */
    public Monster(String name) {
        super(name);
    }

    @Override
    public void attack(RpgCharacter player) {
        System.out.println(this.name + "の攻撃");
        int damage = getAttackPower() - player.getDiffencePower();
        System.out.println(player.getName() + "へ" + damage + "のダメージ");
        player.setHp(player.getHp() - damage);
    }
}

必要な属性(フィールド)はRpgCharacterクラスで持っているので、このクラスに特有な部分のみを実装します。

そして、コンストラクタに関しては、細かい情報(性別、年齢など)は必要な時にsetAge()などのメソッドで設定すれば良いので明示できに書きません。

その代わり、RpgCharacterクラスの、初期値としては「不明」「-1」などの値を設定するようにします。

int型は、参照型のようなnullという値が使えないので、-1で代用します。

つまりは、「年齢が『-1』だった場合『年齢不詳』という意味にする」というルールを追加してやれば、この問題は解決出るのでそのようにしたというところです。

スライムクラス

public class Slime extends Monster {

    /**
     * @param name
     */
    public Slime(String name) {
        super(name);
    }
}

このクラスに至っては、コンストラクタのみの実装で事足ります。

<<<前回

継承に関するページ一覧

環境構築関連ページ一覧

Eclipse セットアップ

設計関連ページ一覧

PHP関連ページ

JS関連ページ

数理モデル関連ページ

Java ポリモーフィズム(多様性) 〜クラス型の変換と組み合わせ〜

インロトダクション

前回は抽象クラスとインターフェースについて学習しました。

クラスの作り方

クラスの使い方

今回は、以下の３つを組み合わせて、どのような仕組みを作ることができるのか？について学習したいと思います。

はっきり言って、「どのような仕組みを作ることができるのか？」の問いに対する答えは、「ほぼ無限の組み合わせ方、仕組みを作ることができる」と思います。という答えが言えます。

前回までに、クラスとクラスを組み合わせるための土台になる部分を学習しました。以下のような内容です。

クラスの継承関係を作成する(親クラスと子クラス)
抽象クラスとインターフェース

これらの仕組み(継承関係を作る)を使用して、どのような組み合わせ方ができるのか学習していきます。
世間巷には「デザインパターン」という名前で広く知られています。が、デザインパターンなどのように広く知られるものは
大体Java APIの方で実装してあるので、使い方さえ分かっていれば改めて実装する必要はありません。

ポイントになるのは、「クラス関係を作成して、どのような仕組みを実現するか？」というところです。

ポリモーフィズムの実装

「テキストRPGを作る」ということをテーマ(話題)として話を進めていきます。

テキストRPG(戦闘シーンのみ)１

テキストRPG(戦闘シーンのみ)２

前回までに作成したもの

まとめると、キャラクターを表現するクラスを作成しました。RpgCharacterクラスを
継承して、必要なパラメータ、HPなどを定義しておき、勇者などのクラスは固有のパラメータのみを保持する形で実装しました。

親クラス、子クラス。。。として以下のようなクラスを作成したいと考えています。下のようなクラスたちです。

＜具体例A＞
テキストRPGゲームを作成しようとしているので下のようなクラスを作成したいと思っている。

勇者・クラス <作成済み>

魔法使い・クラス <作成済み>
3.盗賊・クラス

超勇者クラス

マタンゴ・クラス

ポインズンマタンゴ・クラス

ゴブリン・クラス

ウェアウルフ・クラス

デスバット・クラス

そして、プレーヤー側のクラスの親になるRpgCharacterクラスも作成しました。(詳細は前回を参照ください。)

ポリモーフィズムの設計

先ずは、設計から入ります。

組み合わせて、プログラムを実行するのに「どう組み合わせるか？」を考えないと始まらないのです。

自分の場合は、まずは紙と鉛筆を持ってプログラミングを始めます。つまり「設計から始める」ということです。

RPGのパーティを考える

例えば、前回作成したCharacterクラスとは別に「RpgCharacter」というクラスを作成します。
このクラスは、下の図のように勇者クラス(RpgHero)や魔法使いクラスを作成したとします。

そうすると、下のようなコードが書けます。(エラーが出ません)

＜メインメソッド＞

    public static void main(String[] args) {
        RpgCharacter[] party = new RpgCharacter[2];
        party[0] = new RpgHero("太郎");
        party[1] = new RpgWizard("二郎");

        System.out.println("こんにちは、良いパーティですね。");
        for (int i = 0; i < party.length; i++) {
            System.out.println(party[i].getName() + "さん");
        }
    }

このように、RpgCharacterクラスを継承しているクラスなので、RpgCharacterの配列をパーティとして扱うことができます。

そして、MonsterもRpgCharacterを継承することになるので、モンスターも仲間(パーティ)に追加できます。

RpgCharacterに処理をまとめる

現状では、勇者や魔法使い、モンスターなどの使用できるコマンドは「たたかう」というコマンドのみです。

ここに、すべてのキャラクターに共通する「にげる」コマンドを追加します。
それには、下のようにコードを追加します。

＜RpgCharacterクラスの修正＞

public abstract class RpgCharacter {
    /** 名前 */
    protected String name;
    /** HP */
    protected int hp;
    /** MP */
    protected int mp;

    /** にげる */
    public void escape() {
        System.out.println(this.name + "は逃げ出した");
    }
}

この状態で、RpgCharacterクラスを継承するクラスは「にげる」コマンドを使用することができます。

しかし「全く同じではない処理を追加する場合」はどうでしょうか？

例えば、「たたかう」コマンドの場合です。勇者クラスと魔法使いクラスでは、攻撃力が違うはずです。

この場合は、与えるダメージの大きさをそのクラスによって変えられるようにする必要があります。

その仕組みとして「抽象メソッド」を使用する方法があります。

具体的には下のようなコードです。

＜抽象メソッドを追加する＞

    /** たたかう */
    public abstract void attack(RpgCharacter character);

実装したクラスのコードは下のようになります。

＜抽象メソッドを追加したクラス＞

public abstract class RpgCharacter {
    /** 名前 */
    protected String name;
    /** HP */
    protected int hp;
    /** MP */
    protected int mp;

    /** たたかう */
    public abstract void attack(RpgCharacter character);
    /** にげる */
    public void escape() {
        System.out.println(this.name + "は逃げ出した");
    }

そして、これらのクラスを生成するとき(newするとき) には、コンストラクタが必要になりますが、これもRpgCharacterクラスと同じものになりますので、下のようにコンストラクタを追加します。

＜コンストラクタを追加したクラス＞

public abstract class RpgCharacter {
    /** 名前 */
    protected String name;
    /** HP */
    protected int hp;
    /** MP */
    protected int mp;

    /** コンストラクタ */
    public RpgCharacter(String name) {
        this.name = name;
        this.hp = 10;
        this.mp = 0;
    }

    /** たたかう */
    public abstract void attack(RpgCharacter character);
    /** にげる */
    public void escape() {
        System.out.println(this.name + "は逃げ出した");
    }

そうすると初めにも書きましたが、このようなコードでの処理が実行できます。

    public static void main(String[] args) {
        RpgCharacter[] party = new RpgCharacter[2];
        party[0] = new RpgHero("太郎");
        party[1] = new RpgWizard("二郎");

        System.out.println("こんにちは、良いパーティですね。");
        for (int i = 0; i < party.length; i++) {
            System.out.println(party[i].getName() + "さん");
        }
    }

実行結果は下のようになります。

こんにちは、良いパーティですね。
太郎さん
二郎さん

<<<前回次回 >>>

継承に関するページ一覧

環境構築関連ページ一覧

Eclipse セットアップ

設計関連ページ一覧

PHP関連ページ

JS関連ページ

数理モデル関連ページ

Java 未来に備えるための継承〜親クラスの作成とインターフェース〜

イントロダクション

前回は、継承に関して学習しました。

継承関係を作る目的は大まかに下の２つがあります。

クラスのグループ化
クラスの拡張

そして、クラスをグルーピング、拡張することで以下のようなメリットがあります。

親クラスのメソッドも使用できる
親クラスと似て非なるメソッドができる

この特性を使用して、実際に使用されているのがJava APIにあります。

＜画面コンポーネント系のクラス(java.net)＞

Socket通信を使用した、実装のサンプルです。これは画面(サーバー)C++で作られています。しかし、クライアント側、つまりアクセスする方はJavaでさくせいしました。実行はEclipseを使用しています。

＜インターフェースのケース＞

java.util.List
ArrayList, LinkedListなどのクラスをグルーピングしている
java.util.Set
HashSet, EnumSet名どのクラスをグルーピング
java.util.Map
HashMap, LinkedMapなどのクラスをグルーピング

未来に備える実装の例

＜具体例A＞
テキストRPGゲームを作成しようとしているので下のようなクラスを作成したいと思っている。

勇者・クラス
魔法使い・クラス
3.盗賊・クラス
超勇者クラス
マタンゴ・クラス
ポインズンマタンゴ・クラス
ゴブリン・クラス
ウェアウルフ・クラス
デスバット・クラス

これらのクラスを作るのに、全てのクラスに「HP」「名前」が必要になりますが、毎回同じコードを書くのは
スマートではありませんので「継承(extends)」を行うことでこれらを解消することができました。
※↑前回の学習内容

そして、インターフェースも同様に「同じカテゴリ」のクラスを作ることができます。

具体的には、自分が作成した「CommandIF」のことです。

今回の学習ポイント

今回は、通常のクラスにある、メソッドとは別の「抽象メソッド」に関して学びます。
通常のクラス + 「抽象メソッド」＝【抽象クラス】
「抽象メソッド」と定数のみ = 【インターフェース】

未来に備えるための継承

プログラミングを行う目的には、大まかに２種類あります。

目的のものを実装する(今作ろうとしているものを作る)
今後あると便利なものを前もって、実装しやすいように作っておく

※普段から今後使えるものを作ろうとするのは基本ですが。。。

先ほどの具体例Aを例にすると、下のようなクラス群を作成するのに共通するプロパティ(属性)を持ったクラスを継承して作成するのが、良さそうです。※この時点では、アイディアのレベルで良いのです。

勇者・クラス
魔法使い・クラス
3.盗賊・クラス
超勇者クラス
マタンゴ・クラス
ポインズンマタンゴ・クラス
ゴブリン・クラス
ウェアウルフ・クラス
デスバット・クラス

なので、これらのクラスに共通するプロパティ(属性)を考えます。
UMLを使用すると、直感的に考えることができます。

とりあえずは。このような形で、クラスの継承関係を作成すると「HP」と「名前」はCharacterクラスのみに作成すれば問題なくできそうです。

2つの不都合

ここで不都合が生じます。具体的には「詳細不明のメソッド」が出てくるというところです。

具体的問題は、

「勇者クラスと魔法使いクラスの攻撃力、ダメージは同じでしょうか？」

答えはNOだと思います。そんな魔法使いがいても良いのかもしれませんが。。。

しかし、勇者と魔法使いが同じ攻撃を行うのでは、職種が違う意味がありません。

なので、「戦う」というメソッドの処理内容をそれぞれのクラスで別の処理にしてやる必要があります。

ただし、メソッドの名前は同じである必要があります。

なので、HeroやWizardなどのプレーヤー側のクラスの親になるクラス「Character」を作成してやれば、コードとしては下のような形になります。共通するプロパティ(属性)は全てCharacterクラスで管理するようにします。

＜Heroクラス＞

package yoshida.tkm.lesson10;

/**
 *
 * @author 作成者の名前
 * 2021/05/19
 */
public class Hero extends Character {
    /** 定数 */
    final String TEISU = "定数";

    /** コンストラクタ */
    public Hero() {
        // newしたときに呼び出される
        System.out.println("*** Hero コンストラクタ ***");
    }

    /** 戦う */
    public void attack(Matango m) {
        System.out.println(getName() + "の攻撃");
        m.hp -= 5;
        System.out.println("5ポイントのダメージをあたえた！");
    }

    /** 逃げる */
    public void run() {
        // コメント
        System.out.println(getName() + "は逃げ出した！");
    }
}

CharacterクラスにHPと名前が定義してあるので、これらのフィールド変数は親クラスのものを使用します。

そして、Heroクラスには「戦う」と「逃げる」、のコマンドがあります。

＜Wizardクラス＞

public class Wizard extends Character {
    public void heal(Hero hero) {
        hero.setHp(hero.getHp() + 10);
        System.out.println(hero.getName() + "のHPを10ポイント回復した");
    }
 }

Wizardクラスは回復の魔法が使えます。そして、HP、名前は親クラスのものを使用します。

ここで問題なのは。。。

勇者クラスでなくとも「戦う」コマンドは使用できなくてはおかしい、というところです。
なので、上記のWizardクラスにattack()メソッドを追加します。

＜Wizardクラス②＞

public class Wizard extends Character {
    /** 戦う */
    public void attack(Matango m) {
        System.out.println(getName() + "の攻撃");
        m.hp -= 5;
        System.out.println("5ポイントのダメージをあたえた！");
    }

public void heal(Hero hero) {
        hero.setHp(hero.getHp() + 10);
        System.out.println(hero.getName() + "のHPを10ポイント回復した");
    }
 }

この状態では、勇者クラスの「戦う」と同じ処理になりますが、魔法使いは別な「戦う」方法があるはずです。

この部分の解決方法としては抽象メソッドを使用するという方法があります。

具体的には、Characterクラスに抽象メソッドをもたせてやるという方法です。

しかし、「抽象メソッドをもたせると、通常のクラスではなく抽象クラスとして定義する」必要があります。

通常のクラスと違い下のように定義します。

「書き方」
public abstract class クラス名{
// 通常クラスと変わらないが抽象メソッドを作る必要がある
public abstract 返却値メソッド名(引数);
}

＜Characterクラス＞

public abstract class Character {
    // java.lang.Character;
    private String name;
    private int hp;
    private int mp;

    /** 抽象メソッド */
    public abstract void attack(Matango m);

/**
     * @return the name
     */
    public String getName() {
        return name;
    }
    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }
    /**
     * @return the hp
     */
    public int getHp() {
        return hp;
    }
    /**
     * @param hp the hp to set
     */
    public void setHp(int hp) {
        this.hp = hp;
    }
    /**
     * @return the mp
     */
    public int getMp() {
        return mp;
    }
    /**
     * @param mp the mp to set
     */
    public void setMp(int mp) {
        this.mp = mp;
    }
}

これで、HeoクラスとWizardクラスは同じ名前で全く別の処理＊＊のメソッドを作成することができます。
さらに、メソッドのオーバーライド**を強制させることができるので、オーバーライドのし忘れを防止することができます。

public class Wizard extends Character {
    /** 戦う */
    @Override
    public void attack(Matango m) {
        System.out.println(getName() + "の攻撃");
        m.hp -= 2;
        System.out.println("2ポイントのダメージをあたえた！");
    }

<<<前回次回>>>

継承に関するページ一覧

環境構築関連ページ一覧

Eclipse セットアップ

設計関連ページ一覧

PHP関連ページ

JS関連ページ

数理モデル関連ページ

Java クラスの継承を理解する

イントロダクション

Javaなどのオブジェクト指向言語では、ほとんどの言語がクラスの継承を行うことができます。

継承を行うメリットに関して、その方法などを記載します。

前提１：データ型、演算子などを理解している

参考ページ１：変数の使い方
参考ページ２：クラス型変数の使い方

前提２：Javaの基本文法の理解をしている

今回は、クラスの継承関係を作成しその関係について記載しました。ここでいう基本文法というのは「条件分岐」と「ループ」「extendsの書き方」「implementsの書き方」です。

継承関係を作って実行してみました。 => 親、兄、弟のクラスを作成して実行した動画です。

クラスの継承

クラスの継承を行う目的は大まかに２つあります。

作成するクラスをグループ化したい
親クラスを拡張したい

上記のような目的が多いです。

==クラスの継承方法==
＜親クラスの例＞

package jp.zenryoku.practice.train2.cls.familly;

public class Parent extends Gosenzo {
    /** 家計 */
    public static int kakei = 1000;
    /** 苗字 */
    protected String lastName;
    /** 名前 */
    private String name;
    /** 年齢 */
    private int age;
    /** 趣味・特技 */
    public String favorit;

    /** コンストラクタ */
    public Parent() {
        lastName = "tanaka";
        name = "takao";
        age = 50;
        favorit = "ケツで箸を割る";
    }

    /** Gosenzoクラスの抽象メソッド */
    @Override
    public String kekkeiGenkai() {
        return "白目をむく";
    }

    /** 自己紹介 */
    public void say() {
        System.out.println(lastName + "と申します。");
        System.out.println("親です。名前は" + name + "です。年齢は" + age + "です。");
        System.out.println("特技は、「" + favorit + "」です。");
    }

    /** おかしな部分 */
    protected void funny() {
        System.out.println("喜びを真逆の言葉で表現する。");
    }

    /** 買い物 */
    public void buy(int money) {
        kakei -= money;
        System.out.println("残金：" + kakei);
    }
}

＜子クラスの例＞

package jp.zenryoku.practice.train2.cls.familly;

import java.util.List;

import jp.zenryoku.practice.train2.cls.game.util.CommandData;
import jp.zenryoku.practice.train2.cls.game.util.CommandIF;

public class ChildAni extends Parent implements CommandIF {
    /** 年齢 */
    private int age;
    /** 名前 */
    private String name;

    public ChildAni() {
        name = "taro";
        age = 12;
        createCommandList();
    }

    @Override
    public void say() {
        System.out.println(lastName + "です。");
        System.out.println("兄です。名前は" + name + "です。年齢は" + age + "です。");
        System.out.println("特技は、「" + favorit + "」です。");
    }

    @Override
    public List<CommandData> getCommandList() {
        addCommand(createCommandData("すかしっぺ", 15));
        addCommand(createCommandData("漢の一撃", 20));
        return super.getCommandList();
    }

    /**
     * コマンド実行する
     * @param index
     */
    public int exeCommand(String index) {
        CommandData data = super.getCommandList().get(Integer.parseInt(index));
        System.out.println(this.name + "の" + data.getCommandName());
        return data.getCommandValue();
    }
}

このようなクラスを題材に話を進めていきたいと思います。

クラスを継承することでできること

この記事では次のことを記載しています。

クラスをグループ化する
クラスを拡張する

クラスをグループ化する

クラスをグループ化する場合、上記の「親クラス」と「子クラス」の場合は、人間の親子を表しています。

なので、Parentクラスのグループ(親クラス)に対して子クラスは、兄とか弟ができるというところです。

しかし、このグループに車とか、犬などの子クラス(Parentクラスを継承したクラス)を作ると「役割」がまとまらなくなってしまいます。

なので、同じカテゴリのもの(クラス)**を作成していきましょう。

実際に、このグループに属するクラス「弟」クラスを作成すると下のようになります。

package jp.zenryoku.practice.train2.cls.familly;

public class ChildOtoto extends Parent {
    /** 年齢 */
    private int age;
    /** 名前 */
    private String name;

    public ChildOtoto() {
        name = "jiro";
        age = 10;
        favorit = "鼻を膨らます";
    }

    @Override
    public void say() {
        System.out.println(lastName + "といいます。");
        System.out.println("弟です。名前は" + name + "です。年齢は" + age + "です。");
        System.out.println("特技は、「" + favorit + "」です。");
    }

    @Override
    public void funny() {
        super.funny();
    }
}

このクラス以外にも、姉、妹、孫など作成することが可能です。※犬なども作れますが、混乱の元なのでやめましょう。

そして、このグループ化に関してはインタフェースでも行うことができます。下の図はクラス図で表現した場合のものです。
Parentというグループに兄と弟が存在している形になります。
そして、弟は「Interface1」というグループにも所属している形になります。

クラスを拡張する

そして、「クラスを継承する目的」その２に関してです。

Parentクラスは以下の属性(フィールド変数)を持っています。

    /** 家計 */
    public static int kakei = 1000;
    /** 苗字 */
    protected String lastName;
    /** 名前 */
    private String name;
    /** 年齢 */
    private int age;
    /** 趣味・特技 */
    public String favorit;

なので、このParentクラスは「家系」を管理しているクラスというとこができます。

そして、このクラスを継承したクラスChildAniは親クラスの「buy()」メソッドを使用することができます。

つまり、親クラスにあるkakeiを参照することができます。アクセス修飾子が「public」だからというのもありますが。。。

結局のところは、親クラスのメソッドを使用することができるというところです。

ちょっと待て〜い

「拡張」する話はどこに行ったのか？と疑問に思う方もいると思います。

まずは、上記の「親クラスのメソッドも使用できる」というところが大切なのです。

この親クラスのメソッドを使用できるというところで、子クラスでは同じメソッドを定義した場合どのようになるのでしょうか？

オーバーライド

このようになります。「オーバーライドって何？」と思った方、正常でございます。

この「オーバーライド」こそが「拡張」する部分になります。

元々あったメソッド「親クラスのbuy()」メソッドは子クラスからでも下のような書き方で呼び出すことが可能です。

super.buy();

逆に下のように書いた場合

this.buy();

これは、子クラスに書いたbuy()メソッドを呼び出すことになります。

具体的には下のようなコードになります。
＜親クラスを拡張した兄クラス＞

public class ChildAni extends Parent implements CommandIF {
　　・
　　・※省略
　　・
    /** 買い物 */
    public void buy(int money) {
        // 親クラスの処理から値引き処理( - nebiki)が追加されている
        int nebiki = 100;
        kakei -= (money - nebiki);
        System.out.println("残金：" + kakei);
    }
}

親クラスでの「buy(買い物)」メソッドでは引数の値を「kakei(家計)」から直接、減算していましたが、兄クラスでは「値引き」が入ります。

このように、親クラスのbuy()メソッドを使うよりも、兄クラスのbuy()メソッドを使用した方が安く済むということです。

これを現実に例えていうならば、親よりも、兄の方が買い物上手といったところでしょうか？

次回

継承に関するページ一覧

環境構築関連ページ一覧

Eclipse セットアップ

設計関連ページ一覧

PHP関連ページ

JS関連ページ

数理モデル関連ページ

Mavan インストール～ワンポイントレッスン的な～

Mavenのインストール

このMavenはビルドツールとして世界中で利用されているものです。自分も開発したり、サンプルを作成するときに使用することが多いです。同類のものとしてgradleというものがありますが、今回はビルドツールのMavenをインストールします。

Javaのインストール

こちらのサイト、java.netよりインストーラーをダウンロードできます。これでインストールすると
Mavenのインストール準備ができます。

確認方法

「windows」ボタンを押しながら「R]ボタンを押下します。

すると下のようなダイアログが表示されるので「cmd」と入力してエンターキーを押下してください、
するとコマンドプロンプトが開きます。

ここでjava --versionと入力してバージョン情報が表示されればOKです。(ラズパイでの表示ですが。。。)

Mavenのインストール

Apache MavanのサイトからZIP（apache-maven-X.X.X-bin.zip）ファイルをダウンロードします。※「X」は数字が入ります。
手順はです。
ZIPのファイルを展開して、展開後にできたフォルダが以下のようになります。
最後に、上のbinフォルダを環境変数へ登録します。

こんな感じです。

でわでわ。。。

JavaFX関連ページ

ステップアップ関連ページ一覧

JavaFX + ND4Jで機械学習準備

オブジェクト指向関連ページ

[オブジェクト指向の概念1〜OracleDocのチュートリアル１〜](https://zenryokuservice.com/wp/2019/10/301. /%e3%82%aa%e3%83%96%e3%82%b8%e3%82%a7%e3%82%af%e3%83%88%e6%8c%87%e5%90%91%e3%81%ae%e6%a6%82%e5%bf%b5-%e3%80%9coracledoc%e3%81%ae%e3%83%81%e3%83%a5%e3%83%bc%e3%83%88%e3%83%aa%e3%82%a2%e3%83%ab%ef%bc%91/)
オブジェクト指向の概念2〜クラスとは〜

イントロダクション

前回の学習ポイント

ポリモーフィズムの実装

実装する手順を考える

メインメソッドの実装

バージョン１の実装

RpgHeroクラスを作る

RpgCharacterクラスの製造

RpgHeroを作る

Monsterクラスの製造

スライムクラス

<<<前回

継承に関するページ一覧

環境構築関連ページ一覧

設計関連ページ一覧

PHP関連ページ

JS関連ページ

数理モデル関連ページ

インロトダクション

クラスの作り方

クラスの使い方

ポリモーフィズムの実装

テキストRPG(戦闘シーンのみ)１

テキストRPG(戦闘シーンのみ)２

前回までに作成したもの

ポリモーフィズムの設計

RPGのパーティを考える

RpgCharacterに処理をまとめる

継承に関するページ一覧

環境構築関連ページ一覧

設計関連ページ一覧

PHP関連ページ

JS関連ページ

数理モデル関連ページ

イントロダクション

未来に備える実装の例

今回の学習ポイント

未来に備えるための継承

2つの不都合

「勇者クラスと魔法使いクラスの攻撃力、ダメージは同じでしょうか？」

ここで問題なのは。。。

継承に関するページ一覧

環境構築関連ページ一覧

設計関連ページ一覧

PHP関連ページ

JS関連ページ

数理モデル関連ページ

イントロダクション

前提１：データ型、演算子などを理解している

前提２：Javaの基本文法の理解をしている

クラスの継承

クラスを継承することでできること

クラスをグループ化する

クラスを拡張する

ちょっと待て〜い

オーバーライド

次回

継承に関するページ一覧

環境構築関連ページ一覧

設計関連ページ一覧

PHP関連ページ

JS関連ページ

数理モデル関連ページ

Mavenのインストール

Javaのインストール

確認方法

Mavenのインストール

関連ページ一覧

[Eclipse セットアップ](http://zenryokuservice.com/wp/2020/09/01/%e9%96%8b%e7%99%ba%e7%92%b0%e5%a2%83%e6%a7%8b%e7%af%89%ef%bd%9ewindows%e7%89%88eclipse%e3%81%ae%e8%a8%ad%e5%ae%9a%ef%bd%9e/)

Git関連

JavaFX関連ページ

ステップアップ関連ページ一覧

JavaFX + ND4Jで機械学習準備

オブジェクト指向関連ページ

Java Discord