01. 단일 책임 원칙 (Single Responsibility Principle)

단일 책임 원칙 (Single Responsibility Principle)

객체는 단 한개의 책임만을 가져야 한다.

Mission. 한수

Procedure-Oriendted Code

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

class Main {

  public static void main(String[] args) throws IOException {

    //입력
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    final int N = Integer.parseInt(br.readLine());
    int[] c = new int[3];
    int count = N;

    //한수갯수구하기
    for (int i = 1; i <= N; i++) {
      String s = String.valueOf(i);

      if (s.length() >= 3) {
        c[0] = s.charAt(0) - s.charAt(1);

        //한수가 아니라면 카운트 빼주기
        for (int j = 1; j <= s.length() - 2; j++) {
          if (c[0] != s.charAt(j) -s.charAt(j + 1)) {
            count--;
            break;
          }
        }
      }
    }

    //출력
    System.out.println(count);
  }
}

위의 코드는 절차지향적인 코드입니다.

위의 코드는 길이가 짧아 흐름을 파악하는데 어려움이 없겠지만,

대형 프로젝트라고 생각해보면 상당히 까다로울 것입니다.

객체의 책임 분배하기

한 객체가 어떤 기능을 제공한다면, 이는 책임이 있다는 것을 의미합니다.

단일 책임 원칙이란 한 객체는 하나의 책임을 가져야 한다는 것인데요.

위 Main 클래스에는 이러한 책임이 있습니다.

1. 흐름제어 (Main Method)
2. 숫자 N 입력
3. 1~N 의 한수 갯수 구하기
4. 한수갯수 출력

책임에 따라 클래스를 나누면 다음과 같습니다.

class Main{}
class Input{}
class Hansoo{}
class Print{}

이 클래스 구현해보았습니다. 코드가 길어 대충 훑어보시면 될 것 같습니다.

Object-Oriendted Code

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


class Main {

  public static void main(String[] args) throws IOException {

    Input input =  new Input();
    Hansoo hansoo = new Hansoo(input.getN());
    Print print = new Print(hansoo.getCountHansoo());

  }
}


class Input{
  //Field
  private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  private final int N;

  //Constructor
  Input() throws IOException{
    N = Integer.parseInt(br.readLine());
  }

  public int getN() {
    return N;
  }

}


class Hansoo{

  //Field
  private int N;
  private int countHansoo;

  //getter
  public int getCountHansoo() {
    return countHansoo;
  }

  //Constructor
  Hansoo(int N){
    this.N = N;
    this.countHansoo = N;
    countHansoo();
  }

  public void countHansoo() {
    for (int i = 1; i <= N; i++) {
      if(!isHansoo(i)) countHansoo--;
      }
    }

  public boolean isHansoo(int n) {
    String s = String.valueOf(n);
    if (s.length() >= 3) {
      int firstMinusValue = s.charAt(0) - s.charAt(1);

      for (int j = 1; j <= s.length() - 2; j++) {
        if (!isEqualMinusValue(firstMinusValue, s.charAt(j)-'0', s.charAt(j+1)-'0')) {
          return false;
        }
      }
    }
    return true;
  }

  public boolean isEqualMinusValue(int firstMinusValue,int cur, int next) {
    return (firstMinusValue == cur - next) ? true : false;
  }

}


class Print{
  //Constructor
  Print(final int hansooCount){
    System.out.println(hansooCount);
  }
}

각 객체는 하나의 책임만을 가지게 되었습니다.

유지보수 , 협업시에서 OOP의 중요성은 너무 공감하고있습니다..

한달전에 자바로 채팅프로그램을 2명이서 만든적이 있었는데

제 코드를 상대방에게 이해시키기가 너무 힘들었던 적이 있었거든요.

책임에 따라 클래스를 분리시키지 못했었습니다.

프로그래밍을 할 때 구현하는 것의 책임에 대해 생각해보는것은 어떨까요?

참고자료

개발자가 반드시 정복해야 할 객체 지향과 디자인 패턴(최범균 저)

https://www.acmicpc.net/problem/1065