質問をすることでしか得られない、回答やアドバイスがある。

15分調べてもわからないことは、質問しよう!

ただいまの
回答率

90.51%

  • Java

    15836questions

    Javaは、1995年にサン・マイクロシステムズが開発したプログラミング言語です。表記法はC言語に似ていますが、既存のプログラミング言語の短所を踏まえていちから設計されており、最初からオブジェクト指向性を備えてデザインされています。セキュリティ面が強力であることや、ネットワーク環境での利用に向いていることが特徴です。Javaで作られたソフトウェアは基本的にいかなるプラットフォームでも作動します。

comparableクラスの実装、自作の比較メソッドを作りたい。

解決済

回答 1

投稿

  • 評価
  • クリップ 0
  • VIEW 915

b_b_b

score 24

前提・実現したいこと

{@link Comparable<MonsterComparison>} を実装した
{@link ComparableMonster} クラスを作りたい。

クラスは以下を満たすものとします。
・FIRE タイプは BUG, GRASS タイプより強く(大きく)、
BUG タイプは GRASS タイプより強い(大きい)
・同じタイプ同士では、(3*attackStat + 2* defenseStat) が大きい方が強い(大きい)
(type は常に null でないと仮定してかまいません)

ComparableMonster.javaのcompareToメソッドの中身に何を入れていいかわかりません。
下のテストクラスが正常に動くようなメソッドをご教授お願い致します。

ComparableMonster.java

public class ComparableMonster implements Comparable<ComparableMonster> {
    private String name;
    private int attackStat;
    private int defenseStat;
    private Type type;

    public ComparableMonster(String name, int attackStat, int defenseStat, Type type) {
        super();
        this.name = name;
        this.attackStat = attackStat;
        this.defenseStat = defenseStat;
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public int getAttackStat() {
        return attackStat;
    }

    public int getDefenseStat() {
        return defenseStat;
    }

    public Type getType() {
        return type;
    }

    @Override
    public String toString() {
        return "MonsterComparison [name=" + getName() + "]";
    }

    // @Override
    public int compareTo(ComparableMonster enemy) {

    }
}

ComparableMonster.java

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;

public class ComparableMonsterTest extends TestCase {
    protected void setUp() throws Exception {
        super.setUp();
    }

    protected void tearDown() throws Exception {
        super.tearDown();
    }

    public void testMonsterComparisonImplements() {
        ComparableMonster mc = new ComparableMonster("FIRE タイプ", 0, 0, Type.FIRE);
        if (!(mc instanceof Comparable<?>)) {
            fail("MonsterComparison クラスに Comparable インターフェースが実装されていません。");
        }
    }

    public void testWhenExistNull() {
        testMonsterComparisonImplements();
        ComparableMonster monster0 = new ComparableMonster("FIRE タイプ", 0, 0, Type.FIRE);
        ComparableMonster monster1 = new ComparableMonster("GRASS タイプ", 0, 0, Type.GRASS);
        ComparableMonster monster2 = new ComparableMonster("BUG タイプ", 0, 0, Type.BUG);
        ComparableMonster monster3 = new ComparableMonster("BUG タイプ", 0, 0, Type.BUG);
        ComparableMonster monster4 = null;
        ComparableMonster[] monsters = new ComparableMonster[] { monster0, monster1, monster2, monster3, monster4 };
        try {
            for (int i = 0; i < monsters.length; i++) {
                for (int j = i + 1; j < monsters.length; j++) {
                    monsters[i].compareTo(monsters[j]);
                }
            }
        } catch (IllegalArgumentException e) {
            // handled null object correctly
        } catch (NullPointerException e) {
            fail("null が含まれる場合は、IllegalArgumentException を投げましょう。");
        }
    }

    public void testType() {
        testMonsterComparisonImplements();
        ComparableMonster fire = new ComparableMonster("FIRE タイプ", 0, 0, Type.FIRE);
        ComparableMonster bug = new ComparableMonster("BUG タイプ", 1, 0, Type.BUG);
        ComparableMonster grass = new ComparableMonster("GRASS タイプ", 2, 0, Type.GRASS);
        ComparableMonster[] array = new ComparableMonster[] { grass, bug, fire };
        Arrays.sort(array);
        if (array[0].equals(grass) && array[1].equals(bug) && array[2].equals(fire)) {
            // succeeded
        } else {
            fail("タイプによる強さの比較がうまくいっていません。");
        }
    }

    public void testAttack() {
        testMonsterComparisonImplements();
        ComparableMonster weekest = new ComparableMonster("attackStat 0", 0, 0, Type.FIRE);
        ComparableMonster marginal = new ComparableMonster("attackStat 1", 1, 0, Type.FIRE);
        ComparableMonster strongest = new ComparableMonster("attackStat 2", 2, 0, Type.FIRE);
        ComparableMonster[] array = new ComparableMonster[] { strongest, marginal, weekest };
        Arrays.sort(array);
        if (array[0] == weekest && array[1] == marginal && array[2] == strongest) {
            // succeeded
        } else {
            fail("attackStat による強さの比較がうまくいっていません。");
        }
    }

    public void testDefence() {
        testMonsterComparisonImplements();
        ComparableMonster weekest = new ComparableMonster("defenceStat -2147483648", 0, Integer.MIN_VALUE, Type.BUG);
        ComparableMonster marginal = new ComparableMonster("defenceStat 0", 0, 0, Type.BUG);
        ComparableMonster strongest = new ComparableMonster("defenceStat 2147483647", 0, Integer.MAX_VALUE, Type.BUG);
        ComparableMonster[] array = new ComparableMonster[] { strongest, marginal, weekest };
        Arrays.sort(array);
        if (array[0] == weekest && array[1] == marginal && array[2] == strongest) {
            // succeeded
        } else {
            fail("defenceStat による強さの比較がうまくいっていません。");
        }
    }

    public void testAttackAndDeffence() {
        testMonsterComparisonImplements();
        // arrange
        ComparableMonster monster0 = new ComparableMonster("(5,0)", 5, 0, Type.BUG);
        ComparableMonster monster1 = new ComparableMonster("(2,6)", 2, 6, Type.BUG);
        ComparableMonster monster2 = new ComparableMonster("(3,5)", 3, 5, Type.BUG);
        ComparableMonster monster3 = new ComparableMonster("(4,4)", 4, 4, Type.BUG);
        ComparableMonster monster4 = new ComparableMonster("(7,1)", 7, 1, Type.BUG);
        ComparableMonster[] monsters = new ComparableMonster[] { monster0, monster1, monster2, monster3, monster4 };
        // act
        Arrays.sort(monsters);
        // assert
        Map<Integer, ComparableMonster> monsterMap = new LinkedHashMap<>();
        int cnt = 0;
        monsterMap.put(cnt++, monster0);
        monsterMap.put(cnt++, monster1);
        monsterMap.put(cnt++, monster2);
        monsterMap.put(cnt++, monster3);
        monsterMap.put(cnt++, monster4);
        int index = 0;
        for (ComparableMonster monster : monsterMap.values()) {
            if (!monsters[index++].equals(monster)) {
                fail("比較がうまくいっていません。");
            }
        }
    }

    public void testWhenExistTie() {
        testMonsterComparisonImplements();
        ComparableMonster monster00 = new ComparableMonster("0", 0, -1, Type.GRASS);
        ComparableMonster monster01 = new ComparableMonster("1", 0, 0, Type.GRASS);
        ComparableMonster monster02 = new ComparableMonster("2", 0, 0, Type.GRASS);
        ComparableMonster monster03 = new ComparableMonster("3", 0, 0, Type.GRASS);
        ComparableMonster monster04 = new ComparableMonster("4", 0, 0, Type.BUG);
        ComparableMonster[] monsters = new ComparableMonster[] { monster04, monster03, monster02, monster01,
                monster00 };
        Arrays.sort(monsters);
        if (!monsters[0].equals(monster00)) {
            fail("比較がうまくいっていません。");
        }
        if (!monsters[4].equals(monster04)) {
            fail("比較がうまくいっていません。");
        }
        List<ComparableMonster> monsterList = Arrays.asList(monsters);
        if (!monsterList.contains(monster01) || !monsterList.contains(monster02) || !monsterList.contains(monster03)) {
            fail("比較がうまくいっていません。");
        }
    }

    public void testLargeCase() {
        testMonsterComparisonImplements();
        // arrange
        ComparableMonster monster19 = new ComparableMonster("ミュウ", Integer.MAX_VALUE, Integer.MAX_VALUE, Type.FIRE);
        ComparableMonster monster18 = new ComparableMonster("ミュウツー", 9999999, 888888, Type.FIRE);
        ComparableMonster monster17 = new ComparableMonster("フーディン", 102, 102, Type.BUG);
        ComparableMonster monster16 = new ComparableMonster("ユンゲラー", 102, 101, Type.BUG);
        ComparableMonster monster15 = new ComparableMonster("ピカチュウ", 101, 102, Type.BUG);
        ComparableMonster monster14 = new ComparableMonster("ライチュウ", 101, 101, Type.BUG);
        ComparableMonster monster13 = new ComparableMonster("ケーシー", 101, 100, Type.BUG);
        ComparableMonster monster12 = new ComparableMonster("フリーザ", 99, 102, Type.BUG);
        ComparableMonster monster11 = new ComparableMonster("ヒュンダー", 100, 100, Type.BUG);
        ComparableMonster monster10 = new ComparableMonster("ファイアー", 99, 100, Type.BUG);
        ComparableMonster monster09 = new ComparableMonster("カビゴン", Integer.MAX_VALUE, 1000, Type.GRASS);
        ComparableMonster monster08 = new ComparableMonster("フシギダネ", Integer.MAX_VALUE, 0, Type.GRASS);
        ComparableMonster monster07 = new ComparableMonster("フシギソウ", Integer.MAX_VALUE, Integer.MIN_VALUE, Type.GRASS);
        ComparableMonster monster06 = new ComparableMonster("フシギバナ", 100, 100, Type.GRASS);
        ComparableMonster monster05 = new ComparableMonster("ヒトカゲ", 100, 99, Type.GRASS);
        ComparableMonster monster04 = new ComparableMonster("リザード", 100, 98, Type.GRASS);
        ComparableMonster monster03 = new ComparableMonster("リザードン", -3, 250, Type.GRASS);
        ComparableMonster monster02 = new ComparableMonster("ゼニガメ", 0, 0, Type.GRASS);
        ComparableMonster monster01 = new ComparableMonster("カメール", -100, -100, Type.GRASS);
        ComparableMonster monster00 = new ComparableMonster("カメックス", Integer.MIN_VALUE, Integer.MIN_VALUE, Type.GRASS);
        ComparableMonster[] monsters = new ComparableMonster[] { monster09, monster08, monster07, monster06, monster05,
                monster00, monster01, monster02, monster03, monster04, monster10, monster11, monster12, monster13,
                monster14, monster19, monster18, monster17, monster16, monster15 };
        // act
        Arrays.sort(monsters);
        // assert
        Map<Integer, ComparableMonster> monsterMap = new LinkedHashMap<>();
        int cnt = 0;
        monsterMap.put(cnt++, monster00);
        monsterMap.put(cnt++, monster01);
        monsterMap.put(cnt++, monster02);
        monsterMap.put(cnt++, monster03);
        monsterMap.put(cnt++, monster04);
        monsterMap.put(cnt++, monster05);
        monsterMap.put(cnt++, monster06);
        monsterMap.put(cnt++, monster07);
        monsterMap.put(cnt++, monster08);
        monsterMap.put(cnt++, monster09);
        monsterMap.put(cnt++, monster10);
        monsterMap.put(cnt++, monster11);
        monsterMap.put(cnt++, monster12);
        monsterMap.put(cnt++, monster13);
        monsterMap.put(cnt++, monster14);
        monsterMap.put(cnt++, monster15);
        monsterMap.put(cnt++, monster16);
        monsterMap.put(cnt++, monster17);
        monsterMap.put(cnt++, monster18);
        monsterMap.put(cnt++, monster19);
        int index = 0;
        for (ComparableMonster monster : monsterMap.values()) {
            if (!monsters[index++].equals(monster)) {
                fail("比較がうまくいっていません。");
            }
        }
    }
}
  • 気になる質問をクリップする

    クリップした質問は、後からいつでもマイページで確認できます。

    またクリップした質問に回答があった際、通知やメールを受け取ることができます。

    クリップを取り消します

  • 良い質問の評価を上げる

    以下のような質問は評価を上げましょう

    • 質問内容が明確
    • 自分も答えを知りたい
    • 質問者以外のユーザにも役立つ

    評価が高い質問は、TOPページの「注目」タブのフィードに表示されやすくなります。

    質問の評価を上げたことを取り消します

  • 評価を下げられる数の上限に達しました

    評価を下げることができません

    • 1日5回まで評価を下げられます
    • 1日に1ユーザに対して2回まで評価を下げられます

    質問の評価を下げる

    teratailでは下記のような質問を「具体的に困っていることがない質問」、「サイトポリシーに違反する質問」と定義し、推奨していません。

    • プログラミングに関係のない質問
    • やってほしいことだけを記載した丸投げの質問
    • 問題・課題が含まれていない質問
    • 意図的に内容が抹消された質問
    • 広告と受け取られるような投稿

    評価が下がると、TOPページの「アクティブ」「注目」タブのフィードに表示されにくくなります。

    質問の評価を下げたことを取り消します

    この機能は開放されていません

    評価を下げる条件を満たしてません

    評価を下げる理由を選択してください

    詳細な説明はこちら

    上記に当てはまらず、質問内容が明確になっていない質問には「情報の追加・修正依頼」機能からコメントをしてください。

    質問の評価を下げる機能の利用条件

    この機能を利用するためには、以下の事項を行う必要があります。

回答 1

checkベストアンサー

+1

Typeクラスが示されていませんが、まずそのTypeクラスにComparable<Type>を実装させておきます。

// どういうものかわからないのでイメージ的に書いておきます
class Type implements Comparable<Type> {
    static List<Type> types = Arrays.asList(GRASS, BUG, FIRE);
    public int compareTo(Type another) {
        return types.indexOf(this) - types.indexOf(another);
    }
}

こうしておけば、ComparableMonsterの比較において、まずTypeを比較し、Typeが同位なら所定の値の大小を比較するというように書けます。所定の値は専用メソッドを用意しておいたほうがいいでしょう。

public class ComparableMonster implements Comparable<ComparableMonster> {
    public int compareTo(ComparableMonster enemy) {
        int result = this.type.compareTo(enemy.type);
        // 0でない(差がある)場合はその結果をそのまま返す
        if (result != 0) return result;
        // 0である(同位である)場合は所定の値を比較する
        return Integer.compare(this.parameter(), enemy.parameter());
    }

    public int parameter() {
        return 3 * attackStat + 2 * defenseStat;
    }
}

投稿

  • 回答の評価を上げる

    以下のような回答は評価を上げましょう

    • 正しい回答
    • わかりやすい回答
    • ためになる回答

    評価が高い回答ほどページの上位に表示されます。

  • 回答の評価を下げる

    下記のような回答は推奨されていません。

    • 間違っている回答
    • 質問の回答になっていない投稿
    • スパムや攻撃的な表現を用いた投稿

    評価を下げる際はその理由を明確に伝え、適切な回答に修正してもらいましょう。

同じタグがついた質問を見る

  • Java

    15836questions

    Javaは、1995年にサン・マイクロシステムズが開発したプログラミング言語です。表記法はC言語に似ていますが、既存のプログラミング言語の短所を踏まえていちから設計されており、最初からオブジェクト指向性を備えてデザインされています。セキュリティ面が強力であることや、ネットワーク環境での利用に向いていることが特徴です。Javaで作られたソフトウェアは基本的にいかなるプラットフォームでも作動します。