java – ページ 8 – サイゼントの技術ブログ

2020年1月20日

java：Enumによりコード値に意味を持たせ可読性を向上させる

javaのEnum（列挙型）を使用するメリットとしては、一般的に「使用可能な定数を明確化できる」「定数を複数のクラスで使い回せる」といったメリットが挙げられます。
実際に使用していて、コード値に意味を持たせられるというメリットもありそうだったので、記事に残します。

コーディングをしていると、コード値を用いた方が便利な場合が間々あります。
例えば、RPGの道具に対して、「weakSwordにはID0、normalSwordにはID1、strongSwordにはID2を割り振る」といった具合です。
コード値を用いれば、コード値を用いて配列操作することが可能になりますし、DBでマスタ管理する際にも便利です。

しかし、コード値には「人間が理解し辛い」というデメリットがあります。
コンピュータで処理する分には効率が良いのですが、人間から見たら「IDが0ならweakSword、IDが1なら…」といった具合で、コード値が何を意味しているのかを予め知る必要が出てきてしまいます。
コード値とその意味の対応付けを人間が行うことで、読み間違い・書き間違いといったバグに繋がるミスも起こりやすくなります。

そこで、Enumでコード値とその意味の対応付けを行えば、「ソースコード上は意味のある単語、コンピュータ上はコード値」という形にできます。
そうすることで、コード値とその意味の対応付けを人間が行う必要が無くなり、読み間違い・書き間違いを未然に防ぐことができます。

以下、サンプルコードです。

【サンプルコード】

・ItemEnum.java

public enum ItemEnum {
    weakSword(0),
    normalSword(1),
    strongSword(2);

    private int id;
    public final static int ITEM_TOTAL_NUMBER = 3; // 道具の総数

    private ItemEnum (int id) {
      this.id = id;
    }

    public int getId() {
        return id;
    }

    public static ItemEnum valueOf(int id) {
        ItemEnum[] array = values();
        for(ItemEnum num : array) {
            if (id == num.getId()){
                return num;
            }
        }
        return null;
    }

    public static int getItemPrice(ItemEnum itemEnum) {

        int[] result = new int[ITEM_TOTAL_NUMBER];

        result[weakSword.getId()] = 100;
        result[normalSword.getId()] = 200;
        result[strongSword.getId()] = 300;

        return result[itemEnum.getId()];

    }

}

public enum ItemEnum {

weakSword(0),

normalSword(1),

strongSword(2);

private int id;

public final static int ITEM_TOTAL_NUMBER = 3; // 道具の総数

private ItemEnum (int id) {

this.id = id;

}

public int getId() {

return id;

}

public static ItemEnum valueOf(int id) {

ItemEnum[] array = values();

for(ItemEnum num : array) {

if (id == num.getId()){

return num;

}

return null;

}

public static int getItemPrice(ItemEnum itemEnum) {

int[] result = new int[ITEM_TOTAL_NUMBER];

result[weakSword.getId()] = 100;

result[normalSword.getId()] = 200;

result[strongSword.getId()] = 300;

return result[itemEnum.getId()];

}

・ItemManagementMain.java

public class ItemManagementMain {

    public static void main(String[] args) {

        // 道具袋を定義し、道具を入れていく
        // javaの言語仕様でint型は初期値0のため初期化は不要
        int[] itemBag = new int[ItemEnum.ITEM_TOTAL_NUMBER];
        itemBag[ItemEnum.weakSword.getId()]++;
        itemBag[ItemEnum.normalSword.getId()]++;
        itemBag[ItemEnum.strongSword.getId()]++;
        itemBag[ItemEnum.weakSword.getId()]++;
        itemBag[ItemEnum.strongSword.getId()]++;

        // 道具袋の中の数を確認
        System.out.println("・道具袋の中身の確認");
        for(int i = 0; i &lt; ItemEnum.ITEM_TOTAL_NUMBER; i++) {
            System.out.println
                ("　" + ItemEnum.valueOf(i) + " は " + itemBag[i] + " 個 ");
        }

        // 道具の値段を確認
        System.out.println();
        System.out.println("・道具の値段の確認");
        for(int i = 0; i &lt; ItemEnum.ITEM_TOTAL_NUMBER; i++) {
            System.out.println
                ("　" + ItemEnum.valueOf(i) + " の値段は " +
                    ItemEnum.getItemPrice(ItemEnum.valueOf(i)));
        }

    }

}

public class ItemManagementMain {

public static void main(String[] args) {

// 道具袋を定義し、道具を入れていく

// javaの言語仕様でint型は初期値0のため初期化は不要

int[] itemBag = new int[ItemEnum.ITEM_TOTAL_NUMBER];

itemBag[ItemEnum.weakSword.getId()]++;

itemBag[ItemEnum.normalSword.getId()]++;

itemBag[ItemEnum.strongSword.getId()]++;

itemBag[ItemEnum.weakSword.getId()]++;

itemBag[ItemEnum.strongSword.getId()]++;

// 道具袋の中の数を確認

System.out.println("・道具袋の中身の確認");

for(int i = 0; i < ItemEnum.ITEM_TOTAL_NUMBER; i++) {

System.out.println

("　" + ItemEnum.valueOf(i) + " は " + itemBag[i] + " 個 ");

}

// 道具の値段を確認

System.out.println();

System.out.println("・道具の値段の確認");

for(int i = 0; i < ItemEnum.ITEM_TOTAL_NUMBER; i++) {

System.out.println

("　" + ItemEnum.valueOf(i) + " の値段は " +

ItemEnum.getItemPrice(ItemEnum.valueOf(i)));

}

【実行結果】

・道具袋の中身の確認
　weakSword は 2 個 
　normalSword は 1 個 
　strongSword は 2 個 

・道具の値段の確認
　weakSword の値段は 100
　normalSword の値段は 200
　strongSword の値段は 300

・道具袋の中身の確認

　weakSword は 2 個

　normalSword は 1 個

　strongSword は 2 個

・道具の値段の確認

　weakSword の値段は 100

　normalSword の値段は 200

　strongSword の値段は 300

いかがでしたでしょうか。

Enumを始めて知った時は何のために使うのか分からなかったのですが、慣れてくると便利だと思うようになりました。
今回は、実際に使って便利だった点を一つ挙げて記事にしてみました。

これからも、役に立つと思ったことがあればどんどん記事にしていきたいと思います！

2020年1月11日

javaでのAbstract Factoryパターン

Abstract FactoryパターンはFactory Methodパターンを発展させたもので、生成するオブジェクトの組み合わせを間違えないために、１つのFactoryクラスに複数のオブジェクトの生成処理を実装するようにしたものです。

今回は、RPGのキャラクター作成を模したサンプルコードを作成してみました。
キャラクターの職業毎に、職業を示すオブジェクトとスキルを示すオブジェクトを生成します。
両オブジェクトの組み合わせ方を間違えないように、Abstract Factoryパターンにより組み合わせ方を限定しています。

【サンプルコード】

・AbstractJob.java

public abstract class AbstractJob {

    protected String playerName;
    protected String jobName;

    public abstract void setPlayerName(String playerName);
    public abstract String getPlayerName();
    public abstract void setJobName(String jobName);
    public abstract String getJobName();

}

public abstract class AbstractJob {

protected String playerName;

protected String jobName;

public abstract void setPlayerName(String playerName);

public abstract String getPlayerName();

public abstract void setJobName(String jobName);

public abstract String getJobName();

}

・WarriorJob.java

public class WarriorJob extends AbstractJob {

    public void setPlayerName(String playerName) {
        this.playerName = playerName;
    }

    public String getPlayerName() {
        return this.playerName;
    }

    public void setJobName(String jobName) {
        this.jobName = jobName;
    }

    public String getJobName() {
        return this.jobName;
    }

}

public class WarriorJob extends AbstractJob {

public void setPlayerName(String playerName) {

this.playerName = playerName;

}

public String getPlayerName() {

return this.playerName;

}

public void setJobName(String jobName) {

this.jobName = jobName;

}

public String getJobName() {

return this.jobName;

}

・MagicianJob.java

public class MagicianJob extends AbstractJob {

    public void setPlayerName(String playerName) {
        this.playerName = playerName;
    }

    public String getPlayerName() {
        return this.playerName;
    }

    public void setJobName(String jobName) {
        this.jobName = jobName;
    }

    public String getJobName() {
        return this.jobName;
    }

}

public class MagicianJob extends AbstractJob {

public void setPlayerName(String playerName) {

this.playerName = playerName;

}

public String getPlayerName() {

return this.playerName;

}

public void setJobName(String jobName) {

this.jobName = jobName;

}

public String getJobName() {

return this.jobName;

}

・AbstractSkill.java

import java.util.ArrayList;
import java.util.List;

public abstract class AbstractSkill {

    protected String playerName;
    protected List＜String＞ skillList = new ArrayList＜String＞();

    public abstract void setPlayerName(String playerName);
    public abstract String getPlayerName();
    public abstract void setSkill(String skill);
    public abstract List&lt;String> getSkill();

}

import java.util.ArrayList;

import java.util.List;

public abstract class AbstractSkill {

protected String playerName;

protected List＜String＞ skillList = new ArrayList＜String＞();

public abstract void setPlayerName(String playerName);

public abstract String getPlayerName();

public abstract void setSkill(String skill);

public abstract List<String> getSkill();

}

・WarriorSkill.java

import java.util.List;

public class WarriorSkill extends AbstractSkill {

    public void setPlayerName(String playerName) {
        this.playerName = playerName;
    }

    public String getPlayerName() {
        return this.playerName;
    }

    public void setSkill(String skill) {
        this.skillList.add(skill);
    }

    public List＜String＞ getSkill() {
        return this.skillList;
    }

}

import java.util.List;

public class WarriorSkill extends AbstractSkill {

public void setPlayerName(String playerName) {

this.playerName = playerName;

}

public String getPlayerName() {

return this.playerName;

}

public void setSkill(String skill) {

this.skillList.add(skill);

}

public List＜String＞ getSkill() {

return this.skillList;

}

・MagicianSkill.java

import java.util.List;

public class MagicianSkill extends AbstractSkill {

    public void setPlayerName(String playerName) {
        this.playerName = playerName;
    }

    public String getPlayerName() {
        return this.playerName;
    }

    public void setSkill(String skill) {
        this.skillList.add(skill);
    }

    public List＜String＞ getSkill() {
        return this.skillList;
    }

}

import java.util.List;

public class MagicianSkill extends AbstractSkill {

public void setPlayerName(String playerName) {

this.playerName = playerName;

}

public String getPlayerName() {

return this.playerName;

}

public void setSkill(String skill) {

this.skillList.add(skill);

}

public List＜String＞ getSkill() {

return this.skillList;

}

・AbstractJobFactory.java

/*
 * 生成するオブジェクトの組み合わせを間違えないように、
 * 複数のオブジェクトの生成を１クラスにまとめる
 */
public abstract class AbstractFactory {

    public final AbstractJob createJob(String playerName) {
        AbstractJob abstractJob = createJobLogic(playerName);
        return abstractJob;
    }

    protected abstract AbstractJob createJobLogic(String playerName);

    public final AbstractSkill createSkill(String playerName) {
        AbstractSkill abstractSkill = createSkillLogic(playerName);
        return abstractSkill;
    }

    protected abstract AbstractSkill createSkillLogic(String playerName);

}

* 生成するオブジェクトの組み合わせを間違えないように、

* 複数のオブジェクトの生成を１クラスにまとめる

public abstract class AbstractFactory {

public final AbstractJob createJob(String playerName) {

AbstractJob abstractJob = createJobLogic(playerName);

return abstractJob;

}

protected abstract AbstractJob createJobLogic(String playerName);

public final AbstractSkill createSkill(String playerName) {

AbstractSkill abstractSkill = createSkillLogic(playerName);

return abstractSkill;

}

protected abstract AbstractSkill createSkillLogic(String playerName);

}

・WarriorFactory.java

/*
 * WarriorJobとWarriorSkillの組み合わせ
 */
public class WarriorFactory extends AbstractFactory {

    protected AbstractJob createJobLogic(String playerName) {
        WarriorJob warriorJob = new WarriorJob();
        warriorJob.setPlayerName(playerName);
        warriorJob.setJobName("Warrior");
        return warriorJob;
    }

    protected AbstractSkill createSkillLogic(String playerName) {
        WarriorSkill warriorSkill = new WarriorSkill();
        warriorSkill.setPlayerName(playerName);
        warriorSkill.setSkill("QuickSlash");
        return warriorSkill;
    }

}

* WarriorJobとWarriorSkillの組み合わせ

public class WarriorFactory extends AbstractFactory {

protected AbstractJob createJobLogic(String playerName) {

WarriorJob warriorJob = new WarriorJob();

warriorJob.setPlayerName(playerName);

warriorJob.setJobName("Warrior");

return warriorJob;

}

protected AbstractSkill createSkillLogic(String playerName) {

WarriorSkill warriorSkill = new WarriorSkill();

warriorSkill.setPlayerName(playerName);

warriorSkill.setSkill("QuickSlash");

return warriorSkill;

}

・MagicianFactory.java

/*
 * MagicianJobとMagicianSkillの組み合わせ
 */
public class MagicianFactory extends AbstractFactory {

    protected AbstractJob createJobLogic(String playerName) {
        MagicianJob magicianJob = new MagicianJob();
        magicianJob.setPlayerName(playerName);
        magicianJob.setJobName("Magician");
        return magicianJob;
    }

    protected AbstractSkill createSkillLogic(String playerName) {
        MagicianSkill magicianSkill = new MagicianSkill();
        magicianSkill.setPlayerName(playerName);
        magicianSkill.setSkill("FireL1");
        return magicianSkill;
    }

}

* MagicianJobとMagicianSkillの組み合わせ

public class MagicianFactory extends AbstractFactory {

protected AbstractJob createJobLogic(String playerName) {

MagicianJob magicianJob = new MagicianJob();

magicianJob.setPlayerName(playerName);

magicianJob.setJobName("Magician");

return magicianJob;

}

protected AbstractSkill createSkillLogic(String playerName) {

MagicianSkill magicianSkill = new MagicianSkill();

magicianSkill.setPlayerName(playerName);

magicianSkill.setSkill("FireL1");

return magicianSkill;

}

・CreateJobMain.java

import java.util.Iterator;

public class CreateJobMain {
    public static void main(String[] args){

        // Factoryメソッドの定義
        WarriorFactory warriorFactory = new WarriorFactory();
        MagicianFactory magicianFactory = new MagicianFactory();

        // Factoryメソッドによりオブジェクトを生成
        AbstractJob player1Job = warriorFactory.createJob("Player1");
        AbstractSkill player1Skill = warriorFactory.createSkill("Player1");
        AbstractJob player2Job = magicianFactory.createJob("Player2");
        AbstractSkill player2Skill = magicianFactory.createSkill("Player1");

        // 生成されたオブジェクトの内容を確認
        displayJob(player1Job,player1Skill);
        displayJob(player2Job,player2Skill);

    }

    private static void displayJob(AbstractJob job,AbstractSkill skill) {
        System.out.println("［プレイヤー："+job.getPlayerName()+"］");
        System.out.println("・職業");
        System.out.println("　"+job.getJobName());
        System.out.println("・スキル");
        Iterator&lt;String> iterator = skill.getSkill().iterator();
        if (!iterator.hasNext()) {
            System.out.println("　None");
        } else {
            while (iterator.hasNext()) {
                String str = iterator.next();
                System.out.println("　"+str);
            }
        }
    }

}

import java.util.Iterator;

public class CreateJobMain {

public static void main(String[] args){

// Factoryメソッドの定義

WarriorFactory warriorFactory = new WarriorFactory();

MagicianFactory magicianFactory = new MagicianFactory();

// Factoryメソッドによりオブジェクトを生成

AbstractJob player1Job = warriorFactory.createJob("Player1");

AbstractSkill player1Skill = warriorFactory.createSkill("Player1");

AbstractJob player2Job = magicianFactory.createJob("Player2");

AbstractSkill player2Skill = magicianFactory.createSkill("Player1");

// 生成されたオブジェクトの内容を確認

displayJob(player1Job,player1Skill);

displayJob(player2Job,player2Skill);

}

private static void displayJob(AbstractJob job,AbstractSkill skill) {

System.out.println("［プレイヤー："+job.getPlayerName()+"］");

System.out.println("・職業");

System.out.println("　"+job.getJobName());

System.out.println("・スキル");

Iterator<String> iterator = skill.getSkill().iterator();

if (!iterator.hasNext()) {

System.out.println("　None");

} else {

while (iterator.hasNext()) {

String str = iterator.next();

System.out.println("　"+str);

}

【実行結果】

［プレイヤー：Player1］
・職業
　Warrior
・スキル
　QuickSlash
［プレイヤー：Player2］
・職業
　Magician
・スキル
　FireL1

［プレイヤー：Player1］

・職業

　Warrior

・スキル

　QuickSlash

［プレイヤー：Player2］

・職業

　Magician

・スキル

　FireL1

いかがでしたでしょうか？

デザインパターンの勉強をしていて、個人的に一番わかりにくいと思ったのは今回紹介したAbstract Factoryパターンです。
このデザインパターンは「複数のオブジェクトを組み合わせる場合に、その組み合わせ方を間違えないようにする」という意図を持ったデザインパターンなのですが、「Abstract Factory（抽象的な工場）」という名前からこの意図を読み取るのは難しいと思いますし、クラス図やサンプルコードを眺めても複雑で意図を理解するのは難しいと思います。
今回の記事で、その意図が伝われば幸いです。

まだ紹介していないデザインパターンもありますので、これからも少しずつ紹介していきたいと思います！

2019年12月29日

javaでのFactory Methodパターン

Factory MethodパターンはTemplate Methodパターンをオブジェクト生成の場面に適用したもので、オブジェクト生成の処理を共通化することができます。

今回は、RPGのキャラクター作成を模したサンプルコードを作成してみました。
キャラクターの職業毎にクラスを分けており、クラス毎に微妙にオブジェクト生成時の処理が異なっていますが、各々のクラスのオブジェクト生成処理を共通化することができています。

【サンプルコード】

・AbstractJob.java

import java.util.ArrayList;
import java.util.List;

public abstract class AbstractJob {

    protected String playerName;
    protected List＜String＞ skillList = new ArrayList&lt;String>();

    public abstract void setPlayerName(String playerName);
    public abstract String getPlayerName();
    public abstract void setSkill(String skill);
    public abstract List＜String＞ getSkill();

}

import java.util.ArrayList;

import java.util.List;

public abstract class AbstractJob {

protected String playerName;

protected List＜String＞ skillList = new ArrayList<String>();

public abstract void setPlayerName(String playerName);

public abstract String getPlayerName();

public abstract void setSkill(String skill);

public abstract List＜String＞ getSkill();

}

・Warrior.java

import java.util.List;

public class Warrior extends AbstractJob {

    public void setPlayerName(String playerName) {
        this.playerName = playerName;
    }

    public String getPlayerName() {
        return this.playerName;
    }

    public void setSkill(String skill) {
        this.skillList.add(skill);
    }

    public List＜String＞ getSkill() {
        return this.skillList;
    }

}

import java.util.List;

public class Warrior extends AbstractJob {

public void setPlayerName(String playerName) {

this.playerName = playerName;

}

public String getPlayerName() {

return this.playerName;

}

public void setSkill(String skill) {

this.skillList.add(skill);

}

public List＜String＞ getSkill() {

return this.skillList;

}

・NormalPerson.java

import java.util.List;

public class NormalPerson extends AbstractJob {

    public void setPlayerName(String playerName) {
        this.playerName = playerName;
    }

    public String getPlayerName() {
        return this.playerName;
    }

    public void setSkill(String skill) {
        this.skillList.add(skill);
    }

    public List＜String＞ getSkill() {
        return this.skillList;
    }

}

import java.util.List;

public class NormalPerson extends AbstractJob {

public void setPlayerName(String playerName) {

this.playerName = playerName;

}

public String getPlayerName() {

return this.playerName;

}

public void setSkill(String skill) {

this.skillList.add(skill);

}

public List＜String＞ getSkill() {

return this.skillList;

}

・AbstractJobFactory.java

public abstract class AbstractJobFactory {

    public final AbstractJob create(String playerName) {
        AbstractJob abstractJob = createJob(playerName);
        return abstractJob;
    }

    protected abstract AbstractJob createJob(String playerName);

}

public abstract class AbstractJobFactory {

public final AbstractJob create(String playerName) {

AbstractJob abstractJob = createJob(playerName);

return abstractJob;

}

protected abstract AbstractJob createJob(String playerName);

}

・WarriorFactory.java

public class WarriorFactory extends AbstractJobFactory {

    protected AbstractJob createJob(String playerName) {
        Warrior warrior = new Warrior();
        warrior.setPlayerName(playerName);
        warrior.setSkill("QuickSlash");
        return warrior;
    }

}

public class WarriorFactory extends AbstractJobFactory {

protected AbstractJob createJob(String playerName) {

Warrior warrior = new Warrior();

warrior.setPlayerName(playerName);

warrior.setSkill("QuickSlash");

return warrior;

}

・NormalPersonFactory.java

public class NormalPersonFactory extends AbstractJobFactory {

    protected AbstractJob createJob(String playerName) {
        NormalPerson normalPerson = new NormalPerson();
        normalPerson.setPlayerName(playerName);
        return normalPerson;
    }

}

public class NormalPersonFactory extends AbstractJobFactory {

protected AbstractJob createJob(String playerName) {

NormalPerson normalPerson = new NormalPerson();

normalPerson.setPlayerName(playerName);

return normalPerson;

}

・CreateJobMain.java

import java.util.Iterator;

public class CreateJobMain {
    public static void main(String[] args){

        // Factoryメソッドの定義
        WarriorFactory warriorFactory = new WarriorFactory();
        NormalPersonFactory normalPersonFactory = new NormalPersonFactory();

        // Factoryメソッドによりオブジェクトを生成
        AbstractJob warrior = warriorFactory.create("Player1");
        AbstractJob normalPerson = normalPersonFactory.create("Player2");

        // 生成されたオブジェクトの内容を確認
        displayJob(warrior);
        displayJob(normalPerson);

    }

    private static void displayJob(AbstractJob player) {
        System.out.println("［プレイヤー："+player.getPlayerName()+"］");
        System.out.println("・職業");
        System.out.println("　"+player.getClass().getName());
        System.out.println("・スキル");
        Iterator&lt;String> iterator = player.getSkill().iterator();
        if (!iterator.hasNext()) {
            System.out.println("　None");
        } else {
            while (iterator.hasNext()) {
                String str = iterator.next();
                System.out.println("　"+str);
            }
        }
    }

}

import java.util.Iterator;

public class CreateJobMain {

public static void main(String[] args){

// Factoryメソッドの定義

WarriorFactory warriorFactory = new WarriorFactory();

NormalPersonFactory normalPersonFactory = new NormalPersonFactory();

// Factoryメソッドによりオブジェクトを生成

AbstractJob warrior = warriorFactory.create("Player1");

AbstractJob normalPerson = normalPersonFactory.create("Player2");

// 生成されたオブジェクトの内容を確認

displayJob(warrior);

displayJob(normalPerson);

}

private static void displayJob(AbstractJob player) {

System.out.println("［プレイヤー："+player.getPlayerName()+"］");

System.out.println("・職業");

System.out.println("　"+player.getClass().getName());

System.out.println("・スキル");

Iterator<String> iterator = player.getSkill().iterator();

if (!iterator.hasNext()) {

System.out.println("　None");

} else {

while (iterator.hasNext()) {

String str = iterator.next();

System.out.println("　"+str);

}

【実行結果】

［プレイヤー：Player1］
・職業
　Warrior
・スキル
　QuickSlash
［プレイヤー：Player2］
・職業
　NormalPerson
・スキル
　None

［プレイヤー：Player1］

・職業

　Warrior

・スキル

　QuickSlash

［プレイヤー：Player2］

・職業

　NormalPerson

・スキル

　None

いかがでしたでしょうか。

前に紹介したTemplate MethodパターンとFactory Methodパターンは似ているので、合わせて覚えておきたいパターンだと思います。
実務でも、「～Factory」という言葉を良く聞きます。「～Factoryはオブジェクトを生成するクラスだ」という知識があるだけでも、開発者同士のコミュニケーションがスムーズになると思います。

では、よいお年を！

2019年12月21日

javaでのTemplate Methodパターン

Template Methodパターンは、処理（メソッド）の中で共通している箇所を抽象クラスとして抜き出すことで、重複した記述を排除し、更に処理の流れも規定する手法のことを指します。
手続き型言語でも共通する箇所を子メソッドとして抜き出すことをしますが、子メソッドとして抜き出してしまうとその子メソッドの使い方までは規定できず、子メソッドを誤った使い方をされてしまう可能性が出てきてしまいます。

サンプルコードとして、RPGのダメージ計算を模したプログラムを作成してみました。
「ベースのダメージ量に対してランダム化を行い最終的なダメージ量とする」という処理の流れを規定できていることがポイントです。

【サンプルコード】

・AbstractDamageCalc.java

import java.util.Random;

public abstract class AbstractDamageCalc {

    public abstract int getDamageBase();

    public final int damageCalc() {
        // ベースのダメージ量に7/8、8/8、9/8の何れかの値をかけてランダム化する
        // 単に共通処理をまとめるだけでなく、共通処理の使い方も指定できる
        // （ランダム化忘れ、ランダム化を２重でする、等を未然に防げる）
        return getDamageBase() * (new Random().nextInt(3) + 7) / 8;
    }
}

import java.util.Random;

public abstract class AbstractDamageCalc {

public abstract int getDamageBase();

public final int damageCalc() {

// ベースのダメージ量に7/8、8/8、9/8の何れかの値をかけてランダム化する

// 単に共通処理をまとめるだけでなく、共通処理の使い方も指定できる

// （ランダム化忘れ、ランダム化を２重でする、等を未然に防げる）

return getDamageBase() * (new Random().nextInt(3) + 7) / 8;

}

・PhysicsDamageCalc.java

public final class PhysicsDamageCalc extends AbstractDamageCalc {

    private int baseDamage = 0;

    public PhysicsDamageCalc(int physicsPower) {
        baseDamage = physicsPower / 2; //攻撃力の半分がダメージ
    }

    public int getDamageBase() {
        return baseDamage;
    }

}

public final class PhysicsDamageCalc extends AbstractDamageCalc {

private int baseDamage = 0;

public PhysicsDamageCalc(int physicsPower) {

baseDamage = physicsPower / 2; //攻撃力の半分がダメージ

}

public int getDamageBase() {

return baseDamage;

}

・MagicDamageCalc.java

public final class MagicDamageCalc extends AbstractDamageCalc {

    private int baseDamage = 0;

    public MagicDamageCalc(int magicID) {
        if (magicID == 0) { //魔法「FireL1」
            baseDamage = 15;
        } else if (magicID == 1) { //魔法「FireL2」
            baseDamage = 60;
        } else if (magicID == 2) { //魔法「FireL3」
            baseDamage = 120;
        } else { //例外処理
            System.out.println("指定された魔法ＩＤは未実装です");
            System.exit(1);
        }
    }

    public int getDamageBase() {
        return baseDamage;
    }

}

public final class MagicDamageCalc extends AbstractDamageCalc {

private int baseDamage = 0;

public MagicDamageCalc(int magicID) {

if (magicID == 0) { //魔法「FireL1」

baseDamage = 15;

} else if (magicID == 1) { //魔法「FireL2」

baseDamage = 60;

} else if (magicID == 2) { //魔法「FireL3」

baseDamage = 120;

} else { //例外処理

System.out.println("指定された魔法ＩＤは未実装です");

System.exit(1);

}

public int getDamageBase() {

return baseDamage;

}

・DamageCalcMain.java

public class DamageCalcMain {
    public static void main(String[] args){

        int physicsPower = -1;
        int magicID = -1;
        int damage = 0;

        // 引数から物理攻撃力、魔法ＩＤを取得
        if (args.length == 2) {
            physicsPower = Integer.parseInt(args[0]);
            magicID = Integer.parseInt(args[1]);
        }

        // ダメージ計算
        if (physicsPower >= 0 || magicID == -1) { //物理攻撃
            damage = new PhysicsDamageCalc(physicsPower)
                              .damageCalc();
        } else if (physicsPower == -1 || magicID >= 0) { //魔法攻撃
            damage = new MagicDamageCalc(magicID)
                              .damageCalc();
        } else { //例外処理
            System.out.println
                ("第１引数：物理攻撃力、魔法攻撃の場合は-1にしてください");
            System.out.println
                ("第２引数：魔法ＩＤ、物理攻撃の場合は-1にしてください");
            System.exit(1);
        }

        System.out.println("ダメージは"+damage);
        System.exit(0);

    }
}

public class DamageCalcMain {

public static void main(String[] args){

int physicsPower = -1;

int magicID = -1;

int damage = 0;

// 引数から物理攻撃力、魔法ＩＤを取得

if (args.length == 2) {

physicsPower = Integer.parseInt(args[0]);

magicID = Integer.parseInt(args[1]);

}

// ダメージ計算

if (physicsPower >= 0 || magicID == -1) { //物理攻撃

damage = new PhysicsDamageCalc(physicsPower)

.damageCalc();

} else if (physicsPower == -1 || magicID >= 0) { //魔法攻撃

damage = new MagicDamageCalc(magicID)

.damageCalc();

} else { //例外処理

System.out.println

("第１引数：物理攻撃力、魔法攻撃の場合は-1にしてください");

System.out.println

("第２引数：魔法ＩＤ、物理攻撃の場合は-1にしてください");

System.exit(1);

}

System.out.println("ダメージは"+damage);

System.exit(0);

}

【実行結果】

ダメージは52

ダメージは52

　※第１引数に-1、第２引数に1を指定した場合

いかがでしたでしょうか。

手続き型言語に対するオブジェクト指向型言語の利点として、特定のルールに従ったコーディングを他の開発者にさせやすくなるというものがあり、バグの混入を未然に防ぐことができます。
共通処理の使い方を指定できるTemplate Methodパターンは、その利点が良く分かるパターンの一つだと思います。
抽象クラスの使い方として、このような使い方は覚えておいて損はないと思います。

では、また次回！

2019年12月14日

javaでのFacadeパターン

Facadeクラスとは、使い方が複雑になっているクラス群をまとめ、使いやすい形のインターフェースとして外部に提供するクラスのことを指します。
デザインパターンでは、このFacadeクラスを利用するパターンをFacadeパターンと呼びます。
（ちなみに、Facadeは「窓口」を意味する単語です）

サンプルコードとして、RPGのダメージ計算を模したプログラムを作成してみました。
RPGのダメージ計算は複雑で、そのRPGに詳しくない人が正しく計算式を実装するのは困難なのですが、Facadeクラスを用いることにより、Facadeクラスの利用者は詳しい知識を持たずとも正しく計算式を実装することが可能となります。

【サンプルコード】

・PhysicsBaseDamageCalc.java

public final class PhysicsBaseDamageCalc {

    private int baseDamage = 0;

    public PhysicsBaseDamageCalc(int physicsPower) {
        baseDamage = physicsPower / 2; //攻撃力の半分がダメージ
    }

    public int getBaseDamage() {
        return baseDamage;
    }

}

public final class PhysicsBaseDamageCalc {

private int baseDamage = 0;

public PhysicsBaseDamageCalc(int physicsPower) {

baseDamage = physicsPower / 2; //攻撃力の半分がダメージ

}

public int getBaseDamage() {

return baseDamage;

}

・MagicBaseDamageCalc.java

public final class MagicBaseDamageCalc {

    private int baseDamage = 0;

    public MagicBaseDamageCalc(int magicID) {
        if (magicID == 0) { //魔法「FireL1」
            baseDamage = 15;
        } else if (magicID == 1) { //魔法「FireL2」
            baseDamage = 60;
        } else if (magicID == 2) { //魔法「FireL3」
            baseDamage = 120;
        } else { //例外処理
            System.out.println("指定された魔法ＩＤは未実装です");
            System.exit(1);
        }
    }

    public int getBaseDamage() {
        return baseDamage;
    }

}

public final class MagicBaseDamageCalc {

private int baseDamage = 0;

public MagicBaseDamageCalc(int magicID) {

if (magicID == 0) { //魔法「FireL1」

baseDamage = 15;

} else if (magicID == 1) { //魔法「FireL2」

baseDamage = 60;

} else if (magicID == 2) { //魔法「FireL3」

baseDamage = 120;

} else { //例外処理

System.out.println("指定された魔法ＩＤは未実装です");

System.exit(1);

}

public int getBaseDamage() {

return baseDamage;

}

・DamageRandomize.java

import java.util.Random;

public final class DamageRandomize {

    private int damage = 0;

    public DamageRandomize(int baseDamage) {
        // 7/8、8/8、9/8の何れかの値をかけてランダム化
        damage = baseDamage * (new Random().nextInt(3) + 7) / 8;
    }

    public int getDamage() {
        return damage;
    }
}

import java.util.Random;

public final class DamageRandomize {

private int damage = 0;

public DamageRandomize(int baseDamage) {

// 7/8、8/8、9/8の何れかの値をかけてランダム化

damage = baseDamage * (new Random().nextInt(3) + 7) / 8;

}

public int getDamage() {

return damage;

}

・DamageCalcFacade.java

public final class DamageCalcFacade {

    private int damage = 0;

    public DamageCalcFacade (int physicsPower,int magicID) {
        int baseDamage = 0;
        if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃
            baseDamage = new PhysicsBaseDamageCalc(physicsPower)
                              .getBaseDamage();
        } else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃
            baseDamage = new MagicBaseDamageCalc(magicID)
                              .getBaseDamage();
        } else { //例外処理
            System.out.println("不正なダメージ計算です");
            System.exit(1);
        }
        damage = new DamageRandomize(baseDamage).getDamage();
    }

    public int getDamage() {
        return damage;
    }
}

public final class DamageCalcFacade {

private int damage = 0;

public DamageCalcFacade (int physicsPower,int magicID) {

int baseDamage = 0;

if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃

baseDamage = new PhysicsBaseDamageCalc(physicsPower)

.getBaseDamage();

} else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃

baseDamage = new MagicBaseDamageCalc(magicID)

.getBaseDamage();

} else { //例外処理

System.out.println("不正なダメージ計算です");

System.exit(1);

}

damage = new DamageRandomize(baseDamage).getDamage();

}

public int getDamage() {

return damage;

}

・DamageCalcMain.java

public class DamageCalcMain {
    public static void main(String[] args){

        int physicsPower = -1;
        int magicID = -1;
        int damage = 0;

        // 引数から物理攻撃力、魔法ＩＤを取得
        if (args.length == 2) {
            physicsPower = Integer.parseInt(args[0]);
            magicID = Integer.parseInt(args[1]);
        }

        // ダメージ計算→計算式を知らないとこのように実装できない
        /*
        int baseDamage = 0;
        if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃
            baseDamage = new PhysicsBaseDamageCalc(physicsPower)
                              .getBaseDamage();
        } else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃
            baseDamage = new MagicBaseDamageCalc(magicID)
                              .getBaseDamage();
        } else { //例外処理
            System.out.println("不正なダメージ計算です");
            System.exit(1);
        }
        damage = new DamageRandomize(baseDamage).getDamage();
        */

        // 利用者側で複雑な計算式を考えたくないので、Facadeクラスに任せる
        damage = new DamageCalcFacade(physicsPower,magicID).getDamage();

        System.out.println("ダメージは"+damage);
        System.exit(0);

    }
}

public class DamageCalcMain {

public static void main(String[] args){

int physicsPower = -1;

int magicID = -1;

int damage = 0;

// 引数から物理攻撃力、魔法ＩＤを取得

if (args.length == 2) {

physicsPower = Integer.parseInt(args[0]);

magicID = Integer.parseInt(args[1]);

}

// ダメージ計算→計算式を知らないとこのように実装できない

int baseDamage = 0;

if (physicsPower ＞= 0 || magicID == -1) { //物理攻撃

baseDamage = new PhysicsBaseDamageCalc(physicsPower)

.getBaseDamage();

} else if (physicsPower == -1 || magicID ＞= 0) { //魔法攻撃

baseDamage = new MagicBaseDamageCalc(magicID)

.getBaseDamage();

} else { //例外処理

System.out.println("不正なダメージ計算です");

System.exit(1);

}

damage = new DamageRandomize(baseDamage).getDamage();

// 利用者側で複雑な計算式を考えたくないので、Facadeクラスに任せる

damage = new DamageCalcFacade(physicsPower,magicID).getDamage();

System.out.println("ダメージは"+damage);

System.exit(0);

}

【実行結果】

ダメージは52

ダメージは52

　※第１引数に-1、第２引数に1を指定した場合

いかがでしたでしょうか。

デザインパターンはオブジェクト指向プログラミングのプログラミング手法をまとめたものなのですが、このFacadeパターンは手続き型言語にも応用が可能です。
複雑な処理を共通クラス・共通関数・共通スクリプト等のような形で切り出して利用者側に意識させないようにする、というのは現場でも良く使う手法なので、覚えておいて損はありません。

では、また次回！