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

###前提・実現したいこと
{@link Comparable<MonsterComparison>} を実装した
{@link ComparableMonster} クラスを作りたい。

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

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

###ComparableMonster.java

Java
1public class ComparableMonster implements Comparable<ComparableMonster> {
2	private String name;
3	private int attackStat;
4	private int defenseStat;
5	private Type type;
6
7	public ComparableMonster(String name, int attackStat, int defenseStat, Type type) {
8		super();
9		this.name = name;
10		this.attackStat = attackStat;
11		this.defenseStat = defenseStat;
12		this.type = type;
13	}
14
15	public String getName() {
16		return name;
17	}
18
19	public int getAttackStat() {
20		return attackStat;
21	}
22
23	public int getDefenseStat() {
24		return defenseStat;
25	}
26
27	public Type getType() {
28		return type;
29	}
30
31	@Override
32	public String toString() {
33		return "MonsterComparison [name=" + getName() + "]";
34	}
35
36	// @Override
37	public int compareTo(ComparableMonster enemy) {
38		
39	}
40}

###ComparableMonster.java

Java
1import java.util.Arrays;
2import java.util.LinkedHashMap;
3import java.util.List;
4import java.util.Map;
5import junit.framework.TestCase;
6
7public class ComparableMonsterTest extends TestCase {
8	protected void setUp() throws Exception {
9		super.setUp();
10	}
11
12	protected void tearDown() throws Exception {
13		super.tearDown();
14	}
15
16	public void testMonsterComparisonImplements() {
17		ComparableMonster mc = new ComparableMonster("FIRE タイプ", 0, 0, Type.FIRE);
18		if (!(mc instanceof Comparable<?>)) {
19			fail("MonsterComparison クラスに Comparable インターフェースが実装されていません。");
20		}
21	}
22
23	public void testWhenExistNull() {
24		testMonsterComparisonImplements();
25		ComparableMonster monster0 = new ComparableMonster("FIRE タイプ", 0, 0, Type.FIRE);
26		ComparableMonster monster1 = new ComparableMonster("GRASS タイプ", 0, 0, Type.GRASS);
27		ComparableMonster monster2 = new ComparableMonster("BUG タイプ", 0, 0, Type.BUG);
28		ComparableMonster monster3 = new ComparableMonster("BUG タイプ", 0, 0, Type.BUG);
29		ComparableMonster monster4 = null;
30		ComparableMonster[] monsters = new ComparableMonster[] { monster0, monster1, monster2, monster3, monster4 };
31		try {
32			for (int i = 0; i < monsters.length; i++) {
33				for (int j = i + 1; j < monsters.length; j++) {
34					monsters[i].compareTo(monsters[j]);
35				}
36			}
37		} catch (IllegalArgumentException e) {
38			// handled null object correctly
39		} catch (NullPointerException e) {
40			fail("null が含まれる場合は、IllegalArgumentException を投げましょう。");
41		}
42	}
43
44	public void testType() {
45		testMonsterComparisonImplements();
46		ComparableMonster fire = new ComparableMonster("FIRE タイプ", 0, 0, Type.FIRE);
47		ComparableMonster bug = new ComparableMonster("BUG タイプ", 1, 0, Type.BUG);
48		ComparableMonster grass = new ComparableMonster("GRASS タイプ", 2, 0, Type.GRASS);
49		ComparableMonster[] array = new ComparableMonster[] { grass, bug, fire };
50		Arrays.sort(array);
51		if (array[0].equals(grass) && array[1].equals(bug) && array[2].equals(fire)) {
52			// succeeded
53		} else {
54			fail("タイプによる強さの比較がうまくいっていません。");
55		}
56	}
57
58	public void testAttack() {
59		testMonsterComparisonImplements();
60		ComparableMonster weekest = new ComparableMonster("attackStat 0", 0, 0, Type.FIRE);
61		ComparableMonster marginal = new ComparableMonster("attackStat 1", 1, 0, Type.FIRE);
62		ComparableMonster strongest = new ComparableMonster("attackStat 2", 2, 0, Type.FIRE);
63		ComparableMonster[] array = new ComparableMonster[] { strongest, marginal, weekest };
64		Arrays.sort(array);
65		if (array[0] == weekest && array[1] == marginal && array[2] == strongest) {
66			// succeeded
67		} else {
68			fail("attackStat による強さの比較がうまくいっていません。");
69		}
70	}
71
72	public void testDefence() {
73		testMonsterComparisonImplements();
74		ComparableMonster weekest = new ComparableMonster("defenceStat -2147483648", 0, Integer.MIN_VALUE, Type.BUG);
75		ComparableMonster marginal = new ComparableMonster("defenceStat 0", 0, 0, Type.BUG);
76		ComparableMonster strongest = new ComparableMonster("defenceStat 2147483647", 0, Integer.MAX_VALUE, Type.BUG);
77		ComparableMonster[] array = new ComparableMonster[] { strongest, marginal, weekest };
78		Arrays.sort(array);
79		if (array[0] == weekest && array[1] == marginal && array[2] == strongest) {
80			// succeeded
81		} else {
82			fail("defenceStat による強さの比較がうまくいっていません。");
83		}
84	}
85
86	public void testAttackAndDeffence() {
87		testMonsterComparisonImplements();
88		// arrange
89		ComparableMonster monster0 = new ComparableMonster("(5,0)", 5, 0, Type.BUG);
90		ComparableMonster monster1 = new ComparableMonster("(2,6)", 2, 6, Type.BUG);
91		ComparableMonster monster2 = new ComparableMonster("(3,5)", 3, 5, Type.BUG);
92		ComparableMonster monster3 = new ComparableMonster("(4,4)", 4, 4, Type.BUG);
93		ComparableMonster monster4 = new ComparableMonster("(7,1)", 7, 1, Type.BUG);
94		ComparableMonster[] monsters = new ComparableMonster[] { monster0, monster1, monster2, monster3, monster4 };
95		// act
96		Arrays.sort(monsters);
97		// assert
98		Map<Integer, ComparableMonster> monsterMap = new LinkedHashMap<>();
99		int cnt = 0;
100		monsterMap.put(cnt++, monster0);
101		monsterMap.put(cnt++, monster1);
102		monsterMap.put(cnt++, monster2);
103		monsterMap.put(cnt++, monster3);
104		monsterMap.put(cnt++, monster4);
105		int index = 0;
106		for (ComparableMonster monster : monsterMap.values()) {
107			if (!monsters[index++].equals(monster)) {
108				fail("比較がうまくいっていません。");
109			}
110		}
111	}
112
113	public void testWhenExistTie() {
114		testMonsterComparisonImplements();
115		ComparableMonster monster00 = new ComparableMonster("0", 0, -1, Type.GRASS);
116		ComparableMonster monster01 = new ComparableMonster("1", 0, 0, Type.GRASS);
117		ComparableMonster monster02 = new ComparableMonster("2", 0, 0, Type.GRASS);
118		ComparableMonster monster03 = new ComparableMonster("3", 0, 0, Type.GRASS);
119		ComparableMonster monster04 = new ComparableMonster("4", 0, 0, Type.BUG);
120		ComparableMonster[] monsters = new ComparableMonster[] { monster04, monster03, monster02, monster01,
121				monster00 };
122		Arrays.sort(monsters);
123		if (!monsters[0].equals(monster00)) {
124			fail("比較がうまくいっていません。");
125		}
126		if (!monsters[4].equals(monster04)) {
127			fail("比較がうまくいっていません。");
128		}
129		List<ComparableMonster> monsterList = Arrays.asList(monsters);
130		if (!monsterList.contains(monster01) || !monsterList.contains(monster02) || !monsterList.contains(monster03)) {
131			fail("比較がうまくいっていません。");
132		}
133	}
134
135	public void testLargeCase() {
136		testMonsterComparisonImplements();
137		// arrange
138		ComparableMonster monster19 = new ComparableMonster("ミュウ", Integer.MAX_VALUE, Integer.MAX_VALUE, Type.FIRE);
139		ComparableMonster monster18 = new ComparableMonster("ミュウツー", 9999999, 888888, Type.FIRE);
140		ComparableMonster monster17 = new ComparableMonster("フーディン", 102, 102, Type.BUG);
141		ComparableMonster monster16 = new ComparableMonster("ユンゲラー", 102, 101, Type.BUG);
142		ComparableMonster monster15 = new ComparableMonster("ピカチュウ", 101, 102, Type.BUG);
143		ComparableMonster monster14 = new ComparableMonster("ライチュウ", 101, 101, Type.BUG);
144		ComparableMonster monster13 = new ComparableMonster("ケーシー", 101, 100, Type.BUG);
145		ComparableMonster monster12 = new ComparableMonster("フリーザ", 99, 102, Type.BUG);
146		ComparableMonster monster11 = new ComparableMonster("ヒュンダー", 100, 100, Type.BUG);
147		ComparableMonster monster10 = new ComparableMonster("ファイアー", 99, 100, Type.BUG);
148		ComparableMonster monster09 = new ComparableMonster("カビゴン", Integer.MAX_VALUE, 1000, Type.GRASS);
149		ComparableMonster monster08 = new ComparableMonster("フシギダネ", Integer.MAX_VALUE, 0, Type.GRASS);
150		ComparableMonster monster07 = new ComparableMonster("フシギソウ", Integer.MAX_VALUE, Integer.MIN_VALUE, Type.GRASS);
151		ComparableMonster monster06 = new ComparableMonster("フシギバナ", 100, 100, Type.GRASS);
152		ComparableMonster monster05 = new ComparableMonster("ヒトカゲ", 100, 99, Type.GRASS);
153		ComparableMonster monster04 = new ComparableMonster("リザード", 100, 98, Type.GRASS);
154		ComparableMonster monster03 = new ComparableMonster("リザードン", -3, 250, Type.GRASS);
155		ComparableMonster monster02 = new ComparableMonster("ゼニガメ", 0, 0, Type.GRASS);
156		ComparableMonster monster01 = new ComparableMonster("カメール", -100, -100, Type.GRASS);
157		ComparableMonster monster00 = new ComparableMonster("カメックス", Integer.MIN_VALUE, Integer.MIN_VALUE, Type.GRASS);
158		ComparableMonster[] monsters = new ComparableMonster[] { monster09, monster08, monster07, monster06, monster05,
159				monster00, monster01, monster02, monster03, monster04, monster10, monster11, monster12, monster13,
160				monster14, monster19, monster18, monster17, monster16, monster15 };
161		// act
162		Arrays.sort(monsters);
163		// assert
164		Map<Integer, ComparableMonster> monsterMap = new LinkedHashMap<>();
165		int cnt = 0;
166		monsterMap.put(cnt++, monster00);
167		monsterMap.put(cnt++, monster01);
168		monsterMap.put(cnt++, monster02);
169		monsterMap.put(cnt++, monster03);
170		monsterMap.put(cnt++, monster04);
171		monsterMap.put(cnt++, monster05);
172		monsterMap.put(cnt++, monster06);
173		monsterMap.put(cnt++, monster07);
174		monsterMap.put(cnt++, monster08);
175		monsterMap.put(cnt++, monster09);
176		monsterMap.put(cnt++, monster10);
177		monsterMap.put(cnt++, monster11);
178		monsterMap.put(cnt++, monster12);
179		monsterMap.put(cnt++, monster13);
180		monsterMap.put(cnt++, monster14);
181		monsterMap.put(cnt++, monster15);
182		monsterMap.put(cnt++, monster16);
183		monsterMap.put(cnt++, monster17);
184		monsterMap.put(cnt++, monster18);
185		monsterMap.put(cnt++, monster19);
186		int index = 0;
187		for (ComparableMonster monster : monsterMap.values()) {
188			if (!monsters[index++].equals(monster)) {
189				fail("比較がうまくいっていません。");
190			}
191		}
192	}
193}

行動規範の内容に同意します

回答1件

ベストアンサー

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

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

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

java
1public class ComparableMonster implements Comparable<ComparableMonster> {
2    public int compareTo(ComparableMonster enemy) {
3        int result = this.type.compareTo(enemy.type);
4        // 0でない(差がある)場合はその結果をそのまま返す
5        if (result != 0) return result;
6        // 0である(同位である)場合は所定の値を比較する
7        return Integer.compare(this.parameter(), enemy.parameter());
8    }
9
10    public int parameter() {
11        return 3 * attackStat + 2 * defenseStat;
12    }
13}