Index
์์ดํ 1. ์์ฑ์ ๋์ ์ ์ ํฉํฐ๋ฆฌ ๋ฉ์๋๋ฅผ ๊ณ ๋ คํ๋ผ
ํต์ฌ ์ ๋ฆฌ
์ฅ์
- ์ด๋ฆ์ ๊ฐ์ง ์ ์๋ค. (๋์ผํ ์๊ทธ๋์ฒ์ ์์ฑ์๋ฅผ ๋๊ฐ ๊ฐ์ง ์ ์๋ค.)
public static Order createForPrime(boolean prime, Product product) {
Order order = new Order();
order.prime = prime;
order.product = product;
return order;
}
public static Order createForUrgent(boolean urgent, Product product) {
Order order = new Order();
order.urgent = urgent;
order.product = product;
return order;
}
- ํธ์ถ๋ ๋๋ง๋ค ์ธ์คํด์ค๋ฅผ ์๋ก ์์ฑํ์ง ์์๋ ๋๋ค. (Boolean.valueOf)
public static final Boolean TRUE = new Boolean(true);
public static final Boolean FALSE = new Boolean(false);
public static Boolean valueOf(boolean b) {
return (b ? TRUE : FALSE);
}
// main
Boolean.valueOf(false);
- ๋ฐํ ํ์ ์ ํ์ ํ์ ๊ฐ์ฒด๋ฅผ ๋ฐํํ ์ ์๋ ๋ฅ๋ ฅ์ด ์๋ค. (์ธํฐํ์ด์ค ๊ธฐ๋ฐ ํ๋ ์์ํฌ, ์ธํฐํ์ด์ค์ ์ ์ ๋ฉ์๋)
- ์ ๋ ฅ ๋งค๊ฐ๋ณ์์ ๋ฐ๋ผ ๋งค๋ฒ ๋ค๋ฅธ ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ๋ฐํํ ์ ์๋ค. (EnumSet)
- ์ ์ ํฉํฐ๋ฆฌ ๋ฉ์๋๋ฅผ ์์ฑํ๋ ์์ ์๋ ๋ฐํํ ๊ฐ์ฒด์ ํด๋์ค๊ฐ ์กด์ฌํ์ง ์์๋ ๋๋ค. (์๋น์ค ์ ๊ณต์ ํ๋ ์์ํฌ)
public interface HelloService {
String hello();
}
public class ChineseHelloService implements HelloService {
@Override
public String hello() {
return "Ni Hao";
}
}
@Bean
public HelloService helloService() {
return new ChineseHelloService();
}
// main
ServiceLoader<HelloService> loader = ServiceLoader.load(HelloService.class);
Optional<HelloService> helloServiceOptional = loader.findFirst();
helloServiceOptional.ifPresent(h -> {
System.out.println(h.hello()); // Ni Hao
});
๋จ์
- ์์์ ํ๋ ค๋ฉด public์ด๋ protected ์์ฑ์๊ฐ ํ์ํ๋ ์ ์ ํฉํฐ๋ฆฌ ๋ฉ์๋๋ง ์ ๊ณตํ๋ฉด ํ์ ํด๋์ค๋ฅผ ๋ง๋ค ์ ์๋ค.
- ์ ์ ํฉํฐ๋ฆฌ ๋ฉ์๋๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ฐพ๊ธฐ ์ด๋ ต๋ค.
์๋ฒฝ ๊ณต๋ต
- p9, ์ด๊ฑฐ ํ์ ์ ์ธ์คํดํธ๊ฐ ํ๋๋ง ๋ง๋ค์ด์ง์ ๋ณด์ฅํ๋ค.
- p9, ๊ฐ์ ๊ฐ์ฒด๊ฐ ์์ฃผ ์์ฒญ๋๋ ์ํฉ์ด๋ผ๋ฉด ํ๋ผ์ด์จ์ดํธ ํจํด์ ์ฌ์ฉํ ์ ์๋ค.
- p10, ์๋ฐ 8๋ถํฐ๋ ์ธํฐํ์ด์ค๊ฐ ์ ์ ๋ฉ์๋๋ฅผ ๊ฐ์ง ์ ์๋ค๋ ์ ํ์ด ํ๋ ธ๊ธฐ ๋๋ฌธ์ ์ธ์คํด์คํ ๋ถ๊ฐ ๋๋ฐ ํด๋์ค๋ฅผ ๋ ์ด์ ๊ฐ ๋ณ๋ก ์๋ค.
- p11, ์๋น์ค ์ ๊ณต์ ํ๋ ์์ํฌ๋ฅผ ๋ง๋๋ ๊ทผ๊ฐ์ด ๋๋ค.
- p12, ์๋น์ค ์ ๊ณต์ ์ธํฐํ์ด์ค๊ฐ ์๋ค๋ฉด ๊ฐ ๊ตฌํ์ฒด๋ฅผ ์ธ์คํด์ค๋ก ๋ง๋ค ๋ ๋ฆฌํ๋ ์ ์ ์ฌ์ฉํด์ผ ํ๋ค.
- p12, ๋ธ๋ฆฌ์ง ํจํด
- p12, ์์กด ๊ฐ์ฒด ์ฃผ์ ํ๋ ์์ํฌ
์๋ฒฝ ๊ณต๋ต 1. ์ด๊ฑฐ ํ์
Enumeration
- ์์ ๋ชฉ๋ก์ ๋ด์ ์ ์๋ ๋ฐ์ดํฐ ํ์ .
- ํน์ ํ ๋ณ์๊ฐ ๊ฐ์ง ์ ์๋ ๊ฐ์ ์ ํํ ์ ์๋ค. ํ์ -์ธ์ดํํฐ (Type-Safety)๋ฅผ ๋ณด์ฅํ ์ ์๋ค. ์ฑ๊ธํค ํจํด์ ๊ตฌํํ ๋ ์ฌ์ฉํ๊ธฐ๋ ํ๋ค.
- ์ง๋ฌธ1) ํน์ enum ํ์ ์ด ๊ฐ์ง ์ ์๋ ๋ชจ๋ ๊ฐ์ ์ํํ๋ฉฐ ์ถ๋ ฅํ๋ผ.
Arrays.stream(OrderStatus.values())
.forEach(orderStatus1 -> System.out.println("orderStatus1 = " + orderStatus1));
- ์ง๋ฌธ2) enum์ ์๋ฐ์ ํด๋์ค์ฒ๋ผ ์์ฑ์, ๋ฉ์๋, ํ๋๋ฅผ ๊ฐ์ง ์ ์๋๊ฐ?
public enum OrderStatus {
PREPARING(0), SHIPPED(1), DELIVERING(2), DELIVERED(3);
private int number;
OrderStatus(int number) {
this.number = number;
}
}
- ์ง๋ฌธ3) enum์ ๊ฐ์ == ์ฐ์ฐ์๋ก ๋์ผ์ฑ์ ๋น๊ตํ ์ ์๋๊ฐ?
Order order = new Order();
if (order.orderStatus == OrderStatus.DELIVERED) { // enum
System.out.println("order = " + order);
}
- ์ง๋ฌธ4) enum์ key๋ก ์ฌ์ฉํ๋ Map์ ์ ์ํ์ธ์.
EnumMap<OrderStatus, String> enumMap = new EnumMap(OrderStatus.class);
enumMap.put(OrderStatus.PREPARING, "PRE");
enumMap.put(OrderStatus.DELIVERING, "DEL");
enumMap.put(OrderStatus.SHIPPED, "SHIPP");
enumMap.put(OrderStatus.DELIVERED, "DELIVERED");
for (Map.Entry<OrderStatus, String> orderStatusStringEntry : enumMap.entrySet()) {
System.out.println("orderStatusStringEntry.getKey() = " + orderStatusStringEntry.getKey());
System.out.println("orderStatusStringEntry.getValue() = " + orderStatusStringEntry.getValue());
}
- ์ง๋ฌธ5) enum์ ๋ด๊ณ ์๋ Set์ ๋ง๋ค์ด ๋ณด์ธ์.
EnumSet<OrderStatus> allOfOrderStatuses = EnumSet.allOf(OrderStatus.class);
System.out.println("allOfOrderStatuses = " + allOfOrderStatuses);
EnumSet<OrderStatus> noneOfOrderStatuses = EnumSet.noneOf(OrderStatus.class);
System.out.println("noneOfOrderStatuses = " + noneOfOrderStatuses);
EnumSet<OrderStatus> ofOrderStatuses = EnumSet.of(OrderStatus.SHIPPED, OrderStatus.PREPARING);
System.out.println("ofOrderStatuses = " + ofOrderStatuses);
HashMap vs EnumMap
- HashMap์ key๋ฅผ bucket์ ์ ์ฅํ๊ณ ๊ฐ bucket์ด linked list๋ฅผ ์ฐธ์กฐ ํ๊ณ ์์. (LinkedList์๋ hash(key)๊ฐ ๊ฐ์ element๊ฐ ๋ค์ด๊ฐ)
- EnumMap์ ๊ฒฝ์ฐ key๋ก ์ฌ์ฉํ ๊ฐ์ด ์ ํ๋์ด ์์ผ๋ฏ๋ก, ๊ทธ ๊ฐฏ์๋งํผ ๊ธธ์ด๋ฅผ ๊ฐ์ง array๋ฅผ ์ ์ธํจ. ํด๋น index์ ๊ฐ์ ๋ฃ์ผ๋ฉด ๋จ.
HashSet vs EnumSet
- HashSet์ HashMap๊ณผ ๊ฐ์๋ฐ map์ value๊ฐ ์๋ค ์๋ค๋ฅผ ํํํ๋ ์ง์์ ๊ฐ์ ๊ฐ์ด ๋ค์ด๊ฐ.
- EnumSet์ ๊ฐ์ด ์๋ค ์๋ค๋ง ํ์ํ๋ฉด ๋๋๊น EnumMap์ฒ๋ผ array๋ก ๊ตฌํํ์ง ์๊ณ 10101011 ๊ฐ์ bit vector๋ก ๊ตฌํ์ด ๊ฐ๋ฅ.
์๋ฒฝ ๊ณต๋ต 2. ํ๋ผ์ด์จ์ดํธ ํจํด
Flyweight (๊ฐ๋ฒผ์ด ์ฒด๊ธ)
- ๊ฐ์ฒด๋ฅผ ๊ฐ๋ณ๊ฒ ๋ง๋ค์ด ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ ์ค์ด๋ ํจํด.
- ์์ฃผ ๋ณํ๋ ์์ฑ(๋๋ ์ธ์ ์ธ ์์ฑ, extrinsit)๊ณผ ๋ณํ์ง ์๋ ์์ฑ(๋๋ ๋ด์ ์ธ ์์ฑ, intrinsit)์ ๋ถ๋ฆฌํ๊ณ ์ฌ์ฌ์ฉํ์ฌ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ ์ค์ผ ์ ์๋ค.
์๋ฒฝ ๊ณต๋ต 3. ์ธํฐํ์ด์ค์ ์ ์ ๋ฉ์๋
์๋ฐ 8๊ณผ 9์์ ์ฃผ์ ์ธํฐํ์ด์ค์ ๋ณํ
- ๊ธฐ๋ณธ ๋ฉ์๋ (default method)์ ์ ์ ๋ฉ์๋๋ฅผ ๊ฐ์ง ์ ์๋ค.
- ๊ธฐ๋ณธ ๋ฉ์๋
- ์ธํฐํ์ด์ค์์ ๋ฉ์๋ ์ ์ธ ๋ฟ ์๋๋ผ, ๊ธฐ๋ณธ์ ์ธ ๊ตฌํ์ฒด๊น์ง ์ ๊ณตํ ์ ์๋ค.
- ๊ธฐ์กด์ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ํด๋์ค์ ์๋ก์ด ๊ธฐ๋ฅ์ ์ถ๊ฐํ ์ ์๋ค.
- ์ ์ ๋ฉ์๋
- ์๋ฐ 9๋ถํฐ private static ๋ฉ์๋๋ ๊ฐ์ง ์ ์๋ค.
- ๋จ, private ํ๋๋ ์์ง๋ ์ ์ธํ ์ ์๋ค.
- ์ง๋ฌธ1) ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ Comparator๋ฅผ ๋ง๋ค๊ณ List<Integer>๋ฅผ ์ ๋ ฌํ๋ผ.
List<Integer> numbers = new ArrayList();
numbers.add(10);
numbers.add(100);
numbers.add(20);
numbers.add(44);
numbers.add(3);
Comparator<Integer> desc = (o1, o2) -> o2 - o1;
numbers.sort(desc);
- ์ง๋ฌธ2) ์ง๋ฌธ1์์ ๋ง๋ Comparator๋ฅผ ์ฌ์ฉํด์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ผ.
numbers.sort(desc.reversed());
์๋ฒฝ ๊ณต๋ต 4. ์๋น์ค ์ ๊ณต์ ํ๋ ์์ํฌ
ํ์ฅ ๊ฐ๋ฅํ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ง๋๋ ๋ฐฉ๋ฒ
- ์ฃผ์ ๊ตฌ์ฑ ์์
- ์๋น์ค ์ ๊ณต์ ์ธํฐํ์ด์ค (SPI)์ ์๋น์ค ์ ๊ณต์ (์๋น์ค ๊ตฌํ์ฒด)
- ์๋น์ค ์ ๊ณต์ ๋ฑ๋ก API (์๋น์ค ์ธํฐํ์ด์ค์ ๊ตฌํ์ฒด๋ฅผ ๋ฑ๋กํ๋ ๋ฐฉ๋ฒ)
- ์๋น์ค ์ ๊ทผ API (์๋น์ค์ ํด๋ผ์ด์ธํธ๊ฐ ์๋น์ค ์ธํฐํ์ด์ค์ ์ธ์คํด์ค๋ฅผ ๊ฐ์ ธ์ฌ ๋ ์ฌ์ฉํ๋ API)
- ๋ค์ํ ๋ณํ
- ๋ธ๋ฆฟ์ง ํจํด
- ์์กด ๊ฐ์ฒด ์ฃผ์ ํ๋ ์์ํฌ
์๋ฒฝ ๊ณต๋ต 5. ๋ฆฌํ๋ ์
reflection
- ํด๋์ค๋ก๋๋ฅผ ํตํด ์ฝ์ด์จ ํด๋์ค ์ ๋ณด(๊ฑฐ์ธ์ ๋ฐ์ฌโ๋ ์ ๋ณด)๋ฅผ ์ฌ์ฉํ๋ ๊ธฐ์
- ๋ฆฌํ๋ ์ ์ ์ฌ์ฉํด ํด๋์ค๋ฅผ ์ฝ์ด์ค๊ฑฐ๋, ์ธ์คํด์ค๋ฅผ ๋ง๋ค๊ฑฐ๋, ๋ฉ์๋๋ฅผ ์คํํ๊ฑฐ๋, ํ๋์ ๊ฐ์ ๊ฐ์ ธ์ค๊ฑฐ๋ ๋ณ๊ฒฝํ๋ ๊ฒ์ด ๊ฐ๋ฅํ๋ค.
- ์ธ์ ์ฌ์ฉํ ๊น?
- ํน์ ์ ๋ ธํ ์ด์ ์ด ๋ถ์ด์๋ ํ๋ ๋๋ ๋ฉ์๋ ์ฝ์ด์ค๊ธฐ (JUnit, Spring)
- ํน์ ์ด๋ฆ ํจํด์ ํด๋นํ๋ ๋ฉ์๋ ๋ชฉ๋ก ๊ฐ์ ธ์ ํธ์ถํ๊ธฐ (getter, setter)
Uploaded by N2T