상속(Inheritance) & 초기화

[Roy-wonji]

상속(Inheritance)이란?

클래스는 메소드, 프로퍼티와 다른 특징(characteristics)을 다른 클래스로 부터 상속할 수 있습니다. 이것이 Swift에서 클래스가 다른 타입과 구분되는 근본적인 요소입니다. 클래스에서는 저장된 프로퍼티와 계산된 프로퍼티와 상관없이 상속받은 프로퍼티에 프로퍼티 옵저버를 설정해서 값 설정에 반응할 수 있습니다.

오로지 "클래스"만 상속이 가능하며, 상속은 단일 상속만 허용한다(다중 상속X)

클래스는 메서드, 프로퍼티 및 기타 특징들을 상속할 수 있다

상속은 쉽게 말하면, 본질적으로 성격이 비슷한 타입을 새로만들어

• 데이터(저장속성)를 추가하거나
• 기능(메서드)를 변형시키서 사용하려는 것

class Person {
    var id = 0
    var name = "이름"
    var email = "[email protected]"
}

class Student: Person {
    // id
    // name
    // email
    var studentId = 0
}

class Undergraduate: Student {
    // id
    // name
    // email
    // studentId
    var major = "전공"
}

상속의 재정의

• 오버로딩(overloading) - (엉어 뜻: 과적) 함수에서 함수의 하나의 이름에 여러 함수를 대응시켜서 사용
• 오버라이딩(overriding) - (영어 뜻: 재정의) 클래스의 상속에서 상위클래스의 속성/메서드를 재정의(기능을 약간 변형하여 사용)하는 것

재정의

• 서브클래스에서 슈퍼클래스의 동일한 멤버를 변형하여 구현
• 상위 클래스에서 존재하는 멤버를 변형하는 것을 재정의라고 함
• 재정의를 하려는 멤버에는 override 키워드를 붙여야함

재정의 가능한 대상(멤버)

• 속성 (하지만, 저장 속성에 대한 재정의는 어떠한 경우에도 불가능)
• 메서드 (메서드, 서브스크립트, 생성자)

class SomeSuperclass {
    // 저장속성
    var aValue = 0
    
    // 메서드
    func doSomething() {
        print("Do something")
    }
}

class SomeSubclass: SomeSuperclass {
    // 저장속성의 재정의는 원칙적 불가
    //override var aValue = 3
    
    // 저장속성 ===> (재정의) 계산속성
    // 그러나, 메서드 형태로 부수적 추가는 가능
    override var aValue: Int {
        get {
            return 1
        }
        set {    // self로 쓰면 안됨
            super.aValue = newValue
        }
    }
    
    // 메서드는 (어떤 형태로든)재정의 가능 ===> 변형 / 대체
    override func doSomething() {
        super.doSomething()
        print("Do something 2")
        //super.doSomething()
    }
}

속성의 재정의 (엄격)

• (타입/인스턴스 속성을 구분해서 생각해야 하지만, 실질적으로 타입 속성을 재정의 하는 것은 드문 일이므로 배제하고 생각하면 됨)

저장 속성의 재정의

• 원칙적으로 불가능(고유의 메모리 공간은 유지 해야함)
• 저장 속성은 고유의 메모리 공간이 있으므로 하위클래스에서 고유의 메모리 공간을 바꾸는 방식으로의 재정의는 불가능

에외경우

(메서드 형태로 추가하는 방식의 재정의는 가능)

• 읽기/쓰기 가능한 계산속성으로 재정의 가능(메서드) (읽기만 가능한 계산 속성으로 정의 불가능 - 기능 축소는 불가능 X)
• 속성 감시자를 추가는 가능(메서드) (실질적 단순 메서드를 추가해서 저장 속성이 변하는 시점을 관찰할뿐)

계산 속성(메서드)의 재정의

• (실질적인 메서드이기 때문에 메서드 형태로의 재정의만 가능. 기능의 범위를 축소하는 형태로의 재정의는 불가능)
• (상위)읽기전용 계산 속성을 ===> ( 하위)읽기/쓰기가 가능한 가능한 속성으로 재정의 가능(확장 O)
• 속성 감시자를 추가하는 재정의는 불가능 (읽기 전용 속성을 관찰 할 수 없음 - 논리에 안 맞음)
• (상위)읽기/쓰기 계산 속성을 ===> (하위)읽기만 가능한 가능한 속성으로만 재정의 불가능(기능 제한 X)
• 속성 감시자를 추가하는 재정의 가능 (관찰은 가능)

---

• 읽기 메서드 ===> 읽기 메서드
• 쓰기 메서드 ===>    x      (불가능)
• 읽기 메서드 ===> 읽기 메서드
• x   ===> 쓰기 메서드  (가능)   // 확장은 가능

⭐️ 인스턴스 속성의 대원칙

1. 저장 속성 재정의는 원칙적으로 불가능(하위 속성에서 상위 속성의 고유의 메모리 공간을 변형 불가).

메서드 방식(계산 속성으로의 재정의 가능)으로 추가는 가능

1. 계산 속성의 유지/확장은 가능, 축소는 불가능
2. 속성 감시자(메서드)를 추가하는 재정의는 언제나 가능(실질적 단순 메서드 추가)

(다만, 읽기전용 계산 속성을 관찰하는 것은 의미 없으므로 불가능)

1. (실질적으로 드뭄)

타입 속성의 재정의 원칙

1. 타입 저장 속성은 재정의 불가 - static키워드 (계산속성으로 재정의하거나, 속성 감시자를 추가하는 것도 불가능)
2. 타입 계산 속성 - class 키워드인 경우 계산 속성 재정의 (확장방식) 가능.
3. 재정의한 타입 저장/계산 속성에는 감시자 추가 원칙적으로 불가

오버라이드 방지 (Preventing Overrides)

final 로 선언되면 override 되는 것을 막을 수 있습니다. (final func, final class func, final subscript) 만일 final 로 선언된 메소드, 프로퍼티, 서브스크립트를 오버라이드 하려고 하면 컴파일 시간(compile-time)에 에러가 발생합니다. 클래스 전체를 final로 선언해서 클래스 안의 모든 메소드, 프로퍼티 등이 override가 되는 것을 막을 수 있습니다. (final class)

UIKit 상속

• final은 보통 앱을 만들때 상속을 안하면 메인 뷰 컨트롤러에 final 을 선언을 해준다

final class TextFiedViewController: UIViewController {
    private let textField = HoshiTextField().then {
        $0.placeholder = "title"
        $0.placeholderColor = .white
        $0.placeholderFontScale = 1
        $0.keyboardType = UIKeyboardType.emailAddress
        $0.returnKeyType = UIReturnKeyType.done
        $0.clearButtonMode = UITextField.ViewMode.whileEditing
        $0.contentHorizontalAlignment = UIControl.ContentHorizontalAlignment.leading
        $0.layer.borderWidth = 0.25
        $0.textColor = .white
        $0.layer.borderColor = UIColor.black.cgColor
    }

매서드의 재정의 (메서드, 스크립트, 생성자)

• 속성에 비해, 메서드의 재정의는 자유로운 편(⭐️다만, 생성자의 재정의는 메모리 생성 규칙이 존재)
• 상위 클래스 인스턴스 메서드 또는 타입 메서드 상관없이 기능을 추가하는 것도 가능하고,
• 상위 기능을 무시하고 새롭게 구현 하는 것도 가능(제약 없음 - 메서드 이름만 동일하고 완전히 새롭게 구현 가능하다고 생각하면됨)
• 다만, 기능을 추가하는 구현을 선택할시에 상위구현의 기능을 먼저 실행할지의 여부는 개발자의 선택

메모리 구조를 통한 이해

재정의(overriding) - 현재의 클래스에 맞게 상위 멤버를 변형시키서, 사용 하려는 것

대원칙

1. 저장 속성 재정의 불가
2. 메서드는 자유롧게 재정의 가능(다만, 기능 확장만 가능 - 기능 축소 불가의 의미)
3. (재정의를 하지 않아도, 상속에서는 당연히 모든 멤버의 상속이 일어남)
4. 저장 속성은 실제 인스턴스에 각각의 멤버별(속성별로) 저장공간이 있고,
5. 변형하는 것이 불가 (상속의 기본 원칙)
6. 메서드는 타입(데이터 영역)에만 배열형태로 주소값을 저장되어 존재하므로
7. 각 상속단계에서 재정의 되고 대체 되는 것이 당연

초기화란?

초기화는 클래스, 구조체, 열거형의 인스턴스를 생성하는 과정임

각 "저장 속성"에 대한 초기값을 설정하여 인스턴스를 사용가능한 상태로 만드는 것

(열거형은 저장속성이 존재하지 않으므로, case중에 한가지를 선택 및 생성)

• 결국, 이니셜라이저의 실행이 완료되었을 때,
• 인스턴스의 모든 저장속성이 초기값을 가지는 것이 ==> 생성자(Initializer)의 역할
• 함수의 구현이 특별 키워드인 init으로 명명됨
• 인스턴스 생성과정 - > 저장속성에 대한 초기값을 설정하여 사용가능한 상태가 되는것

(즉 , 생성자 실행의 종료 시점에는 모든 저장 속성에 값이 저장되어 있어야 함)

// 클래스, 구조체, (열거형) 동일
class Color {

//let red, green, blue: Double    // 동일한 타입일때, 한줄에 작성가능

let red: Double

let green: Double

let blue: Double
// 생성자도 오버로딩(Overloading)을 지원 (파리미터의 수, 아규먼트 레이블, 자료형으로 구분)

init() {      // "init()" -> 기본 생성자. 저장 속성의 기본값을 설정하면 "자동" 구현이 제공됨
    red = 0.0
    green = 0.0
    blue = 0.0
}

init(white: Double) {
    red   = white
    green = white
    blue  = white
}

init(red: Double, green: Double, blue: Double) {
    self.red   = red
    self.green = green
    self.blue  = blue
}

}

오버라이딩 지원

• 다양한 파라미터 조합으로 생성자를 여러개 구현 가능

(여러가지 방식으로 인스턴스를 생성하는 방법을 제공 하는 것)

초기화의 방법(저장속성이 초기값 가져야 함)

1. 저장 속성의 선언과 동시에 값을 저장
2. 저장 속성을 옵셔널로 선언 (초기값이 없어도 nil로 초기화됨)
3. 생성자에서 값을 초기화
4. 반드시 생성자를 정의해야만 하는 것은 아님 ⭐️

• 1-2번 방법으로 이니셜라이저를 구현하지 않아도,
• 컴파일러는 기본 생성자(Default Initializer)를 자동으로 생성함 ==> init()
• ==> 이니셜라이저 구현하면, 기본 생성자를 자동으로 생성하지 않음

소멸자

• 생성자와 반대개념의 소멸자(Deinitializer)도 있음
• 소멸자 ==> 인스턴스가 해제되기 전에 해야할 기능을 정의하는 부분

생성자 기본 원칙

• 컴파일러는 기본 생성자(Default Initializer)를 자동으로 생성함 ==> init()
• ==> 이니셜라이저 구현하면, 기본 생성자를 자동으로 생성하지 않음
• 구조체는 저장 속성들이 기본값을 가지고 있더라도,
• 추가적으로 Memberwise멤버와이즈(멤버에 관한) 이니셜라이저를 자동으로 제공함
• 개발자가 직접적으로 생성자를 구현하면, 멤버와이즈 이니셜라이저가 자동으로 제공되지 않음 ⭐️

(멤버와이즈 이니셜라이저는 편의적 기능일뿐)

생성자 직접 구현 하지 않으면?⭐️

1. 모든 저장 속성에 기본값(또는 옵셔널 타입) 전체

   • 클래스 : 기본 생성자 init () 제공 (초기화 방법 별도)
   • 구조체 : 기본 생성자 init () 제공 + 멤버와이즈 이니셜라이즈도 제공

   (편의를 위한 기본제공 / 새로운 값으로 설정 가능 )

2. (일부) 저장 속성에 기본값 (또는 옵셔널 타입) 전제

   • 클래스 : 원칙적으로 일부 값만 가지고 . 셍성자 구현하지 않는 방법이 존재 하지 않음
   • 구조체 : 멤버와이즈 이니셜라이즈도 제공

   (편의를 위한 기본제공 / 새로운 값으로 설정 가능 )

   Dog(name: "초코", weight: 15.0)
   
   

멤버와이즈 이니셜라이즈 : 직접 구현하지 않아도 , 자동으로 제공해주는 저장 속성 설정 가능한 생성자

구조체 vs 클래스 생성자(Initializer

구분	구조체(Struct)	클래스(Class)

1. 지정 생성자 (Designated) | init () {} (모든 저장 속성에 기본값 (or 옵셔널 생섲자 구현 안할시 , 기본 생성자 기본제공) init(파라미터) { } (생성자 구현 안할시 Memberwise 생성자 기본제공) | init () {} (모든 저장 속성에 기본값 (or 옵셔널 생섲자 구현 안할시 , 기본 생성자 기본제공) init(파라미터) { }
2. 편의 생성자 (Convenience) | x | Convenience init(파라 미터 ) { } (상속과 관련 )
3. 필수 생성자 (Required) | x | required init(파라 미터 ) { } (상속과 관련 )
4. 실패가능 생성자 (Failable) | init ? (파라미터 ) { } init ! (파라미터 ) { } | init ? (파라미터 ) { } init ! (파라미터 ) { }
5. 소명자 (Deinitalizers) | x | deinit{ }

1. 지정 생성자 (Designated)

• init(....) 형태를 가지는 생성자
• 지정생성자는 모든 저장 속성을 초기화 해야함

(저장 속성의 선언과 동시에 값을 저장하거나 저장 속성을 옵셔널 타입으로 선언 하는것도 가능)

• 오버로딩이 가능하므로 , 다양한 파라미터 조합으로 지정 생성자 구현 가능
• ( 따로 지정하지 않아도 ) 모든 저장 속성이 초기화 되는 경우 , 기본 생성자 자동 제공 → init( )
• 생성자를 1 개 이상 구현 하면 기본 생성자를 제공 하지 않음

struct Color {
    let red, green, blue: Double
init(red: Double, green: Double, blue: Double) {

self.red   = red

self.green = green

self.blue  = blue

}

}

2. 편의 생성자 (Convenience)

• 지정생자 보다 적은 개수의 파라미터로 보다 편리하게 생성하기 위한 서브(Sub) 개념의 생성자
• 편의생성자 (Convenience)는 지정 생성자 (Designated)에 의전 및 호출 (지정생성자가 저장 속성 초기화)
• 초기화 과정을 간편하게 제공하기 위함
• 실질적으로 가능 한 지정 생성자의 개수를 줄이고 , 편의생성자에서 지정생성자 호출 되도록 하는 것이 바람직함
• 상속했을때 , 편의생성자의 경우 서브클래스에서 재정의를 모샇마(하위에서 호출불가가 원칙)
• 편의생성자는 다른 편의생성자를 호출 하거나 , 지정생성자를 호출 해야함(궁극적으로는 지정생성자를 호출)

class Color2 {

let red, green, blue: Double

convenience init() {
    self.init(red: 0.0, green: 0.0, blue: 0.0)
    //self.init(white: 0.0)
}

convenience init(white: Double) {
    //red   = white
    //green = white
    //blue  = white
    self.init(red: white, green: white, blue: white)
}

init(red: Double, green: Double, blue: Double) {
    self.red   = red
    self.green = green
    self.blue  = blue
}

}

생성자 위임 규칙(Initializer Delegation)

1. 델리게이트 업(Delegate up)

• 서브클래스의 지정생성자는 수퍼 클래스의 지정생성자를 반드시 호출해야함

1. 델리게이트 어크로스(Delegate across)

• 편의생성자는 동일한 클래스에서 다른 이니셜 라이저를 호출해야하고, 궁극적으로 지정생성자를 호출해야함

⭐️ 모든 저장속성 갑이 초기화 되어야지만 인스턴스가 사용이 가능함 !

3. 필수 생성자(Required Initializers)

• 클래스 생성자 앞에 required(요구된/필수의) 키워드 사용시
• 하위 생성자는 반드시 해당 필수 생성자를 구현 해야함

class Cclass: Aclass {

init() {

super.init(x: 0)

}

required init(x: Int) {
    super.init(x: x)       // 호출시 required init으로 호출하지 않음
}

}

소멸자 (Deinitialization)

• 인스턴스가 메모리에서 해제되기 직전 정리가 필요한 내용을 구현하는 메서드
• 클래스 정의시 클래스에는 최대 1개의 소멸자(deinitializer)를 정의 가능
• 소멸자는 파라미터(매개 변수)를 사용하지 않음

소멸자(초기화 해제) 작동 방식

• Swift는 클래스의 인스턴스(객체)를 자동 참조 계산(ARC) 방식을 통해 메모리 관리
• 일반적인 경우(강한 순환 참조를 제외한)에는 메모리에서 해제될때
• 수동으로 관리를 수행할 필요가 없음
• 그러나 특별한 작업을 수행중인 경우, 몇가지 추가 정리를 직접 수행해야 할 수 있음
• 예) 인스턴스에서 파일을 열고 일부 데이터를 쓰는 경우, 클래스 인스턴스가 할당 해제되기 전에 파일을 닫아야 파일에 손상이 안 갈 수 있음
• 소멸자에서는 인스턴스의 모든 속성에 액세스 할 수 있으며 해당 속성을 기반으로 동작을 수정할 수 있음 (예 : 닫아야하는 파일의 이름 조회)

상속이 있는 경우

• 상위클래스 소멸자는 해당 하위클래스에 의해 상속됨
• 상위클래스 소멸자는 하위클래스 소멸자의 실행이 끝날 때 자동으로 호출됨
• 상위클래스 소멸자는 하위클래스가 자체적인 소멸자를 제공하지 않더라도 항상 호출됨

class Aclass {

var x = 0

var y = 0

deinit {
    print("인스턴스의 소멸 시점")
}

}
var a: Aclass? = Aclass()

a = nil   // 메모리에 있던 a인스턴스가 제거됨

❗️소멸자는 클래스에만 존재

• 생성자는 필요한 만큼 구현할 수 있지만, 소멸자는 하나만 구현 가능함
• 소멸자는 직접호출할 수 없고(직접 호출하는 문법이 없고),
• 인스턴스(객체)가 메모리에서 제거되기 직전에 자동으로 호출됨⭐️