[Swift] Objected Oriented Programming in Swift (raywenderlich 번역)

사물을 객체 지향적인 방식으로 설계하는 것은 일반적인 개념을 보다 구체적인 유형으로 확장하는 것에서부터 시작된다. 여기서는 객체 지향 프로그래밍을 사용하여 뮤지컬 밴드를 만들어 볼 것이다. 아래 표를 악기의 가계도라고 생각하면, 자식과 부모 사이의 관계는 is-a이다. 즉, Guitar is-a Instrument라고 말할 수 있는 것이다.

ㅤ ㅤ

Properties

// 1
class Instrument {
  // 2
  let brand: String
  // 3
  init(brand: String) {
    //4 
    self.brand = brand
  }
}

1. class 키워드를 이용해서 Instrument라는 base class를 만들었는데, 이게 바로 instruments 계층의 루트 클래스이다.
2. instrument의 stored properties (data)를 선언했는데, 이는 모든 instruments가 갖고 있는 것이다.
3. init 키워드를 사용해서 클래스의 initializer를 생성했는데, 이는 모든 stored properties를 초기화하여 새로운 instruments를 구성하기 위한 것이다.
4. instruments의 stored property인 brand를 parameter로 전달된 brand로 설정한다. 이 때, property와 parameter의 이름이 같으므로, self 키워드를 사용하여 서로 구분한다.
   ㅤ
   ㅤ

Methods

악기의 종류에 상관 없이 조율하거나 연주를 할 수 있는데, Instrument 클래스 내부에 아래 코드를 추가한다.

func tune() -> String {
  fatalError("Implement this method for \(brand)")
}

• tune() method는 호출하면 런타임에 크래시가 발생하는 placeholder 함수이다.
• 이와 같은 방법을 사용하는 메소드들은 직접적인 사용을 의도하지 않기 때문에 추상적 (abstract)이라고 한다. 대신에, 메소드를 override해서 적절한 작업을 수행하도록 하는 subclass를 정의해야한다.
• class 내부에 정의된 함수들은 Instrument의 brand와 같은 property에 접근할 수 있기 때문에 메소드라고 한다.
• class에서 property들과 관련 작업을 구성하는 것은 복잡성을 낮출 수 있는 강력한 도구이다. 이를 심지어 encapsulation라고도 하는데, Class 타입은 데이터 (ex. stored properties)와 동작 (ex. methods)을 캡슐화 (encapsulate) 한다고 한다.
  ㅤ
  ㅤ

아래 코드를 추가한다.

class Music {
  let notes: [String]

  init(notes: [String]) {
    self.notes = notes
  }

  func prepared() -> String {
    return notes.joined(separator: " ")
  }
}

• 이 Music class는 배열 notes를 캡슐화하고 prepared() 메소드를 사용해서 배열을 문자열로 변환한다.
  ㅤ
  ㅤ

Instrument 클래스의 tune() 메소드 뒤에 아래 코드를 추가한다.

func play(_ music: Music) -> String {
  return music.prepared()
}

• play(_:) 메소드는 문자열을 리턴한다. 여기서 문자열 배열이 아닌 Music 타입을 전달한 이유는, Music 타입을 생성하는 것이 후에 컴파일러가 확장을 위한 장소를 따로 만드는 것을 가능하게 하기 때문이다.
  ㅤ
  ㅤ

Instrument 클래스의 play(_:) 바로 뒤에 아래 코드를 추가한다.

func perform(_ music: Music) {
  print(tune())
  print(play(music))
}

• perform( _ :) 메소드는 tune() 메소드를 먼저 호출하고, 이어서 play(_:) 메소드를 호출하고 있다.

ㅤ
ㅤ

Inheritance

악기를 추가하기 위해서 아래 코드를 추가한다.

// 1
class Piano: Instrument {
  let hasPedals: Bool
  // 2
  static let whiteKeys = 52
  static let blackKeys = 36

  // 3
  init(brand: String, hasPedals: Bool = false) {
    self.hasPedals = hasPedals
    // 4
    super.init(brand: brand)
  }

  // 5
  override func tune() -> String {
    return "Piano standard tuning for \(brand)."
  }

  override func play(_ music: Music) -> String {
    // 6 
    let preparedNotes = super.play(music)
    return "Piano playing \(preparedNotes)"
  }
}

1. Piano 클래스를 Instrument 클래스의 subclass로 생성했다. Instrument 클래스는 Piano 클래스의 parent class라고 부른다. 모든 stored properties와 methods가 자동으로 child class인 Piano 클래스로 상속 (inherited) 되고, Piano 클래스 내에서 사용할 수 있게 된다.
2. 모든 piano들은 브랜드에 관계없이 정확히 같은 숫자의 흰색 키와 검은색 키를 갖고 있다. 그렇기 때문에 이 속성과 관련된 값들은 변하지 않으므로 static 키워드로 선언한다.
3. 생성자는 hasPedals 파라미터 기본값을 제공하는데, 원한다면 이를 변경할 수 있다.
4. child class의 hasPedals 속성을 설정한 후에 super 키워드를 사용하여 parent class의 이니셜라이저를 호출했다. super class 이니셜라이저는 상속된 속성들을 초기화하는데, 여기서는 brand를 초기화한다.
5. override 키워드를 사용하여 tune 메소드를 상속받아서 재정의했다. 이는 parent class에서의 구현처럼 fatalError()를 호출하지 않고, 문자열을 리턴한다. 즉, 기능적인 면으로 말하자면 피아노에 특화된 튜닝을 하는 역할로 재정의되었다.
6. 상속된 play(_:) 메소드를 재정의하고, 이 메소드 내부에서 super 키워드를 사용해서 parent class의 play 메소드를 먼저 호출했다. 그리고 preparedNotes를 얻은 후 이를 연주한다는 문자열로 리턴한다.
   ㅤ
   ㅤ

💡 Swift class는 Two-phase-Initialization이라는 초기화 프로세스를 사용하기 때문에, 모든 속성들이 사용 전에 반드시 초기화되도록 한다.

ㅤ ㅤ

Method Overloading

Piano class의 재정의된 play(_:) 메소드 뒤에 아래 코드를 추가한다.

func play(_ music: Music, usingPedals: Bool) -> String {
  let preparedNotes = super.play(music)
  if hasPedals && usingPedals {
    return "Play piano notes \(preparedNotes) with pedals."
  }
  else {
    return "Play piano notes \(preparedNotes) without pedals."
  }
}

• play(_:) 메소드는 usingPedals가 참이고 실제로 피아노가 페달이 있을 때, 페달을 사용하는 방법을 오버로드한다.
• 다른 파라미터 목록을 갖기 때문에 override 키워드를 사용하지 않는다. Swift는 파라미터 목록을 통해 사용할 메소드를 결정한다.
• 메소드 이름이 같아서 헷갈릴 수 있으므로 조심히 사용해야한다.
  ㅤ
  ㅤ

Piano 클래스의 play(_:)를 아래와 같이 수정한다.

override func play(_ music: Music) -> String {
  return play(music, usingPedals: hasPedals)
}

ㅤ
ㅤ

Instances

// 1
let piano = Piano(brand: "Yamaha", hasPedals: true)
piano.tune()
// 2
let music = Music(notes: ["C", "G", "F"])
// 3
piano.play(music)
// 4
Piano.whiteKeys
Piano.blackKeys

1. piano 인스턴스 생성
2. music 인스턴스 생성
3. 가능하다면 항상 페달을 사용하는 Piano 클래스의 play(_:)를 호출한다.
4. 키의 갯수는 Piano 클래스에 있는 static 상수이므로, 키의 갯수를 호출하는데에 특정 인스턴스는 필요하지 않다. 그저 클래스 이름을 사용하여 호출하면 된다.
   ㅤ
   ㅤ

Intermediate Abstract Base Classes

class Guitar: Instrument {
  let stringGauge: String

  init(brand: String, stringGauge: String = "medium") {
    self.stringGauge = stringGauge
    super.init(brand: brand)
  }
}

• Instrument와 마찬가지로, Guitar는 하위 클래스에서 tune()과 play(_:) 메소드를 재정의해야하는 추상 타입으로 간주된다. 그렇기 때문에 이는 Intermediate Abstract Base Class라고도 부른다.
  ㅤ
  ㅤ

Concrete Guitars

class AcousticGuitar: Guitar {
  static let numberOfStrings = 6
  static let fretCount = 20

  override func tune() -> String {
    return "Tune \(brand) acoustic with E A D G B E"
  }

  override func play(_ music: Music) -> String {
    let preparedNotes = super.play(music)
    return "Play folk tune on frets \(preparedNotes)."
  }
}

• 모든 어쿠스틱 기타들은 6개의 줄과 20개의 프렛을 갖고 있다. 그렇기 때문에 numberOfStrings, fretCount는 static 키워드를 이용하여 선언한다.
• 이 클래스에서는 새로운 stored property가 없기 때문에, Guitar로부터 생성자를 상속받아서 사용하면 되므로 따로 생성자를 만들 필요는 없다.
  ㅤ
  ㅤ

Private

// 1
class Amplifier {
  // 2
  private var _volume: Int
  // 3
  private(set) var isOn: Bool

  init() {
    isOn = false
    _volume = 0
  }

  // 4
  func plugIn() {
    isOn = true
  }

  func unplug() {
    isOn = false
  }

  // 5
  var volume: Int {
    // 6
    get {
      return isOn ? _volume : 0
    }
    // 7
    set {
      _volume = min(max(newValue, 0), 10)
    }
  }
}

1. Amplifier은 루트 클래스이다.
2. _volume은 private으로 선언되어있는데, 이는 외부 유저로부터 숨겨져있다. 앞에 underscore를 붙인 것은 private 구현 사항이라는 것을 강조하는 것이다. convention이기 때문에 지키는 것이 좋다.
3. stored property isOn은 외부 유저들이 읽을 수는 있지만, 편집할 수는 없다. (Read Only) private(set) 키워드를 이용하여 선언한다.
4. plugIn()과 unplug()는 isOn의 상태에 영향을 미친다.
5. computed property인 volume은 _volume을 감싸고 있다.
6. getter에서 isOn이 꺼져있다면 볼륨을 0으로 줄인다.
7. setter에서 볼륨은 항상 0에서 10사이의 값으로 고정된다.
   ㅤ
   ㅤ

Polymorphism

객체 지향 프로그래밍의 가장 큰 장점 중 하나는 바로 다른 객체를 동일한 인터페이스를 통해 사용할 수 있다는 것이다. 이를 바로 다형성 (Polymorphism)이라고 한다.

class Band {
  let instruments: [Instrument]

  init(instruments: [Instrument]) {
    self.instruments = instruments
  }

  func perform(_ music: Music) {
    for instrument in instruments {
      instrument.perform(music)
    }
  }
}

• Band 클래스는 이니셜라이저에서 초기화한 instruments 배열을 stored property로 갖고 있다. band는 perform 메소드에서 배열에 있는 각 instrument를 모두 돌면서 perform 메소드를 호출한다.
  ㅤ
  ㅤ

let instruments = [piano, acousticGuitar, electricGuitar, bassGuitar]
let band = Band(instruments: instruments)
band.perform(music)

• 먼저 instruments를 정의한 후, Band 인스턴스를 생성하고 instruments 프로퍼티를 이용하여 초기화한다.
• 그리고 perform(_:) 메소드를 사용하면, 실제 Band 내의 instruments는 [Instrument] 타입이지만, 각 instrument는 각각의 타입에 따라 작동한다. 이게 바로 다형성이 작동하는 방식이다.
  ㅤ
  ㅤ

Access Control

Access control은 다른 소스 파일과 모듈에 있는 코드에서 일부 코드에 대한 접근을 제한한다. 이 기능을 사용하면 코드의 세부 구현 사항을 숨기거나 해당 코드에 접근하고 사용할 수 있는 기본 인터페이스를 지정할 수 있다.

Swift는 다음과 같은 5가지 레벨의 접근 제어를 제공한다.

• private
  • 같은 클래스 내에서만 사용 가능
• fileprivate
  • 같은 소스 파일 내에서 접근 가능 (.swift)
• internal
  • 같은 모듈이나 프로젝트 내에서 접근 가능
• public
  • 모듈 외부에서도 접근 가능
• open
  • 모듈 외부 어디에서나 사용 가능할 뿐만 아니라, 외부에서 subclass 또는 override도 가능
    ㅤ
    ㅤ

추가적으로 final 키워드는 subclass, override도 모두 불가능하다. 만약 클래스나 속성, 메소드에 대한 접근을 따로 지정하지 않는다면, 기본적으로 internal access로 설정된다.
ㅤ
ㅤ

Object Oriented Programming in Swift