Merge pull request #267 from SujinEmilyCho/sujin

[#2][2기] 생성자에 매개변수가 많다면 빌더를 고려하라

2장/2_생성자에 매개변수가 많다면 빌더를 고려하라_조수진.md

@@ -0,0 +1,318 @@
+# 아이템2. 생성자에 매개변수가 많다면 빌더를 고려하라
+정적 팩터리와 생성자는 선택적 매개변수가 많을 때 대응하기 어렵다. 이런 케이스에 `점층적 생성자 패턴`, `자바 빈즈 패턴`, `빌더 패턴`을 고려해볼 수 있다.
+
+### 점층적 생성자 패턴(telescoping constructor pattern)
+
+- 필수 매개변수만 받는 생성자, 필수 매개변수와 선택 매개변수 1개를 받는 생성자, 선택 매개변수를 2개까지 받는 생성자, ..., 선택 매개변수를 전부 받는 생성자까지 늘려가는 방식
+- 확장하기 어렵다
+- 매개변수가 많아지면 클라이언트 코드를 작성하거나 읽기 어렵다
+
+```java
+public class NutritionFacts {
+	private final int servingSize;  // 필수
+	private final int servings;     // 필수
+	private final int calories;     // 선택
+	private final int fat;          // 선택
+	private final int sodium;       // 선택
+	private final int carbohydrate; // 선택
+
+	public NutritionFacts(int servingSize, int servings) {
+		this(servingSize, servings, 0);
+	}
+
+	public NutritionFacts(int servingSize, int servings, int calories) {
+		this(servingSize, servings, calories, 0);
+	}
+
+	public NutritionFacts(int servingSize, int servings, int calories, int fat) {
+		this(servingSize, servings, calories, fat, 0);
+	}
+
+	public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
+		this(servingSize, servings, calories, fat, 0);
+	}
+
+		public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium, int carbohydrate) {
+		this.servingSize = servingSize;
+		this.servings = servings;
+		this.calories = calories;
+		this.fat = fat;
+		this.sodium = sodium;
+		this.carbohydrate = carbohydrate;
+	}
+}
+```
+
+```java
+// 지방(fat)에 0을 작성한 것 처럼 설정하길 원치 않는 매개변수까지 값을 지정해줘야한다.
+NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
+```
+
+### 자바 빈즈 패턴(JavaBeans pattern)
+
+- 매개변수가 없는 생성자로 객체를 만든 후, 세터(setter) 메서드를 호출해 원하는 매개변수의 값을 설정하는 방식
+- 인스턴스를 만들기 쉽고 가독성이 좋아진다
+- 객체를 하나 만들기 위해 메서드를 여러 개 호출해야 하고, 객체가 완전히 생성되기 전까지는 일관성(consistency)이 무너진 상태에 놓인다(생성자를 통한 유효성 검사라는 장치가 사라짐)
+- 불변으로 만들 수 없으며 스레드 안정성을 위한 추가 작업이 필요하다
+
+```java
+public class NutritionFacts {
+	private int servingSize = -1;  // 필수
+	private int servings = -1;     // 필수
+	private int calories = 0;
+	private int fat = 0;
+	private int sodium = 0;
+	private int carbohydrate = 0;
+
+	public NutritionFacts() {}
+
+	public void setServingSize(int val) { servingSize = val; }
+	public void setServings(int val) { servings = val; }
+	public void setCalories(int val) { calories = val; }
+	public void setFat(int val) { fat = val; }
+	public void setSodium(int val) { sodium = val; }
+	public void setCarbohydrate(int val) {carbohydrate = val; }
+}
+```
+
+```java
+// 점층적 생성자 패턴에 비해 확장하기 쉽고, 인스턴스를 만들기 쉽고, 가독성이 좋아진다.
+NutritinFacts cocaCola = new NutritionFacts();
+cocaCola.setServingSize(240);
+cocaCola.setServings(8);
+cocaCola.setCalories(100);
+cocaCola.setSodium(35);
+cocaCola.setCarbohydrate(27);
+```
+
+### 빌더 패턴
+
+- 필수 매개변수와 생성자(혹은 정적 팩터리)를 통해 객체 생성을 위한 빌더 객체를 얻고, 빌더 객체가 제공하는 일종의 세터 메서드들로 원하는 선택 매개변수를 설정. 마지막으로 build 메서드를 호출해 (보통은 불변인) 타겟 객체를 얻는 방식
+- 빌더의 세터 메서드들은 빌더 자신을 반환하기 때문에 메서드 연쇄(method chaining)가 가능하다(플루언트 API라고도 한다)
+- 점층적 생성자 패턴의 안정성(유효성 검사)과 자바 빈즈 패턴의 가독성이라는 장점을 가진다
+- 빌더 하나로 여러 객체를 순회하며 만들 수 있고, 매개변수에 따라 다른 객체를 만드는 등 유연하게 사용 가능
+- 객체를 만들기 위해 빌더부터 만들어야하기 떄문에 성능에 민감한 상황에서 문제가 될 수 있다
+- 점층적 생성자 패턴보다 코드가 장황해서 매개변수가 4개 이상일 때 유용하
+
+```java
+public class NutritionFacts {
+	private final int servingSize;
+	private final int servings;
+	private final int calories;
+	private final int fat;
+	private final int sodium;
+	private final int carbohydrate;
+
+	public static class Builder {
+		private final int servingSize;  // 필수
+		private final int servings;     // 필수
+		private int calories = 0;
+		private int fat = 0;
+		private int sodium = 0;
+		private int carbohydrate = 0;
+
+		public Builder(int servingSize, int servings) {
+			this,servingSize = serginsSize;
+			this.servings = servings;
+		}
+
+		public Builder fat(int val) {
+			fat = val;
+			return this;
+		}
+
+		public Builder sodium(int val) {
+			sodium = val;
+			return this;
+		}
+
+		public Builder carbohydrate(int val) {
+			carbohydrate = val;
+			return this;
+		}
+
+		public NutritionFacts build() {
+			return new NutritionFacts(this);
+		}
+	}
+
+	private NutirionFacts(Builder builder) {
+		servingSize = builder.servingSize;
+		servings = builder.servings;
+		calories = builder.calories;
+		fat = builder.fat;
+		sodium = builder.fat;
+		carbohydrate = builder.carbohydrate;
+	}
+}
+```
+
+```java
+NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
+	.calories(100)
+	.sodium(35)
+	.carbohydrate(27)
+	.build();
+```
+
+불변(immutable) vs  불변식(invariant)
+- 불변: 어떠한 변경도 허용하지 않는다는 뜻, 주로 변경을 허용하는 가변 객체와 구분하는 용도로 쓰인다. String이 대표적인 불변 객체
+- 불변식: 프로그램이 실행되는 동안, 혹은 정해진 기간 동안 반드시 만족해야 하는 조건. 변경을 허용할 수는 있으나 주어진 조건 내에서만 허용한다는 뜻. 예를 들어, 리스트의 크기는 반드시 0 이상이어야 하니, 한 순간이라도 음수 값이 된다면 불변식이 깨진 것
+
+### 빌더 패턴 - 계층적 빌더
+
+- 빌더 패턴은 계층적으로 설계된 클래스와 함께 쓰기 좋다
+- 추상 클래스에는 추상 빌더를, 구체 클래스에는 구체 빌더를 작성
+- 하위 클래스의 build 메서드는 구체 하위 클래스를 반환하도록 선언(공변 반환 타이핑 - covariant return typing)
+- 생성자와 달리 가변 인수 매개변수를 여러 개 사용하는 것이 가능하다(addTopping 메서드)
+
+```java
+public abstract class Pizza {
+	public enum Topping { HAM, MUSHROOM, ONION, PEPPER, SAUSAGE }
+	final Set<Topping> toppings;
+
+	abstract static class Builder<T extends Builder<T>> {
+		EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);
+		public T addTopping(Topping topping) {
+			toppings.add(Objects.requireNonNull(topping));
+			return self();
+		}
+
+		abstarct Pizza build();
+
+		protected abstract T self(); // 하위 클래스에서 이 메서드를 오버라이드 해서 this를 반환
+	}
+
+	Pizza(Builder<?> builder) {
+		toppings = builder.toppings.clone();
+	}
+}
+```
+
+```java
+public class NyPizza extends Pizza {
+	public enum Size { SMALL, MEDIUM, LARGE }
+	private final Size size;
+
+	public static class Builder extends Pizza.Builder<Builder> {
+		private final Size size;
+
+		public Builder(Size size) {
+			this.size = Objects.requireNonNull(size);
+		}
+
+		@Override
+		public NyPizza build() {
+			return new NyPizza(this);
+		}
+
+		@Override
+		protected Builder self() {
+			return this;		
+		}
+
+		public NyPizza(Builder builder) {
+			super(builder);
+			size = builder.size;
+		}
+	}
+}
+```
+
+```java
+public class Calzone extends Pizza {
+	private final boolean sauceInside;
+
+	public static class Builder extends Pizza.Builder<Builder> {
+		private boolean sauceInsice = false;
+
+		public Builder sauceInside() {
+			sauceInsdie = true;
+			return this;
+		}
+
+		@Override
+		public Calzone build() {
+			return new Calzone(this);
+		}
+
+		@Override
+		protected Builder self() {
+			return this;
+		}
+
+		private Calzone(Builder builder) {
+			super(builder);
+			sauceInside = builder.sauceInside;
+		}
+	}
+}
+```
+
+```java
+NyPizza pizza = new NyPizza.Builder(SMALL)
+	.addTopping(SAUSAGE)
+	.addTopping(ONION)
+	.build();
+
+Calzone pizza = new Calzone.Builder()
+	.addTopping(HAM)
+	.sauceInside()
+	.build();
+```
+
+### 추가 예시
+
+```java
+public class User {
+    private final int id;  // 필수
+    private final String name; //필수
+    private final Set<String> nicknames;
+    private final int phone;
+    private final String address;
+
+    private User(Builder builder) {
+        this.id = builder.id;
+        this.name = builder.name;
+        this.nicknames = builder.nicknames;
+        this.phone = builder.phone;
+        this.address = builder.address;
+    }
+
+    public static class Builder {
+        private final int id;  // 필수
+        private final String name; //필수
+        private final Set<String> nicknames = new HashSet<>();
+        private int phone;
+        private String address;
+
+        public Builder(int id, String name) {
+            this.id = id;
+            this.name = name;
+        }
+
+        public Builder nickname(String nickname) {
+            this.nicknames.add(nickname);
+            return this;
+        }
+
+        public Builder phone(int phone) {
+            this.phone = phone;
+            return this;
+        }
+
+        public Builder address(String address) {
+            this.address = address;
+            return this;
+        }
+
+        public User build() {
+            return new User(this);
+        }
+    }
+}
+```
+
+### 정리
+
+생성자나 정적 팩터리가 처리해야 할 매개변수가 많다면 빌더 패턴을 선택하는 게 더 낫다. 매개변수 중 다수가 필수가 아니거나 같은 타입이면 특히 더 그렇다. 빌더는 점층적 생성자보다 클라이언트 코드를 읽고 쓰기가 훨씬 간결하고, 자바빈즈보다 훨씬 안전하다.