プログラミング – ページ 20 – サイゼントの技術ブログ

2020年2月15日

javaでのCompositeパターン

Compositeパターンは、入れ物のクラスと中身のクラスを１つの抽象クラスでまとめ、同一視できるようにするパターンです。
このパターンを取り入れることで、クラスを使う側から見て入れ物のクラスなのか中身のクラスなのかを意識する必要がなくなります。

ファイルシステムの例が多いですが、理解を深めるために今回はあえて別の例を出して説明します。
袋と本・ゲームソフトの例を出して説明します。
単に袋の中に本やゲームソフトを入れるだけでなく、袋が破れないように袋を二重にする（袋の中に袋を入れる）こともありますし、袋の中に本用の袋とゲームソフト用の袋を入れて分類することもあります。
このような場合、Compositeパターンを用いることで、袋でも本・ゲームソフトでも同じように処理することができるようになります。

【サンプルコード】

・Entry.java

public abstract class Entry {

    public abstract void descript();

}

public abstract class Entry {

public abstract void descript();

}

・Book.java

public class Book extends Entry {

    private String name;

    public Book(String name) {
        this.name = name;
    }

    public void descript() {
        System.out.println("これは" + name + "という本です。");
    }
}

public class Book extends Entry {

private String name;

public Book(String name) {

this.name = name;

}

public void descript() {

System.out.println("これは" + name + "という本です。");

}

・GameSoft.java

public class GameSoft extends Entry {

    private String name;

    public GameSoft(String name) {
        this.name = name;
    }

    public void descript() {
        System.out.println("これは" + name + "というソフトです。");
    }
}

public class GameSoft extends Entry {

private String name;

public GameSoft(String name) {

this.name = name;

}

public void descript() {

System.out.println("これは" + name + "というソフトです。");

}

・Bag.java

import java.util.ArrayList;
import java.util.Iterator;

public class Bag extends Entry {

    private String name;
    private ArrayList＜Entry＞ item = new ArrayList&lt;Entry>();

    public Bag(String name) {
        this.name = name;
    }

    public Entry add(Entry entry) {
        item.add(entry);
        return this;
    }

    public void descript() {
        System.out.println("これは" + name + "という袋です。");
        Iterator＜Entry＞ iterator = item.iterator();
        while (iterator.hasNext()) {
            Entry entry = (Entry) iterator.next();
            System.out.print("袋「" + name + "」の中身：");
            entry.descript();
        }
    }
}

import java.util.ArrayList;

import java.util.Iterator;

public class Bag extends Entry {

private String name;

private ArrayList＜Entry＞ item = new ArrayList<Entry>();

public Bag(String name) {

this.name = name;

}

public Entry add(Entry entry) {

item.add(entry);

return this;

}

public void descript() {

System.out.println("これは" + name + "という袋です。");

Iterator＜Entry＞ iterator = item.iterator();

while (iterator.hasNext()) {

Entry entry = (Entry) iterator.next();

System.out.print("袋「" + name + "」の中身：");

entry.descript();

}

・EntryMain.java

public class EntryMain {

    public static void main(String[] args) {

        // 袋、本・ゲームソフトを作成
        Bag bigBag = new Bag("BigBag");
        Bag emptyBag = new Bag("EmptyBag");
        Bag bagOfBook = new Bag("BagOfBook");
        Bag bagOfSoft = new Bag("BagOfSoft");
        Book bigBook = new Book("BigBook");
        Book book1 = new Book("Book1");
        Book book2 = new Book("Book2");
        GameSoft soft1 = new GameSoft("Soft1");
        GameSoft soft2 = new GameSoft("Soft2");

        // 袋の中に詰める
        // 袋の中に詰めるのは袋でも本・ゲームソフトでも良い
        // （入れ物のクラスなのか中身のクラスなのか意識しなくて良い）
        bagOfBook.add(book1);
        bagOfBook.add(book2);
        bagOfSoft.add(soft1);
        bagOfSoft.add(soft2);
        bigBag.add(emptyBag);
        bigBag.add(bagOfBook);
        bigBag.add(bagOfSoft);
        bigBag.add(bigBook);

        // 説明を見る
        // 袋でも本・ゲームソフトでも同じように説明を見ることができる
        // （入れ物のクラスなのか中身のクラスなのか意識しなくて良い）
        System.out.println("［BigBag（入れ物クラス）の説明］");
        bigBag.descript();
        System.out.println();
        System.out.println("［Book1（中身クラス）の説明］");
        book1.descript();

    }
}

public class EntryMain {

public static void main(String[] args) {

// 袋、本・ゲームソフトを作成

Bag bigBag = new Bag("BigBag");

Bag emptyBag = new Bag("EmptyBag");

Bag bagOfBook = new Bag("BagOfBook");

Bag bagOfSoft = new Bag("BagOfSoft");

Book bigBook = new Book("BigBook");

Book book1 = new Book("Book1");

Book book2 = new Book("Book2");

GameSoft soft1 = new GameSoft("Soft1");

GameSoft soft2 = new GameSoft("Soft2");

// 袋の中に詰める

// 袋の中に詰めるのは袋でも本・ゲームソフトでも良い

// （入れ物のクラスなのか中身のクラスなのか意識しなくて良い）

bagOfBook.add(book1);

bagOfBook.add(book2);

bagOfSoft.add(soft1);

bagOfSoft.add(soft2);

bigBag.add(emptyBag);

bigBag.add(bagOfBook);

bigBag.add(bagOfSoft);

bigBag.add(bigBook);

// 説明を見る

// 袋でも本・ゲームソフトでも同じように説明を見ることができる

// （入れ物のクラスなのか中身のクラスなのか意識しなくて良い）

System.out.println("［BigBag（入れ物クラス）の説明］");

bigBag.descript();

System.out.println();

System.out.println("［Book1（中身クラス）の説明］");

book1.descript();

}

【実行結果】

［BigBag（入れ物クラス）の説明］
これはBigBagという袋です。
袋「BigBag」の中身：これはEmptyBagという袋です。
袋「BigBag」の中身：これはBagOfBookという袋です。
袋「BagOfBook」の中身：これはBook1という本です。
袋「BagOfBook」の中身：これはBook2という本です。
袋「BigBag」の中身：これはBagOfSoftという袋です。
袋「BagOfSoft」の中身：これはSoft1というソフトです。
袋「BagOfSoft」の中身：これはSoft2というソフトです。
袋「BigBag」の中身：これはBigBookという本です。

［Book1（中身クラス）の説明］
これはBook1という本です。

［BigBag（入れ物クラス）の説明］

これはBigBagという袋です。

袋「BigBag」の中身：これはEmptyBagという袋です。

袋「BigBag」の中身：これはBagOfBookという袋です。

袋「BagOfBook」の中身：これはBook1という本です。

袋「BagOfBook」の中身：これはBook2という本です。

袋「BigBag」の中身：これはBagOfSoftという袋です。

袋「BagOfSoft」の中身：これはSoft1というソフトです。

袋「BagOfSoft」の中身：これはSoft2というソフトです。

袋「BigBag」の中身：これはBigBookという本です。

［Book1（中身クラス）の説明］

これはBook1という本です。

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

今回紹介したデザインパターンは、ファイルシステムを扱う時等に役に立つのではないかと思います。
このような再帰的なパターンを自力で思いつくのは難しいと思うので、デザインパターンから学んでおくのが良いと思います。

これからも、役に立つデザインパターンを紹介していこうと思います！

2020年2月8日

javaでのBridgeパターン

Bridgeパターンは、機能のクラス階層と実装（処理の中身）のクラス階層を橋渡しするパターンです。
機能のクラス階層と実装のクラス階層を分けることで、実装毎に機能を書かなくて良くなりますし、その逆に機能毎に実装を書かなくて良くなります。
結果として、重複した記述を減らすことができ、保守性を向上させることができます。

今回は、RPGのダメージ計算を模したサンプルコードを作成してみました。
機能のクラス階層ではダメージの与え方を定義し、実装のクラス階層では具体的なダメージ計算式を定義しています。
Bridgeパターンの適用により、ダメージの与え方毎にダメージ計算式を書かなくて良くなっている点、逆にダメージ計算式毎にダメージの与え方を書かなくて良くなっている点に注目です。

【サンプルコード】

・DamageCalc.java

// ダメージ計算機能
public class DamageCalc {

    protected DamageCalcImpl damageCalcImpl;
    protected int damage = 0;

    public DamageCalc (DamageCalcImpl damageCalcImpl) {
        this.damageCalcImpl = damageCalcImpl;
    }

    protected void clearDamage() {
        damage = 0;
    }

    public int getDamage() {
        return this.damage;
    }

    public void damageCalc(int offenceValue, int defenceValue) {
        clearDamage();
        damage = damageCalcImpl.damageCalc(offenceValue,defenceValue);
    }

}

// ダメージ計算機能

public class DamageCalc {

protected DamageCalcImpl damageCalcImpl;

protected int damage = 0;

public DamageCalc (DamageCalcImpl damageCalcImpl) {

this.damageCalcImpl = damageCalcImpl;

}

protected void clearDamage() {

damage = 0;

}

public int getDamage() {

return this.damage;

}

public void damageCalc(int offenceValue, int defenceValue) {

clearDamage();

damage = damageCalcImpl.damageCalc(offenceValue,defenceValue);

}

・MultipleDamageCalc.java

// ダメージ計算機能（連続攻撃に対応するための拡張）
public class MultipleDamageCalc extends DamageCalc {

    public MultipleDamageCalc(DamageCalcImpl damageCalcImpl) {
        super(damageCalcImpl);
    }

    public void multipleDamageCalc
        (int offenceValue, int defenceValue, int damageTimes) {
        clearDamage();
        for(int i = 0;i ＜ damageTimes;i++) {
            damage += damageCalcImpl.damageCalc(offenceValue,defenceValue);
        }
    }

}

// ダメージ計算機能（連続攻撃に対応するための拡張）

public class MultipleDamageCalc extends DamageCalc {

public MultipleDamageCalc(DamageCalcImpl damageCalcImpl) {

super(damageCalcImpl);

}

public void multipleDamageCalc

(int offenceValue, int defenceValue, int damageTimes) {

clearDamage();

for(int i = 0;i ＜ damageTimes;i++) {

damage += damageCalcImpl.damageCalc(offenceValue,defenceValue);

}

・DamageCalcImpl.java

// ダメージ計算の実装（抽象クラス）
public abstract class DamageCalcImpl {

    public abstract int damageCalc(int offenceValue, int defenceValue);

}

// ダメージ計算の実装（抽象クラス）

public abstract class DamageCalcImpl {

public abstract int damageCalc(int offenceValue, int defenceValue);

}

・NormalDamageCalcImpl.java

// ダメージ計算の実装（通常のダメージ計算）
public class NormalDamageCalcImpl extends DamageCalcImpl {

    public int damageCalc(int offenceValue, int defenceValue) {
        int damage = 0;
        damage = offenceValue - (defenceValue/2);
        if (damage ＜ 0) {
            damage = 0;
        }
        return damage;
    }

}

// ダメージ計算の実装（通常のダメージ計算）

public class NormalDamageCalcImpl extends DamageCalcImpl {

public int damageCalc(int offenceValue, int defenceValue) {

int damage = 0;

damage = offenceValue - (defenceValue/2);

if (damage ＜ 0) {

damage = 0;

}

return damage;

}

・IgnoreDefenceDamageCalcImpl.java

// ダメージ計算の実装（防御無視のダメージ計算）
public class IgnoreDefenceDamageCalcImpl extends DamageCalcImpl {

    public int damageCalc(int offenceValue, int defenceValue) {
        int damage = 0;
        damage = offenceValue;
        if (damage ＜ 0) {
            damage = 0;
        }
        return damage;
    }

}

// ダメージ計算の実装（防御無視のダメージ計算）

public class IgnoreDefenceDamageCalcImpl extends DamageCalcImpl {

public int damageCalc(int offenceValue, int defenceValue) {

int damage = 0;

damage = offenceValue;

if (damage ＜ 0) {

damage = 0;

}

return damage;

}

・DamageCalcMain.java

// ダメージ計算のメインクラス
public class DamageCalcMain {
    public static void main(String[] args){

        int offenceValue = 100;
        int defenceValue = 50;
        int multipleDamageTimes = 4; // 連続攻撃の場合のみ使用

        NormalDamageCalcImpl normalDamageCalcImpl =
            new NormalDamageCalcImpl();
        IgnoreDefenceDamageCalcImpl ignoreDefenceDamageCalcImpl =
            new IgnoreDefenceDamageCalcImpl();

        System.out.println("■通常のダメージ計算（１回攻撃）");
        DamageCalc damageCalc1 = new DamageCalc(normalDamageCalcImpl);
        damageCalc1.damageCalc(offenceValue, defenceValue);
        System.out.println("　ダメージ：" + damageCalc1.getDamage());

        // 実装を独立させることで、実装毎に機能を書かなくて良い
        // （通常の１回攻撃メソッドと
        //   防御無視の１回攻撃メソッドを用意しなくて良い）
        System.out.println("■防御無視のダメージ計算（１回攻撃）");
        DamageCalc damageCalc2 =
            new DamageCalc(ignoreDefenceDamageCalcImpl);
        damageCalc2.damageCalc(offenceValue, defenceValue);
        System.out.println("　ダメージ：" + damageCalc2.getDamage());

        // 機能を独立させることで、機能毎に実装を書かなくて良い
        // （１回攻撃の防御無視メソッドと
        //   複数攻撃の防御無視メソッドを用意しなくて良い）
        System.out.println("■防御無視のダメージ計算（４回攻撃）");
        MultipleDamageCalc multipleDamageCalc1 =
            new MultipleDamageCalc(ignoreDefenceDamageCalcImpl);
        multipleDamageCalc1.multipleDamageCalc
            (offenceValue, defenceValue, multipleDamageTimes);
        System.out.println("　ダメージ：" + multipleDamageCalc1.getDamage());

    }
}

// ダメージ計算のメインクラス

public class DamageCalcMain {

public static void main(String[] args){

int offenceValue = 100;

int defenceValue = 50;

int multipleDamageTimes = 4; // 連続攻撃の場合のみ使用

NormalDamageCalcImpl normalDamageCalcImpl =

new NormalDamageCalcImpl();

IgnoreDefenceDamageCalcImpl ignoreDefenceDamageCalcImpl =

new IgnoreDefenceDamageCalcImpl();

System.out.println("■通常のダメージ計算（１回攻撃）");

DamageCalc damageCalc1 = new DamageCalc(normalDamageCalcImpl);

damageCalc1.damageCalc(offenceValue, defenceValue);

System.out.println("　ダメージ：" + damageCalc1.getDamage());

// 実装を独立させることで、実装毎に機能を書かなくて良い

// （通常の１回攻撃メソッドと

// 防御無視の１回攻撃メソッドを用意しなくて良い）

System.out.println("■防御無視のダメージ計算（１回攻撃）");

DamageCalc damageCalc2 =

new DamageCalc(ignoreDefenceDamageCalcImpl);

damageCalc2.damageCalc(offenceValue, defenceValue);

System.out.println("　ダメージ：" + damageCalc2.getDamage());

// 機能を独立させることで、機能毎に実装を書かなくて良い

// （１回攻撃の防御無視メソッドと

// 複数攻撃の防御無視メソッドを用意しなくて良い）

System.out.println("■防御無視のダメージ計算（４回攻撃）");

MultipleDamageCalc multipleDamageCalc1 =

new MultipleDamageCalc(ignoreDefenceDamageCalcImpl);

multipleDamageCalc1.multipleDamageCalc

(offenceValue, defenceValue, multipleDamageTimes);

System.out.println("　ダメージ：" + multipleDamageCalc1.getDamage());

}

【実行結果】

■通常のダメージ計算（１回攻撃）
　ダメージ：75
■防御無視のダメージ計算（１回攻撃）
　ダメージ：100
■防御無視のダメージ計算（４回攻撃）
　ダメージ：400

■通常のダメージ計算（１回攻撃）

　ダメージ：75

■防御無視のダメージ計算（１回攻撃）

　ダメージ：100

■防御無視のダメージ計算（４回攻撃）

　ダメージ：400

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

先日記事にさせていただいたBuilderパターンと似たような話ですが、こちらのパターンは、機能や処理の中身が少しずつ違う場合に冗長性を排除できるパターンです。
同じ記述をコピーすると保守性が低下しますので、同じ記述が続いてると思ったらこのパターンの適用を検討した方が良いと思います。

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

2020年2月1日

javaでのBuilderパターン

Builderパターンは、処理内容を定義するBuilderクラスと、処理順番を定義するDirectorクラスの２つに分けることで、柔軟に処理を変更できるようにするパターンです。
Builderクラスの定義により処理内容が変わっても都度処理内容を記述する必要が無くなり、Directorクラスの定義により処理順番が変わっても都度処理順番を記述する必要が無くなります。

今回は、RPGのダメージ計算を模したサンプルコードを作成してみました。
ゲームが変わると処理内容が変わるのですが、Builderクラスを定義することで処理内容が変更されても利用者側で処理内容を都度記述する必要が無くなります。
また、ダメージを与える手段によってはダメージが可変になったり固定になったりするのですが、Directorクラスを定義することで利用者側で都度ダメージを可変にしたり固定にしたりするための具体的な記述をする必要が無くなります。

【サンプルコード】

・DamageBuilder.java

// ダメージ計算で使用する共通のメソッドを定義
public interface DamageBuilder {

    public void baseDamageCalc(int offenceValue,int defenceValue);
    public void damageRandomise();
    public Object getResult();

}

// ダメージ計算で使用する共通のメソッドを定義

public interface DamageBuilder {

public void baseDamageCalc(int offenceValue,int defenceValue);

public void damageRandomise();

public Object getResult();

}

・DamageDto.java

public class DamageDto {

    private int DamageValue;

    public int getDamageValue() {
        return DamageValue;
    }

    public void setDamageValue(int damageValue) {
        DamageValue = damageValue;
    }

}

public class DamageDto {

private int DamageValue;

public int getDamageValue() {

return DamageValue;

}

public void setDamageValue(int damageValue) {

DamageValue = damageValue;

}

・DamageBuilderGameA.java

import java.util.Random;

// ゲームA用の計算式を記述
public class DamageBuilderGameA implements DamageBuilder {

    private DamageDto damageDto;

    public DamageBuilderGameA(){
        this.damageDto = new DamageDto();
    }

    public void baseDamageCalc(int offenceValue, int defenceValue) {
        int baseDamageValue = offenceValue - (defenceValue / 2);
        if (baseDamageValue ＜ 0) {
            baseDamageValue = 0;
        }
        damageDto.setDamageValue(baseDamageValue);
    }

    public void damageRandomise() {
        // 4/5、5/5、6/5の何れかの値をかけてランダム化する
        damageDto.setDamageValue(damageDto.getDamageValue() *
                ((new Random()).nextInt(3) + 4) / 5);
    }

    public Object getResult() {
        return this.damageDto;
    }

}

import java.util.Random;

// ゲームA用の計算式を記述

public class DamageBuilderGameA implements DamageBuilder {

private DamageDto damageDto;

public DamageBuilderGameA(){

this.damageDto = new DamageDto();

}

public void baseDamageCalc(int offenceValue, int defenceValue) {

int baseDamageValue = offenceValue - (defenceValue / 2);

if (baseDamageValue ＜ 0) {

baseDamageValue = 0;

}

damageDto.setDamageValue(baseDamageValue);

}

public void damageRandomise() {

// 4/5、5/5、6/5の何れかの値をかけてランダム化する

damageDto.setDamageValue(damageDto.getDamageValue() *

((new Random()).nextInt(3) + 4) / 5);

}

public Object getResult() {

return this.damageDto;

}

・DamageBuilderGameB.java

import java.util.Random;

// ゲームB用の計算式を記述
public class DamageBuilderGameB implements DamageBuilder {

    private DamageDto damageDto;

    public DamageBuilderGameB(){
        this.damageDto = new DamageDto();
    }

    public void baseDamageCalc(int offenceValue, int defenceValue) {
        int baseDamageValue = offenceValue / (defenceValue / 10);
        if (baseDamageValue ＜ 0) {
            baseDamageValue = 0;
        }
        damageDto.setDamageValue(baseDamageValue);
    }

    public void damageRandomise() {
        // 9/10、10/10、11/10の何れかの値をかけてランダム化する
        damageDto.setDamageValue(damageDto.getDamageValue() *
                ((new Random()).nextInt(3) + 9) / 10);
    }

    public Object getResult() {
        return this.damageDto;
    }

}

import java.util.Random;

// ゲームB用の計算式を記述

public class DamageBuilderGameB implements DamageBuilder {

private DamageDto damageDto;

public DamageBuilderGameB(){

this.damageDto = new DamageDto();

}

public void baseDamageCalc(int offenceValue, int defenceValue) {

int baseDamageValue = offenceValue / (defenceValue / 10);

if (baseDamageValue ＜ 0) {

baseDamageValue = 0;

}

damageDto.setDamageValue(baseDamageValue);

}

public void damageRandomise() {

// 9/10、10/10、11/10の何れかの値をかけてランダム化する

damageDto.setDamageValue(damageDto.getDamageValue() *

((new Random()).nextInt(3) + 9) / 10);

}

public Object getResult() {

return this.damageDto;

}

・DamageDirectorVariable.java

// ダメージがランダムで変化するケースで使用するDirector
public class DamageDirectorVariable {

    private DamageBuilder damageBuilder;
    public DamageDirectorVariable (DamageBuilder damageBuilder){
        this.damageBuilder = damageBuilder;
    }

    public void constract(int offenceValue,int defenceValue){
        damageBuilder.baseDamageCalc(offenceValue,defenceValue);
        damageBuilder.damageRandomise();
    }

}

// ダメージがランダムで変化するケースで使用するDirector

public class DamageDirectorVariable {

private DamageBuilder damageBuilder;

public DamageDirectorVariable (DamageBuilder damageBuilder){

this.damageBuilder = damageBuilder;

}

public void constract(int offenceValue,int defenceValue){

damageBuilder.baseDamageCalc(offenceValue,defenceValue);

damageBuilder.damageRandomise();

}

・DamageDirectorFixed.java

// ダメージが固定のケースで使用するDirector
public class DamageDirectorFixed {

    private DamageBuilder damageBuilder;
    public DamageDirectorFixed (DamageBuilder damageBuilder){
        this.damageBuilder = damageBuilder;
    }

    public void constract(int offenceValue,int defenceValue){
        damageBuilder.baseDamageCalc(offenceValue,defenceValue);
    }

}

// ダメージが固定のケースで使用するDirector

public class DamageDirectorFixed {

private DamageBuilder damageBuilder;

public DamageDirectorFixed (DamageBuilder damageBuilder){

this.damageBuilder = damageBuilder;

}

public void constract(int offenceValue,int defenceValue){

damageBuilder.baseDamageCalc(offenceValue,defenceValue);

}

・DamageCalcMain.java

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

        int offenceValue = 100;
        int defenceValue = 100;
        int damageValue = 0;

        DamageBuilderGameA damageBuilderGameA = new DamageBuilderGameA();
        DamageBuilderGameB damageBuilderGameB = new DamageBuilderGameB();
        DamageDirectorVariable damageDirectorValiableGameA =
                new DamageDirectorVariable(damageBuilderGameA);
        DamageDirectorFixed damageDirectorFixedGameA =
                new DamageDirectorFixed(damageBuilderGameA);
        DamageDirectorVariable damageDirectorValiableGameB =
                new DamageDirectorVariable(damageBuilderGameB);

        System.out.println
                ("■ゲームA用のダメージ計算（ダメージ可変ケース）");
        damageDirectorValiableGameA.constract(offenceValue, defenceValue);
        damageValue = 
                ((DamageDto) damageBuilderGameA.getResult()).getDamageValue();
        System.out.println("　ダメージ：" + damageValue);

        // Directorを定義することで利用者側で処理の順番を都度定義しなくて良い
        System.out.println
                ("■ゲームA用のダメージ計算（ダメージ固定ケース）");
        damageDirectorFixedGameA.constract(offenceValue, defenceValue);
        damageValue = 
                ((DamageDto) damageBuilderGameA.getResult()).getDamageValue();
        System.out.println("　ダメージ：" + damageValue);

        // Builderを定義することで利用者側で処理の内容を都度定義しなくて良い
        System.out.println
                ("■ゲームB用のダメージ計算（ダメージ可変ケース）");
        damageDirectorValiableGameB.constract(offenceValue, defenceValue);
        damageValue = 
                ((DamageDto) damageBuilderGameB.getResult()).getDamageValue();
        System.out.println("　ダメージ：" + damageValue);

    }
}

public class DamageCalcMain {

public static void main(String[] args){

int offenceValue = 100;

int defenceValue = 100;

int damageValue = 0;

DamageBuilderGameA damageBuilderGameA = new DamageBuilderGameA();

DamageBuilderGameB damageBuilderGameB = new DamageBuilderGameB();

DamageDirectorVariable damageDirectorValiableGameA =

new DamageDirectorVariable(damageBuilderGameA);

DamageDirectorFixed damageDirectorFixedGameA =

new DamageDirectorFixed(damageBuilderGameA);

DamageDirectorVariable damageDirectorValiableGameB =

new DamageDirectorVariable(damageBuilderGameB);

System.out.println

("■ゲームA用のダメージ計算（ダメージ可変ケース）");

damageDirectorValiableGameA.constract(offenceValue, defenceValue);

damageValue =

((DamageDto) damageBuilderGameA.getResult()).getDamageValue();

System.out.println("　ダメージ：" + damageValue);

// Directorを定義することで利用者側で処理の順番を都度定義しなくて良い

System.out.println

("■ゲームA用のダメージ計算（ダメージ固定ケース）");

damageDirectorFixedGameA.constract(offenceValue, defenceValue);

damageValue =

((DamageDto) damageBuilderGameA.getResult()).getDamageValue();

System.out.println("　ダメージ：" + damageValue);

// Builderを定義することで利用者側で処理の内容を都度定義しなくて良い

System.out.println

("■ゲームB用のダメージ計算（ダメージ可変ケース）");

damageDirectorValiableGameB.constract(offenceValue, defenceValue);

damageValue =

((DamageDto) damageBuilderGameB.getResult()).getDamageValue();

System.out.println("　ダメージ：" + damageValue);

}

【実行結果】

■ゲームA用のダメージ計算（ダメージ可変ケース）
　ダメージ：40
■ゲームA用のダメージ計算（ダメージ固定ケース）
　ダメージ：50
■ゲームB用のダメージ計算（ダメージ可変ケース）
　ダメージ：9

■ゲームA用のダメージ計算（ダメージ可変ケース）

　ダメージ：40

■ゲームA用のダメージ計算（ダメージ固定ケース）

　ダメージ：50

■ゲームB用のダメージ計算（ダメージ可変ケース）

　ダメージ：9

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

プログラムを作っていると、「処理の順番は同じなのに処理の中身が少しずつ違う…」といったことや「処理の中身は同じなのに処理の順番が少しずつ違う…」といったことがあると思います。私も、そのようなケースでは、共通関数は作りつつも同じ記述を何か所にもコピーせざるを得なくなり、かなり冗長なコードを作ってしまっていました。
Builderパターンは、そのようなケースで効果を発揮します。同じ記述を何か所にもコピーすると保守する時に（テストも含めて）大変なので、中身や順番が少しずつ違うなと思ったら適用することをお勧めします。

次回も、開発の役に立つ情報を発信していきたいと思います！

2020年1月24日

java：オブジェクトの中身をコピーする方法（cloneメソッド実装）

参照型変数（主に、自分で作成したクラスのオブジェクト）をコピーする場合、単純に「=」で代入するだけでは不十分な場合があります。
参照型変数の中身は参照先（オブジェクトのメモリ領域を示すポインタ）です。
「=」で代入するだけでは、参照先だけがコピーされて、参照しているものは同じという状態になるので、コピー先の変更がコピー元に影響してしまいますし、その逆にコピー元の変更がコピー先に影響してしまいます。

これを避けたい場合は、cloneメソッドを用いて中身を丸ごとコピー（新たにメモリ領域を確保し書き込み）する必要があります。
以下の記述を行うことで、cloneメソッドを使用することができるようになります。

・cloneしたいクラスでCloneableインターフェースを実装する

・Cloneableインターフェースのclone()メソッドをオーバーライドする

・clone()メソッド内で、super.clone()メソッドを使用する

　（super＝Objectクラス）

・super.clone()メソッドはObject型で返ってくるので自身の型でキャストを行う

・CloneNotSupportedExceptionが返ってくる可能性があるので例外処理する

以下、サンプルコードです。
参照先のみコピーした場合とcloneで中身をコピーした場合を比較しています。
参照先のみコピーした場合は、コピー後にコピー先を変更した際にコピー元が影響を受けていますが、cloneで中身をコピーした場合は影響を受けていません。

【サンプルコード】

・CloneableItem.java

// cloneしたいクラスはCloneableインターフェースを実装する必要がある
public class CloneableItem implements Cloneable {

    // イミュータブルではない参照型変数を含む場合はそれも一緒にcloneが必要
    // （今回は割愛）
    private int itemId;
    private String itemName;

    public int getItemId() {
        return itemId;
    }
    public void setItemId(int itemId) {
        this.itemId = itemId;
    }
    public String getItemName() {
        return itemName;
    }
    public void setItemName(String itemName) {
        this.itemName = itemName;
    }

    // Cloneableインターフェースのclone()メソッドをオーバーライド
    @Override
    public CloneableItem clone() {
        CloneableItem clonedItem = null;
        // CloneNotSupportedExceptionを返す可能性があるので例外処理が必要
        try {
            // Object型で返ってくるのでキャストが必要
            clonedItem = (CloneableItem)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clonedItem;
    }

}

// cloneしたいクラスはCloneableインターフェースを実装する必要がある

public class CloneableItem implements Cloneable {

// イミュータブルではない参照型変数を含む場合はそれも一緒にcloneが必要

// （今回は割愛）

private int itemId;

private String itemName;

public int getItemId() {

return itemId;

}

public void setItemId(int itemId) {

this.itemId = itemId;

}

public String getItemName() {

return itemName;

}

public void setItemName(String itemName) {

this.itemName = itemName;

}

// Cloneableインターフェースのclone()メソッドをオーバーライド

@Override

public CloneableItem clone() {

CloneableItem clonedItem = null;

// CloneNotSupportedExceptionを返す可能性があるので例外処理が必要

try {

// Object型で返ってくるのでキャストが必要

clonedItem = (CloneableItem)super.clone();

} catch (CloneNotSupportedException e) {

e.printStackTrace();

}

return clonedItem;

}

・ItemCloneMain.java

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

        System.out.println("［参照先のみコピーした場合］");
        CloneableItem cloneableItem1 = new CloneableItem();
        cloneableItem1.setItemId(1);
        cloneableItem1.setItemName("sword");
        System.out.println
            ("コピー前のコピー元オブジェクト：ID=" +
             cloneableItem1.getItemId() +
             " NAME=" +
             cloneableItem1.getItemName());
        CloneableItem cloneableItem2 = cloneableItem1;
        System.out.println
            ("コピー後のコピー元オブジェクト：ID=" +
             cloneableItem1.getItemId() +
             " NAME=" +
             cloneableItem1.getItemName());
        System.out.println
            ("コピー後のコピー先オブジェクト：ID=" +
             cloneableItem2.getItemId() +
             " NAME=" +
             cloneableItem2.getItemName());
        cloneableItem2.setItemId(2);
        cloneableItem2.setItemName("shield");
        System.out.println
            ("編集後のコピー元オブジェクト　：ID=" +
             cloneableItem1.getItemId() +
             " NAME=" +
             cloneableItem1.getItemName());
        System.out.println
            ("編集後のコピー先オブジェクト　：ID=" +
             cloneableItem2.getItemId() +
             " NAME=" +
             cloneableItem2.getItemName());

        System.out.println("");
        System.out.println("［cloneで中身をコピーした場合］");
        CloneableItem cloneableItem3 = new CloneableItem();
        cloneableItem3.setItemId(3);
        cloneableItem3.setItemName("armor");
        System.out.println
            ("コピー前のコピー元オブジェクト：ID=" +
             cloneableItem3.getItemId() +
             " NAME=" +
             cloneableItem3.getItemName());
        CloneableItem cloneableItem4 = cloneableItem3.clone();
        System.out.println
            ("コピー後のコピー元オブジェクト：ID=" +
             cloneableItem3.getItemId() +
             " NAME=" +
             cloneableItem3.getItemName());
        System.out.println
            ("コピー後のコピー先オブジェクト：ID=" +
             cloneableItem4.getItemId() +
             " NAME=" +
             cloneableItem4.getItemName());
        cloneableItem4.setItemId(4);
        cloneableItem4.setItemName("helm");
        System.out.println
            ("編集後のコピー元オブジェクト　：ID=" +
             cloneableItem3.getItemId() +
             " NAME=" +
             cloneableItem3.getItemName());
        System.out.println
            ("編集後のコピー先オブジェクト　：ID=" +
             cloneableItem4.getItemId() +
             " NAME=" +
             cloneableItem4.getItemName());

    }
}

public class ItemCloneMain {

public static void main(String[] args){

System.out.println("［参照先のみコピーした場合］");

CloneableItem cloneableItem1 = new CloneableItem();

cloneableItem1.setItemId(1);

cloneableItem1.setItemName("sword");

System.out.println

("コピー前のコピー元オブジェクト：ID=" +

cloneableItem1.getItemId() +

" NAME=" +

cloneableItem1.getItemName());

CloneableItem cloneableItem2 = cloneableItem1;

System.out.println

("コピー後のコピー元オブジェクト：ID=" +

cloneableItem1.getItemId() +

" NAME=" +

cloneableItem1.getItemName());

System.out.println

("コピー後のコピー先オブジェクト：ID=" +

cloneableItem2.getItemId() +

" NAME=" +

cloneableItem2.getItemName());

cloneableItem2.setItemId(2);

cloneableItem2.setItemName("shield");

System.out.println

("編集後のコピー元オブジェクト　：ID=" +

cloneableItem1.getItemId() +

" NAME=" +

cloneableItem1.getItemName());

System.out.println

("編集後のコピー先オブジェクト　：ID=" +

cloneableItem2.getItemId() +

" NAME=" +

cloneableItem2.getItemName());

System.out.println("");

System.out.println("［cloneで中身をコピーした場合］");

CloneableItem cloneableItem3 = new CloneableItem();

cloneableItem3.setItemId(3);

cloneableItem3.setItemName("armor");

System.out.println

("コピー前のコピー元オブジェクト：ID=" +

cloneableItem3.getItemId() +

" NAME=" +

cloneableItem3.getItemName());

CloneableItem cloneableItem4 = cloneableItem3.clone();

System.out.println

("コピー後のコピー元オブジェクト：ID=" +

cloneableItem3.getItemId() +

" NAME=" +

cloneableItem3.getItemName());

System.out.println

("コピー後のコピー先オブジェクト：ID=" +

cloneableItem4.getItemId() +

" NAME=" +

cloneableItem4.getItemName());

cloneableItem4.setItemId(4);

cloneableItem4.setItemName("helm");

System.out.println

("編集後のコピー元オブジェクト　：ID=" +

cloneableItem3.getItemId() +

" NAME=" +

cloneableItem3.getItemName());

System.out.println

("編集後のコピー先オブジェクト　：ID=" +

cloneableItem4.getItemId() +

" NAME=" +

cloneableItem4.getItemName());

}

【実行結果】

［参照先のみコピーした場合］
コピー前のコピー元オブジェクト：ID=1 NAME=sword
コピー後のコピー元オブジェクト：ID=1 NAME=sword
コピー後のコピー先オブジェクト：ID=1 NAME=sword
編集後のコピー元オブジェクト　：ID=2 NAME=shield
編集後のコピー先オブジェクト　：ID=2 NAME=shield

［cloneで中身をコピーした場合］
コピー前のコピー元オブジェクト：ID=3 NAME=armor
コピー後のコピー元オブジェクト：ID=3 NAME=armor
コピー後のコピー先オブジェクト：ID=3 NAME=armor
編集後のコピー元オブジェクト　：ID=3 NAME=armor
編集後のコピー先オブジェクト　：ID=4 NAME=helm

［参照先のみコピーした場合］

コピー前のコピー元オブジェクト：ID=1 NAME=sword

コピー後のコピー元オブジェクト：ID=1 NAME=sword

コピー後のコピー先オブジェクト：ID=1 NAME=sword

編集後のコピー元オブジェクト　：ID=2 NAME=shield

編集後のコピー先オブジェクト　：ID=2 NAME=shield

［cloneで中身をコピーした場合］

コピー前のコピー元オブジェクト：ID=3 NAME=armor

コピー後のコピー元オブジェクト：ID=3 NAME=armor

コピー後のコピー先オブジェクト：ID=3 NAME=armor

編集後のコピー元オブジェクト　：ID=3 NAME=armor

編集後のコピー先オブジェクト　：ID=4 NAME=helm

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

javaでオブジェクトの中身をコピーしようとした場合、言語仕様上の問題により意外と複雑な実装になってしまいます。
そのため、サンプルコードを参考に実装するのがお勧めです。
Webには他の方が書いてくださったサンプルコードが色々とあるので、用途に応じて他のサンプルコードも参考にしてみると良いでしょう。

今回の記事がお役に立てれば幸いです。
これからもjavaに関する記事を書いていこうと思います！

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

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