DAY 20

🔖 오늘 읽은 범위 : 10. 클래스 (172~185p)

---

🤓 책에서 기억하고 싶은 내용

클래스 체계

• 신문 기사처럼 읽히는 순차적 추상화 단계

1. public static variable
2. private static variable
3. private instance variable
4. public instance variable ( 거의 쓰지 않음 )
5. public function
6. private function

캡슐화

• 변수나 유틸리티 함수를 protected로 선언해 테스트 코드에 접근 허용해도된다
• 하지만 그 전에 비공개 상태를 유지할 방법을 최대한 강구
• 캡슐화를 해제하는 결정은 최후의 수단

클래스는 작아야 한다!

• 얼마나?: 책임의 개수
• 클래스 이름은 해당 클래스 책임을 기술해야 한다
• 작명이 클래스 크기를 줄이는 첫 번째 관문
• 간결한 이름이 떠오르지 않는다 → 클래스 크기가 너무 크기 때문
• 클래스 설명은 if, and, or, but 을 사용하지 않고 25단어 내외로 기술해야함

단일 책임 원칙(SRP)

• 클래스나 모듈을 변경할 이유가 단 하나뿐이어야 한다

public class SuperDashboard extends JFrame implements MetaDataUser public Component getLastFocusedComponent() {
    public void setLastFocused(Component lastFocused)
    public int getMajorVersionNumber()
    public int getMinorVersionNumber()
    public int getBuildNumber()
}

메서드가 5개뿐이지만 책임이 큰 SuperDashboard 를 변경

1. getMajorVersion? → 버전 정보는 소프트웨어 출시때마다 달라진다
2. 스윙 코드를 변경할 때마다 버전 번호가 달라진다?

• 버전 정보를 다루를 메서드를 분리하면 재사용하기 쉬움

  public class Version {
      public int getMajorVersionNumber()
      public int getMinorVersionNumber()
      public int getBuildNumber()
  }

• 실무에서는 자잘한 단일 책임 클래스가 많아지면 큰 그림을 이해하기 어려워 진다고 우려
• 작은 서랍을 많이 두고 기능과 이름이 명확한 컴포넌트를 나눠넣기 vs 큰 서랍 몇 개에 때려넣기

응집도

• 클래스의 인스턴스 변수 수는 작아야한다
• 클래스 메서드는 인스턴스 변수를 하나 이상 사용해야 한다
• 메서드가 인스턴스 변수를 더 많이 사용할 수록 메서드와 클래스의 응집도가 높다
• 함수를 작게, 매개변수 목록을 짧게 전략을 따르다 보면 일부 메서드만 사용하는 인스턴스 변수가 많아짐 → 응집도가 높아지도록 새로운 클래스로 분리

응집도를 유지하면 작은 클래스 여럿이 나온다

• 큰 함수를 작은 함수 여럿으로 나누기만 해도 클래스 수가 많아진다
  1. 함수를 여러개로 쪼개려다 보니 여러개 인수가 중복 필요
  2. 필요한 변수를 클래스 인스턴스 변수로 승격하면 함수는 인수가 필요 없다
  3. 함수 쪼개기 쉬워짐
  4. 응집도가 낮아짐?
  5. 클래스 분리!

package literatePrimes;
public class PrintPrimes {
    public static void main(String[] args) {
        final int M = 1000;
        final int RR = 50;
        final int CC = 4;
        final int WW = 10;
        final int ORDMAX = 30;
        int P[] = new int[M + 1];
        int PAGENUMBER;
        int PAGEOFFSET;
        int ROWOFFSET;
        int C;
        int J;
        int K;
        boolean JPRIME;
        int ORD;
        int SQUARE;
        int N;
        int MULT[] = new int[ORDMAX + 1];
        J = 1;
        K = 1;
        P[1] = 2;
        ORD = 2;
        SQUARE = 9;
        while (K < M) {
            do {
                J = J + 2;
                if (J == SQUARE) {
                    ORD = ORD + 1;
                    SQUARE = P[ORD] * P[ORD];
                    MULT[ORD - 1] = J;
                }
                N = 2;
                JPRIME = true;
                while (N < ORD && JPRIME) {
                    while (MULT[N] < J)
                        MULT[N] = MULT[N] + P[N] + P[N];
                    if (MULT[N] == J) JPRIME = false;
                    N = N + 1;
                }
            } while (!JPRIME);
            K = K + 1;
            P[K] = J;
        } {
            PAGENUMBER = 1;
            PAGEOFFSET = 1;
            while (PAGEOFFSET <= M) {
                System.out.println("The First " + M +
                    " Prime Numbers --- Page " + PAGENUMBER);
                System.out.println("");
                for (ROWOFFSET = PAGEOFFSET; ROWOFFSET < PAGEOFFSET + RR; ROWOFFSET++) {
                    for (C = 0; C < CC; C++)
                        if (ROWOFFSET + C * RR <= M)
                            System.out.format("%10d", P[ROWOFFSET + C * RR]);
                    System.out.println("");
                }
                System.out.println("\f");
                PAGENUMBER = PAGENUMBER + 1;
                PAGEOFFSET = PAGEOFFSET + RR * CC;
            }
        }
    }
}

• Refactoring결과

// PrimePrinter.java
package literatePrimes;
public class PrimePrinter {
    public static void main(String[] args) {
        final int NUMBER_OF_PRIMES = 1000;
        int[] primes = PrimeGenerator.generate(NUMBER_OF_PRIMES);
        final int ROWS_PER_PAGE = 50;
        final int COLUMNS_PER_PAGE = 4;
        RowColumnPagePrinter tablePrinter =
            new RowColumnPagePrinter(ROWS_PER_PAGE, COLUMNS_PER_PAGE,
                "The First " + NUMBER_OF_PRIMES + " Prime Numbers");
        tablePrinter.print(primes);
    }
}

// RowColumnPagePrinter.java
package literatePrimes;
import java.io.PrintStream;
public class RowColumnPagePrinter {
    private int rowsPerPage;
    private int columnsPerPage;
    private int numbersPerPage;
    private String pageHeader;
    private PrintStream printStream;
    public RowColumnPagePrinter(int rowsPerPage, int columnsPerPage,
        String pageHeader) {
        this.rowsPerPage = rowsPerPage;
        this.columnsPerPage = columnsPerPage;
        this.pageHeader = pageHeader;
        numbersPerPage = rowsPerPage * columnsPerPage;
        printStream = System.out;
    }
    public void print(int data[]) {
        int pageNumber = 1;
        for (int firstIndexOnPage = 0; firstIndexOnPage < data.length; firstIndexOnPage += numbersPerPage) {
            int lastIndexOnPage =
                Math.min(firstIndexOnPage + numbersPerPage - 1, data.length - 1);
            printPageHeader(pageHeader, pageNumber);
            printPage(firstIndexOnPage, lastIndexOnPage, data);
            printStream.println("\f");
            pageNumber++;
        }
    }
    private void printPage(int firstIndexOnPage, int lastIndexOnPage,
        int[] data) {
        int firstIndexOfLastRowOnPage =
            firstIndexOnPage + rowsPerPage - 1;
        for (int firstIndexInRow = firstIndexOnPage; firstIndexInRow <= firstIndexOfLastRowOnPage; firstIndexInRow++) {
            printRow(firstIndexInRow, lastIndexOnPage, data);
            printStream.println("");
        }
    }
    private void printRow(int firstIndexInRow, int lastIndexOnPage,
        int[] data) {
        for (int column = 0; column < columnsPerPage; column++) {
            int index = firstIndexInRow + column * rowsPerPage;
            if (index <= lastIndexOnPage) printStream.format("%10d", data[index]);
        }
    }
    private void printPageHeader(String pageHeader, int pageNumber) {
        printStream.println(pageHeader + " --- Page " + pageNumber);
        printStream.println("");
    }
    public void setOutput(PrintStream printStream) {
        this.printStream = printStream;
    }
}

// PrimeGenerator.java
package literatePrimes;
import java.util.ArrayList;
public class PrimeGenerator {
    private static int[] primes;
    private static ArrayList < Integer > multiplesOfPrimeFactors;
    protected static int[] generate(int n) {
        primes = new int[n];
        multiplesOfPrimeFactors = new ArrayList < Integer > ();
        set2AsFirstPrime();
        checkOddNumbersForSubsequentPrimes();
        return primes;
    }
    private static void set2AsFirstPrime() {
        primes[0] = 2;
        multiplesOfPrimeFactors.add(2);
    }
    private static void checkOddNumbersForSubsequentPrimes() {
        int primeIndex = 1;
        for (int candidate = 3; primeIndex < primes.length; candidate += 2) {
            if (isPrime(candidate)) primes[primeIndex++] = candidate;
        }
    }
    private static boolean isPrime(int candidate) {
        if (isLeastRelevantMultipleOfNextLargerPrimeFactor(candidate)) {
            multiplesOfPrimeFactors.add(candidate);
            return false;
        }
        return isNotMultipleOfAnyPreviousPrimeFactor(candidate);
    }
    private static boolean isLeastRelevantMultipleOfNextLargerPrimeFactor(int candidate) {
        int nextLargerPrimeFactor = primes[multiplesOfPrimeFactors.size()];
        int leastRelevantMultiple = nextLargerPrimeFactor * nextLargerPrimeFactor;
        return candidate == leastRelevantMultiple;
    }
    private static boolean isNotMultipleOfAnyPreviousPrimeFactor(int candidate) {
        for (int n = 1; n < multiplesOfPrimeFactors.size(); n++) {
            if (isMultipleOfNthPrimeFactor(candidate, n))
                return false;
        }
        return true;
    }
    private static boolean isMultipleOfNthPrimeFactor(int candidate, int n) {
        return
        candidate == smallestOddNthMultipleNotLessThanCandidate(candidate, n);
    }
    private static int
    smallestOddNthMultipleNotLessThanCandidate(int candidate, int n) {
        int multiple = multiplesOfPrimeFactors.get(n);
        while (multiple < candidate)
            multiple += 2 * primes[n];
        multiplesOfPrimeFactors.set(n, multiple);
        return multiple;
    }
}

🤔 떠오르는 생각

• 실생활에서도 정리를 잘 못하는 편인데 그래서 내가 클래스 사용/관리가 어려웠나보다
• 굳이 자바가 아니어도 오픈소스 레포들을 선정하여 책의 원칙대로 클래스 분리를 수행해보자

🔎 질문

📝 소감 3줄 요약

• 클래스 책임의 개수는 작아야 한다 → 간결한 25단어 내외
• 작은 서랍을 많이 두고 기능과 이름이 명확한 컴포넌트를 나눠넣기
• 클래스를 분리하여 응집도를 높여라