속성과 매서드 #96

Roy-wonji · 2022-09-24T06:19:32Z

Roy-wonji
Sep 24, 2022

	구조체 (struct)	클래스 (class)
속성 (Properties)	저장 속성 (Stored), 지연 저장 속성 (Lazy)	저장 속성 (Stored), 지연 저장 속성 (Lazy)
	계산 속성 (Computed) - 읽기 / 쓰기	계산 속성 (Computed) - 읽기 / 쓰기
	타입 속성 (Type) - 저장, 계산	타입 속성 (Type) - 저장, 계산
	속성 감시자 (Property Observers) - willSet, didSet	속성 감시자 (Property Observers) - willSet, didSet
메서드 (Methods)	인스턴스 메서드 (mutating 키워드)	인스턴스 메서드
	타입 메서드 type method	타입 메서드 type method
	서브스크립트 subscript	서브스크립트 subscript
	생성자	생성자
	- Memberwise 생성자 (지정속성에 관한 자동 생성자)	- 지정생성자 (Designated)
	- 지정생성자 (Designated)	- 편의생성자 (Convenience) → 상속
	- 실패가능생성자 (Failable)	- 필수생성자 (Required) → 상속
		- 실패가능생성자 (Failable)
		소멸자

저장 속성

값이 저장되는 일반적인 속성(변수)을 저장 속성이라고 함

각 인스턴스가 고유의 데이터 저장 공간을 가지고 있다.
var, let 으로 선언 가능하다.
객체 초기화 시, 각 저장 속성은 반드시 값을 가져야 한다.
- 기본값 설정, 생성자 설정, 옵셔널 타입
열거형의 경우 따로 메모리 공간이 필요한 저장 속성(데이터)은 선언할 수 없다.

지연 저장 속성(Lazy Stored Properties)

지연 저장 속성은 "해당 저장 속성"의 초기화를 지연시키는 것임

일반적으로 많은 메모리 공간을 차지하는 이미지 같은 속성의 초기화를 지연시킨다.
값에 대한 접근이 있어야 초기화 된다. (메모리 공간 생성)
lazy var 로만 선언이 가능하다.
생성자에서 초기화하지 않기 때문에 반드시 기본값이 필요하다.
- 함수 실행문, 계산식, 클로저

지연 저장 속성을 사용하는 이유

메모리 공간을 많이 차지하는 이미지 등의 속성에 저장할때,
(반드시 메모리에 다 올릴 필요가 없으므로) 지연 저장 속성으로
- 선언 함 (메모리 낭비 막기 위함)
다른 속성들을 이용해야 할때
초기화 시점에 모든 속성들이 동시에 메모리 공간에 저장되므로
어떤 한가지 속성이 다른 속성에 접근할 수가 없다.
(그렇지만, 지연 저장 속성을 이용 하는 경우 지연으로 저장된 속성은 먼저 초기화된 속성에 접근 할 수 있게됨)
실제 프로젝트에서 많이 활용

struct Bird1 {
    var name: String
    lazy var weight: Double = 0.2
init(name: String) {
    self.name = name
    //self.weight = 0.2
}

func fly() {
    print("날아갑니다.")
}

}
var aBird1 = Bird1(name: "새")   // weight 속성 초기화 안됨

aBird1.weight  // <============ 해당 변수에 접근하는 이 시점에 초기화됨 (메모리 공간이 생기고 숫자가 저장됨)

계산 속성(연산속성, Computed property)

Computed property 특징

구조체, 클래스, 열거형 에 사용 가능하다. (열거형은 잘 사용하지 않는다.)
항상 변하는 값이므로, var 로 선언해야 한다.
자료형을 반드시 명시해주어야 한다.
get 은 반드시 구현해야하지만 set은 생략해도 된다.
- read-only property
- get-only-property
set 의 파라미터의 타입을 지정해주지 않아도 된다.
set 의 파라미터는 newValue 로 사용해도 된다.
- (직접 파라미터 이름 설정 가능)
계산 속성은 속성 (변수) 형태를 가진 메서드 이다.
계산 속성은 실제 메모리 공간을 가지지 않는다.
해당 속성에 접근했을 때 다른 속성에 접근하여 계산한 후, 그 계산 결과를 리턴하거나 세팅하는 메서드 이다.

Computed property 장점

관련이 있는 두가지 메서드 (get, set)을 한번에 구현할 수 있다.
외부에서 보기에 속성 이름으로 설정 가능함으로 코드가 좀 더 명확해 보인다.

Computed property 메모리구조

데이터 영역의 class 나 struct 구조에서 get() , set() 메서드의 메모리 주소를 가지고 있다.
→ 실제 메모리 공간이 아닌 메서드로 저장되어있다.
함수를 실행함으로 스택 영역에서 실행된다.

class Person1 {

var name: String = "사람"

var height: Double = 160.0

var weight: Double = 60.0
var bmi: Double {
    get {                                                //get ===&gt; 값을 얻는다는 의미
        let result = weight / (height * height) * 10000
        return result
    }
}

}
let p1 = Person1()

p1.height = 165   // 키 165

p1.weight = 65    // 몸무게 65
p1.bmi

타입 속성 (Type property)

인스턴스에 속한 속성이 아니고, 타입 자체에 속한 속성

데이터 영역 (클래스, 구조체 틀) 에 공통적으로 저장되는 속성
인스턴스로 접근할 수 없고 타입으로 접근해야 한다.

저장 타입 속성

모든 인스턴스가 동일하게 가져야하는 보편적인 속성이거나 모든 인스턴스가 공유 해야 하는 성격에
가까운 저장 타입 속성으로 선어
static/ let / var 선언
- 재정의 불가능
저장 타입속성은 기본적으로 지연 속성
- (속성에 처음 접근하는 순간에 초기화됨)이지만, lazy라고 선언할 필요는 없음
여러 스레드에서 동시에 액세스하는 경우에도 한 번만 초기화되도록 보장됨. Thread-Safe

class Circle {
// (저장) 타입 속성 (값이 항상 있어야 함)
static let pi: Double = 3.14
static var count: Int = 0   // 인스턴스를 (전체적으로)몇개를 찍어내는지 확인

// 저장 속성
var radius: Double     // 반지름

// 계산 속성
var diameter: Double {     // 지름
    get {
        return radius * 2
    }
    set {
        radius = newValue / 2
    }
}

// 생성자
init(radius: Double) {
    self.radius = radius
   Circle.count += 1
}

}

var ciircle = Circle(radius: 2)
var circle1 = Circle(radius: 2)   // 인스턴스를 +1 개 찍어냈다.

Circle.count

//

var circle2 = Circle(radius: 3)   // 인스턴스를 +1 개 찍어냈다.

Circle.count

계산 타입 속성

상속에서, 상위클래스에서 class키워드를 붙인 경우, 재정의 가능
static 또는 class 키워드를 사용한다.
var 키워드만 사용 가능하다.
메서드이기 때문에 메모리 공간이 할당되어 있지 않다.

class Circle1 {
// 저장 타입 속성
static let pi: Double = 3.14
static var count: Int = 0


// (계산) 타입 속성(read-only)
static var multiPi: Double {
    return pi * 2
}

// 저장 속성
var radius: Double     // 반지름


// 생성자
init(radius: Double) {
    self.radius = radius
}

}
let b = Circle1.multiPi

속성 감시자(Property Observer)

저장 속성이 변하는 시점을 관찰한다. → 변하는 순간 메서드가 호출된다.

속성 감시자(Property Observer) 를 사용하는 이유

변수 변하면, 변경 내용을 반영하고 싶을때(업데이트)

속성 감시자를 추가 가능한 경우?

→ 저장 속성, 계산 속성 모두 가능하지만 계산 속성은 상속해서 재정의하는 경우에만 가능하다.

let , 지연 저장 속성 은 관찰할 수 없다.
실제 값의 변경이 일어나지 않아도, 값을 Set 하는 작업을 하는면 무조건 호출

willSet

값이 저장되기 직전에 호출된다.

바뀔 값이 파라미터로 전달된다.
파라미터 생략 후 newValue 사용 가능하다.

didSet

값이 저장된 직후에 호출된다.

바뀌기 전의 과거 값이 파라미터로 전달된다.
파라미터 생략 후 oldValue 사용 가능하다.

주의점

속성 감시자를 추가 가능한 경우 ⭐️
저장 속성 (원래, 상속한 경우 둘다 가능)
계산 속성 (상속해서 재정의하는 경우에만 가능) (단순 메서드 추가)
계산 속성의 경우, 속성 관찰자를 만드는 대신 계산 속성의 set블록에서 값 변경을 관찰할 수 있기 때문에
(재정의(상속)이 아닌 본래의 계산 속성에는 추가 불가)
let(상수) 속성에는 당연히 추가 안됨 (값이 변하지 않으므로, 관찰할 필요가 없기 때문)
지연저장 속성에 안됨

class Profile2 {
// 일반 저장 속성
var name: String = "이름"

var statusMessage = "기본 상태메세지" {
    willSet {
        print("메세지가 \\(statusMessage)에서 \\(newValue)로 변경될 예정입니다.")
        print("상태메세지 업데이트 준비")
    }
    didSet {
        print("메세지가 \\(oldValue)에서 \\(statusMessage)로 이미 변경되었습니다.")
        print("상태메세지 업데이트 완료")
    }
}

}
let p2 = Profile2()
p2.name

p2.name = "전지현"
p2.statusMessage

p2.statusMessage = "행복해"

매서드

인스턴스 메서드 (Instance Methods)

클래스, 구조체, 열거형 의 함수를 인스턴스 메서드라고 한다.

메서드이기 때문에 인스턴스에 메모리 공간이 할당되어 있지 않다.
→ 데이터 영역에 함수 주소만을 가지고 있다.

메서드 실행 시, 스택프레임을 만들고 인스턴스의 데이터를 사용한다.

→ 메서드 종료 시 스택프레임 삭제

class Dog1 {

static var species = "Dog"
var name: String
var weight: Double

init(name: String, weight: Double) {
    self.name = name
    self.weight = weight
}

func sit() {
    print("\\(name)가 앉았습니다.")
}

func trainning() {
    print("월월 저는 \\(Dog1.species)입니다.")
    sit()
    sit()
    self.sit()     // self키워드는 명확하게 지칭하는 역할일 뿐
}

func changeName(newName name: String) {
    self.name = name
}

}
let bori1 = Dog1(name: "보리", weight: 20.0)

bori1.trainning()
bori1.changeName(newName: "말썽쟁이보리")

bori1.sit()

구조체의 인스턴스 메서드(Instance Methods)

값 타입(구조체, 열거형)에서 기본적으로 인스턴스 메서드 내에서 속성을 수정할 수 없음
수정하려면, mutating(변형되는)키워드를 붙이면 속성 수정 가능해짐(클래스와 구조체의 차이)
mutate: 변형되다 (mutating - 변형되는)
컴파일러가 알아서 수정해줌 (실수에 대한 자동 방지가 되지만, 문법적으로 인지하고 있어야함)

struct Dog2 {

var name: String

var weight: Double
init(name: String, weight: Double) {
    self.name = name
    self.weight = weight
}

func sit() {
    print("\\(name)가 앉았습니다.")
}

func  sit(a: String)  {
    print(a)
}

mutating func changeName(newName name: String) {
    self.name = name
}

}
var dog777 = Dog2(name: "코비", weight: 20)

dog777.changeName(newName: "베리")

dog777.sit(a: "안녕")

타입 메서드(Type Methods)

매서드 이기 때문에 타입에 메모리 공간이 할당되어 있지 않음
인스턴스애 속한 속성이 아니고 타입 자체에 속한 속성이기에 내/외부에서 Type Methods() 로 접근 해야함
- 매서드 실행시 , 스택프레임을 만들고 타입 데이터를 사용 → 매서드 종료시 스택프레임 사라짐
타입에 해당하는 보편적인 동작인 경우
static(의미 : 고정적이) 또는 class 키원드 사용 (static 상속시 재정의 불가/ clas 상속시 재정의 가능 의미임)
인스턴스 기능이 아닌, 타입 자체에 필요한 기능을 구현할때 주로 사용
타입 자제가 가져야 하는 공통된 기능(동작) 구현시

class Dog {

static var species = "Dog"
var name: String
var weight: Double

init(name: String, weight: Double) {
    self.name = name
    self.weight = weight
}

func sit() {
    print("\\(name)가 앉았습니다.")
}

func trainning() {
    print("월월 저는 \\(Dog.species)입니다.")
    sit()
    sit()
    self.sit()
}

func changeName(newName name: String) {
    self.name = name
}

static func letmeKnow() {     // 타입 메서드에서, 타입속성에 접근시에는 타입으로 접근하지 않아도 됨
    print("종은 항상 \\(species)입니다.")      // Dog.species라고 써도됨
}

}
let bori = Dog(name: "보리", weight: 20.0)

bori.sit()

Dog.letmeKnow()

서브스크립트(Subscripts)

대괄호를 이용해서 접근가능하도록 만든 문법을 가르킴
클래스 / 구조체 / 열거형 에 직접 구현해볼 수 있다.

<aside> 💡 클래스 / 구조체 / 열거형 에 직접 구현해볼 수 있다.

</aside>

메서드이기 때문에 인스턴스에 메모리 공간이 할당되어 있지 않다.]

배열

array[인덱스]

딕셔너리

dictionary[키

class SomeData {

var datas = ["Apple", "Swift", "iOS", "Hello"]

subscript(index: Int) -> String {     // 1) 함수와 동일한 형태이지만, 이름은 subscript

get {                             // 2) get/set은 계산속성에서의 형태와 비슷

return datas[index]

}

set {

datas[index] = newValue         // 또는 파라미터 생략하고 newValue로 대체 가능(계산 속성의 setter와 동일)

}

}

}

2개의 파라미터를 받는 서브스크립트 구현도 가능

struct Matrix {

// 2차원 배열

var data = [["1", "2", "3"], ["4", "5", "6"], ["7", "8", "9"]]
// 2개의 파라미터를 받는 읽기전용 서브스크립트의 구현
subscript(row: Int, column: Int) -&gt; String? {
    if row &gt;= 3 || column &gt;= 3 {
        return nil
    }
    return data[row][column]
}

}
// 2개의 파라미터를 받는 서브스크립트 구현도 가능
var mat = Matrix()

mat[0, 1]!     // 대괄호 안에 파라미터 2개 필요

2차원 배열

struct Matrix {

// 2차원 배열

var data = [["1", "2", "3"], ["4", "5", "6"], ["7", "8", "9"]]
// 2개의 파라미터를 받는 읽기전용 서브스크립트의 구현
subscript(row: Int, column: Int) -&gt; String? {
    if row &gt;= 3 || column &gt;= 3 {
        return nil
    }
    return data[row][column]
}

}

타입 서브스크립트(Type Subscripts) - 클래스, 구조체, (열거형)

enum Planet: Int {   // 열거형의 원시값

case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
static subscript(n: Int) -&gt; Planet {    // Self
    return Planet(rawValue: n)!
}

}
let mars = Planet[4]      // Planet.venus

print(mars)

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

속성과 매서드 #96

{{title}}

Replies: 0 comments

Select a reply

속성과 매서드 #96

Roy-wonji Sep 24, 2022

저장 속성

지연 저장 속성(Lazy Stored Properties)

지연 저장 속성을 사용하는 이유

계산 속성(연산속성, Computed property)

Computed property 특징

Computed property 장점

Computed property 메모리구조

타입 속성 (Type property)

저장 타입 속성

계산 타입 속성

속성 감시자(Property Observer)

willSet

didSet

주의점

매서드

인스턴스 메서드 (Instance Methods)

구조체의 인스턴스 메서드(Instance Methods)

타입 메서드(Type Methods)

서브스크립트(Subscripts)

배열

딕셔너리

Replies: 0 comments

Roy-wonji
Sep 24, 2022