Merge branch 'depromeet:main' into main

Ch04/item19/상속을 고려해 설계하고 문서화 하라, 그러지 않았다면 상속을 금지하라.md

@@ -0,0 +1,63 @@
+# item19.상속을 고려해 설계하고 문서화 하라, 그러지 않았다면 상속을 금지하라
+
+### 상속을 고려한 설계와 문서화
+상속용 클래스는 
+- 재정의 할 수 있는 메서드들을 내부적으로 어떻게 이용하는지(자기사용) 문서로 남겨야 한다.
+
+- 재정의 가능 = public 과 protected 메서드 중 final 이 아닌 모든 메서드
+### Implementation Requirements
+API 문서의 메서드 설명 끝에서 Implementation Requirements 로 시작하는 절을 종종 볼 수 있다.
+
+- 메서드의 내부 동작 방식을 설명하는 곳
+- @implSpec 태그 → javadoc 도구가 생성해줌
+- 클래스를 안전하게 상속할 수 있도록 내부 구현 방식을 설명해야 한다.
+
+### protected 로 노출할 메서드의 결정
+- 수는 가능한 적어야 한다.
+- 3개 정도 실제 하위 클래스를 만들어 보는 것이 유일하다.
+- 제 3 자의 작성으로도 검증해야 한다.
+- 꼭 필요한 protected 멤버를 놓쳤다면 하위 클래스를 작성할 때 그 빈자리가 확연히 드러난다.
+- 하위 클래스를 여러 개 만들 때까지 전혀 쓰이지 않는 protected 멤버는 private 이어야 할 가능성이 크다.
+- 너무 적게 노출해서 상속으로 얻는 이점마저 없애지 않도록 주의 한다
+
+### 상속용 클래스의 생성자는 직/간접적으로 재정의 가능메서드를 호출하면 안된다.
+private, final, static 메서드는 재정의가 불가능하니 생성자에서 안심하고 호출해도 된다.
+
+- 상위 클래스의 생성자가 하위 클래스의 생성자보다 먼저 실행된다.
+- 하위 클래스에서 재정의한 메서드가, 하위 클래스의 생성자에서 초기화 하는 값에 의존 → 오동작
+```java
+
+public class Super {
+// 잘못된 예 - 생성자가 재정의 가능 메서드를 호출함.
+public Super() {
+overrideMe();
+}
+public void overrideMe() { }
+}
+
+public final class Sub extends Super {
+// 초기화 되지 않은 final 필드, 생성자에서 초기화 한다.
+private final Instant instant;
+
+    Sub() {
+        instant = Instant.now();
+    }
+    // 재정의 가능 메서드, 상위 클래스의 생성자가 호출한다.    
+    @Override public void overrideMe() {
+        System.out.println(instant);    // null 출력   
+    }
+
+    public static void main(String[] args) {
+        Sub sub = new Sub();
+        sub.overrideMe();   
+    }
+}
+```
+System.out.println(instant); 이 실행 될 때, NullPointerException 이 발생 하지만 println 이 null 입력도 받아 들이기 때문에 에러를 던지지 않았다.
+
+### 상속을 금지하는 방법
+1. final 클래스 선언
+2. 모든 생성자를 private 이나 package-private 으로 선언, public 정적 팩터리
+3. 래퍼 클래스 패턴
+
+Set, List, Map 같이 핵심기능을 정의한 인터페이스가 있고, 클래스가 그 인터페이스를 구현했다면 상속을 금지해도 개발하는 데 아무런 어려움이 없을 것이다.

Ch04/item23/태그_달린_클래스보다는_클래스_계층구조를_활용하라.md

@@ -0,0 +1,101 @@
+### ☁️ 태그 달린 클래스
+태그 달린 클래스란, **하나의 클래스가 두 가지 이상의 의미를 표현** 가능할 때, 그중 현재 표현하는 의미를 태그 값으로 알려주는 클래스이다. 아래 예시를 보자.
+
+
+```java
+class Figure {
+    enum Shape { RECTANGLE, CIRCLE };  // TAG 
+
+    // 태그 필드 - 현재 모양을 나타낸다.
+    final Shape shape;
+
+    // 다음 필드들은 모양이 사각형(RECTANGLE)일 때만 쓰인다.
+    double length;
+    double width;
+
+    // 다음 필드는 모양이 원(CIRCLE)일 때만 쓰인다.
+    double radius;
+
+    // 원용 생성자
+    Figure(double radius) {
+        shape = Shape.CIRCLE;
+        this.radius = radius;
+    }
+
+    // 사각형용 생성자
+    Figure(double length, double width) {
+        shape = Shape.RECTANGLE;
+        this.length = length;
+        this.width = width;
+    }
+
+    double area() {
+        switch(shape) {
+            case RECTANGLE:
+                return length * width;
+            case CIRCLE:
+                return Math.PI * (radius * radius);
+            default:
+                throw new AssertionError(shape);
+        }
+    }
+}
+```
+
+####  태그 달린 클래스 단점
+
+1. 열거 타입 선언, 태그 필드, `switch` 문 등 쓸데없는 코드로 가독성이 떨어진다.
+2. 다른 의미를 위한 코드도 해당하지 않는데 항상 존재하니 메모리를 많이 먹는다.
+3. 필드들을 불변을 위해 `final` 로 선언하려면 해당 의미에 쓰이지 않는 필드들까지 생성자에서 초기화해야한다.
+4. 또 다른 의미를 추가하려면 `switch` 문 코드를 수정해야 한다.
+5. 인스턴스의 타입만으로는 현재 나타내는 의미를 알 길이 전혀 없다.
+
+> 즉, 태그 달린 클래스는 장황하고, 오류를 내기 쉽고, 비효율적이다.
+
+### ☁️ 클래스 계층 구조
+이러한 문제를, 클래스 계층구조를 활용하는 서브타이핑 (subtyping)을 통해 해결할 수 있다. 클래스 계층 구조는, **추상 클래스와 추상 메서드**를 통해 **타입 하나로 다양한 의미의 객체를 표현**할 수 있게 해준다. 
+
+
+1.  계층 구조의 루트가 될 추상 클래스 정의한다.
+```java
+abstract class Figure {
+    abstract double area();
+}
+```
++ 태그 값에 따라 **동작이 달라지는 메서드**들을 루트 클래스의 **추상 메서드**로 선언
++ 태그 값에 상관없이 **동작이 일정한 메서드와 공통 메서드**들을 루트 클래스에 **일반 메서드**로 선언
+
+
+2. 루트 클래스를 확장한 구체 클래스를 의미별로 하나씩 지정한다.
+
+```java
+class Circle extends Figure {
+    final double radius;
+
+    Circle(double radius) { this.radius = radius; }
+
+    @Override double area() { return Math.PI * (radius * radius); }
+}
+```
+
+```java
+class Rectangle extends Figure {
+    final double length;
+    final double width;
+
+    Rectangle(double length, double width) {
+        this.length = length;
+        this.width  = width;
+    }
+    @Override double area() { return length * width; }
+}
+```
++ 루트 클래스가 정의한 추상 메서드를 각자 의미에 맞게 구현
+
+#### 클래스 계층 구조 장점
+
+1. 각 의미를 독립된 클래스에 담아 관련 없던 데이터 필드들을 제거했다.
+2. 남아 있는 필드들은 모두 `final` 로 선언해 불변을 보장할 수 있다.
+3. 각 클래스의 생성자가 모든 필드를 남김없이 초기화하고 추상 메서드를 모두 구현했는지 컴파일러 단에서 확인할 수 있다.
+3. 루트 클래스의 코드를 건드리지 않고 독립적으로 계층 구조를 확장할 수 있다.
+

Ch04/item24/멤버 클래스는 되도록 static 클래스로 만들라.md

@@ -0,0 +1,160 @@
+# item24.멤버 클래스는 되도록 static 클래스로 만들라
+
+### 중첩 클래스 (Nested Class) : 자신을 둘러싼 바깥 클래스에서만 쓰이는 클래스
+- 정적 멤버 클래스 (static member class)
+- 비정적 멤버 클래스
+- 익명 클래스
+- 지역 클래스
+
+### 정적 멤버 클래스
+- 클래스 내부의 static 클래스
+> 바깥 클래스의 private 멤버에도 바로 접근 가능. 이외에는 일반 클래스와 같다.
+
+
+- private 정적 멤버 클래스 : 바깥 클래스의 구성 요소를 나타낼 때
+```java
+public class Person {
+    private String firstName;
+    private String lastName;
+
+    private static class Computer { // private, public
+        private String name;
+        private int price;
+
+        public Computer(String name, int price) {
+            this.name = name;
+            this.price = price;
+        }
+
+        public int getPrice() {
+            return price;
+        }
+    }
+}
+```
+
+- public 정적 멤버 클래스 : 바깥 클래스와 함께 쓰일 때만 유용한 public 도우미 클래스
+```java
+public class Calculator {
+    public enum Operation1 {
+        PLUS(Integer::sum),
+        MINUS((x, y) -> x - y);
+
+        private BiFunction<Integer, Integer, Integer> calculate;
+
+        Operation1(BiFunction<Integer, Integer, Integer> calculate) {
+            this.calculate = calculate;
+        }
+
+        public BiFunction<Integer, Integer, Integer> getFunction() {
+            return calculate;
+        }
+    }
+
+
+    public int Sum(int x, int y) {
+        return Operation1.PLUS.getFunction().apply(x, y);
+    }
+}
+```
+
+```java
+public static void main(String[] args) {
+       Calculator c = new Calculator();
+       System.out.println(c.Sum(1, 2)); // 3
+
+       System.out.println(Calculator.Operation1.PLUS); // PLUS
+   }
+```
+
+<br>
+<br>
+
+### 비정적 멤버 클래스
+- 비정적 멤버 클래스의 인스턴스는 바깥 클래스의 인스턴스와 암묵적으로 연결
+- 따라서, 비정적 멤버 클래스의 인스턴스 메서드에서 정규화된 this 를 사용하여 바깥 인스턴스의 참조를 가져올 수 있음.
+> 정규화된 this == 클래스명.this
+
+- 비 정적 멤버 클래스는 인스턴스를 감싸서 마치 다른 클래스처럼 보이게 하는 뷰인 어댑터에서 주로 쓰인다.
+```java
+public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable {
+    // View class support
+    class Values extends AbstractCollection<V> {
+        public Iterator<V> iterator() {
+            return new ValueIterator(getFirstEntry());
+        }
+
+        public int size() {
+            return TreeMap.this.size();
+        }
+
+        public boolean contains(Object o) {
+            return TreeMap.this.containsValue(o);
+        }
+
+        public boolean remove(Object o) {
+            for (Entry<K,V> e = getFirstEntry(); e != null; e = successor(e)) {
+                if (valEquals(e.getValue(), o)) {
+                    deleteEntry(e);
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void clear() {
+            TreeMap.this.clear();
+        }
+
+        public Spliterator<V> spliterator() {
+            return new ValueSpliterator<>(TreeMap.this, null, null, 0, -1, 0);
+        }
+    }    
+
+
+    class EntrySet extends AbstractSet<Map.Entry<K,V>> {
+        public Iterator<Map.Entry<K,V>> iterator() {
+            return new EntryIterator(getFirstEntry());
+        }
+
+        public boolean contains(Object o) {
+            if (!(o instanceof Map.Entry))
+                return false;
+            Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
+            Object value = entry.getValue();
+            Entry<K,V> p = getEntry(entry.getKey());
+            return p != null && valEquals(p.getValue(), value);
+        }
+
+        public boolean remove(Object o) {
+            if (!(o instanceof Map.Entry))
+                return false;
+            Map.Entry<?,?> entry = (Map.Entry<?,?>) o;
+            Object value = entry.getValue();
+            Entry<K,V> p = getEntry(entry.getKey());
+            if (p != null && valEquals(p.getValue(), value)) {
+                deleteEntry(p);
+                return true;
+            }
+            return false;
+        }
+    }
+}
+```
+- TreeMap.this, getFirstEntry() 는 바깥 클래스의 인스턴스가 있어야 쓸 수 있다.
+- 따라서 비정적 멤버 클래스의 인스턴스안에 관계정보가 저장되어 메모리 공간을 차지하고, 생성 시간도 더 걸린다.
+- 또한 바깥 클래스의 인스턴스를 GC 가 회수하지 못한다.
+```java
+    public Set<Map.Entry<K,V>> entrySet() {
+        EntrySet es = entrySet;
+        return (es != null) ? es : (entrySet = new EntrySet());
+    }
+```
+위의 코드에서 비정적 멤버 클래스 EntrySet의 객체를 생성한다. 암묵적으로 바깥 클래스와 멤버 클래스간의 연결되는 관계가 비정적 멤버 클래스의 인스턴스 안에 만들어지고,  
+Map 객체가 사용하는 곳이 없더라도 이 관계때문에 GC 가 일어나지 못한다.
+
+<br>
+
+### 결론
+- 개념상 중첩 클래스의 인스턴스가 바깥 인스턴스와 독립적으로 존재할 수 있다면, 정적 멤버 클래스로 만들어야 한다.
+- 멤버 클래스에서 바깥 인스턴스에 접근할 일이 없다면 무조건 static 을 붙여서 정적 멤버 클래스로 만들자.