1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

	/**
	 * 値が(this mod m)であるBigIntegerを返します。
	 * このメソッドは、remainderメソッドとは異なり、
   * 常に負でないBigIntegerを返します。
	 * 
	 * @param m 正でなければならない
	 * @return this mod m.
	 * @throws ArithmetricException m <= 0の場合.
	 */
	public BigInteger mod(BigInteger m) {
		if(m.signum() <= 0) {
			throw new ArithmeticException("Modulus <= 0: " + m);
		}
		// 計算を行う
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public static void main(String[] args) {
    int price = Integer.parseInt(args[0]);
    int num = Integer.parseInt(args[1]);

    if (price > 0 || num > 0) {
        int sum = sum(price, num);
        System.out.printf("%d + %d = %d%n", price, num, sum);
    } else {
        System.out.println("価格と数量には正の値を指定してください");
    }
}

private static int sum(int price, int num) {
    assert price > 0 : "price: " + price;
    assert num > 0 : "num: " + num;

    return price * num;
}

1
2
3
4
5
6
7
8

// 第1引数は0より大きな数である必要がある
java -ea EJ38 0 3
/**
* 実行結果
* Exception in thread "main" java.lang.AssertionError: price: 0
* at com.example.takuto_no.effective_java.chapter8.EJ38.sum(EJ38.java:39)
* at com.example.takuto_no.effective_java.chapter8.EJ38.main(EJ38.java:29)
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class Period {
	private final Date start;
	private final Date end;

	/**
	 * @param start 期間の開始
	 * @param end 期間の終わり。開始よりも前であってはならない
	 * @throws IllegalArgumentException startがendの後の場合
	 * @throws NullPointerException startかendがnullの場合
	 */
	public Period(Date start, Date end) {
		if (start.compareTo(end) > 0)
			throw new IllegalArgumentException(start + " after " + end);
		this.start = start;
		this.end = end;
	}

	public Date start() {
		return start;
	}

	public Date end() {
		return end;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Date start = new Date();
Date end = new Date();
Period p = new Period(start, end);
// Attack 1
// Period内部のendと、endが同じアドレスを指しているため、これで、Period内部を変更できてしまう。
end.setYear(78);

// Attack 2
// Period#end()で、periodのendを取得できるため、Period内部を変更できてしまう。
p.end().setYear(78);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

public class Period {
	private final Date start;
	private final Date end;

	/**
	 * @param start 期間の開始
	 * @param end 期間の終わり。開始よりも前であってはならない
	 * @throws IllegalArgumentException startがendの後の場合
	 * @throws NullPointerException startかendがnullの場合
	 */
	public Period(Date start, Date end) {
		// Attack 1の対策
		// 元のパラメータのコピーを保存する
		this.start = new Date(start.getTime());
		this.end = new Date(end.getTime());

		if (start.compareTo(end) > 0)
			throw new IllegalArgumentException(start + " after " + end);
	}


	public Date start() {
		// Attack 2の対策
		// コピーを返却する
		return new Date(start.getTime());
	}

	public Date end() {
		return new Date(end.getTime());
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class TypeClassifier {
	public static String classify(int a) {
		return "int";
	}
	public static String classify(char a) {
		return "char";
	}
	public static String classify(double a) {
		return "double";
	}

	public static void main(String[] args) {
		System.out.println(classify(1));
		System.out.println(classify('a'));
		System.out.println(classify(1.0));
		// 実行結果
		/*
		   int
		   char
		   double
		*/
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class CollectionClassifier {
	public static String classify(Set<?> s) {
		return "Set";
	}

	public static String classify(List<?> s) {
		return "List";
	}

	public static String classify(Collection<?> s) {
		return "Collection";
	}

	public static void main(String[] args) {
		Collection<?>[] collections = { new HashSet<String>(), new ArrayList<String>(),
				new HashMap<String, String>().values() };

		for (Collection<?> c : collections) {
			System.out.println(classify(c));
		}
		// 実行結果
		/*
		   Collection
		   Collection
		   Collection
		*/
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class Wine {
	String name() {
		return "wine";
	}
}

class SparklingWine extends Wine {
	@Override
	String name() {
		return "sparkling wine";
	}
}

class Champagne extends SparklingWine {
	@Override
	String name() {
		return "champagne";
	}
}

class Overriding {
	public static void main(String[] args) {
		List<Wine> list = List.of(new Wine(), new SparklingWine(), new Champagne());

		for (Wine wine : list) {
			System.out.println(wine.name());
		}
		// 実行結果
		/*
		   wine
		   sparkling wine
		   champagne
		*/
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class Varargs {
    public static void main(String[] args) {
        System.out.println(min1(99));
        System.out.println(min2(1, 2, 3));

    }

    // ugly
    static int min1(int... args) {
        if (args.length == 0)
            throw new IllegalArgumentException("Too few arguments");
        int min = args[0];
        for (int i = 1; i < args.length; i++)
            if (args[i] < min)
                min = args[i];
        return min;
    }

    // better
    static int min2(int firstArg, int... remainingArgs) {
        int min = firstArg;
        for (int arg : remainingArgs) {
            if (arg < min) {
                min = arg;
            }
        }
        return min;
    }
}

1
2
3

// 要素があれば、そのSetが返却される
// 要素がなければ、空のSetが返却される
list.stream().map(str -> str.upperCase()).collect(Collectors.toSet());

1
2

null以外の値が含まれている場合も含まれていない場合もあるコンテナ・オブジェクトです。
値が存在する場合、isPresent()はtrueを返し、get()は値を返します。