[4주차] iOS프로그래밍 실무
- 프로젝트 생성 시 만들어지는
//
// AppDelegate.swift
// ddd
//
// Created by 소프트웨어컴퓨터 on 2025/03/26.
//
import UIKit // UIKit 프레임워크를 임포트하여 UI 관련 기능을 사용 가능하게 함
@main // 프로그램의 시작점을 나타내는 어트리뷰트
class AppDelegate: UIResponder, UIApplicationDelegate { // AppDelegate 클래스 선언, UIResponder와 UIApplicationDelegate 프로토콜을 준수
// 애플리케이션이 시작할 때 호출되는 메서드
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
// 애플리케이션이 시작된 후 사용자 정의를 위한 오버라이드 포인트
return true // 애플리케이션이 성공적으로 시작되었음을 나타냄
}
// MARK: UISceneSession Lifecycle // UISceneSession 생명 주기 관련 메서드를 그룹화하기 위한 주석
// 새로운 장면 세션이 연결될 때 호출되는 메서드
func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
// 새로운 장면을 생성하기 위한 구성을 선택하는 메서드
return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role) // 기본 구성 반환
}
// 사용자가 장면 세션을 폐기할 때 호출되는 메서드
func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
// 애플리케이션이 실행 중이지 않을 때 세션이 폐기된 경우 이 메서드가 호출됨
// 폐기된 장면에 특정한 리소스를 해제하는 데 사용할 수 있음
}
}//
// SceneDelegate.swift
// ddd
//
// Created by 소프트웨어컴퓨터 on 2025/03/26.
//
import UIKit // UIKit 프레임워크를 임포트하여 UI 관련 기능을 사용 가능하게 함
class SceneDelegate: UIResponder, UIWindowSceneDelegate { // SceneDelegate 클래스 선언, UIResponder와 UIWindowSceneDelegate 프로토콜을 준수
var window: UIWindow? // UIWindow 인스턴스를 저장할 변수 선언
// 장면이 세션에 연결될 때 호출되는 메서드
func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
// 제공된 UIWindowScene `scene`에 UIWindow `window`를 구성하고 연결하기 위한 선택적 메서드
// 스토리보드를 사용하는 경우 `window` 속성이 자동으로 초기화되고 장면에 연결됨
// 이 델리게이트는 연결된 장면이나 세션이 새로운 것임을 의미하지 않음
guard let _ = (scene as? UIWindowScene) else { return } // scene이 UIWindowScene인지 확인
}
// 장면이 시스템에 의해 해제될 때 호출되는 메서드
func sceneDidDisconnect(_ scene: UIScene) {
// 장면이 백그라운드로 들어가거나 세션이 폐기된 후에 호출됨
// 이 장면과 관련된 리소스를 해제하는 데 사용할 수 있음
// 장면은 나중에 다시 연결될 수 있음
}
// 장면이 비활성 상태에서 활성 상태로 이동할 때 호출되는 메서드
func sceneDidBecomeActive(_ scene: UIScene) {
// 장면이 활성 상태로 전환될 때 일시 중지된 작업을 재시작하는 데 사용
}
// 장면이 활성 상태에서 비활성 상태로 이동할 때 호출되는 메서드
func sceneWillResignActive(_ scene: UIScene) {
// 일시적인 중단으로 인해 호출될 수 있음 (예: 전화 통화 수신)
}
// 장면이 백그라운드에서 포그라운드로 전환될 때 호출되는 메서드
func sceneWillEnterForeground(_ scene: UIScene) {
// 백그라운드에서 들어올 때 변경 사항을 원래대로 되돌리는 데 사용
}
// 장면이 포그라운드에서 백그라운드로 전환될 때 호출되는 메서드
func sceneDidEnterBackground(_ scene: UIScene) {
// 데이터를 저장하고 공유 리소스를 해제하며 장면의 현재 상태를 복원할 수 있도록 상태 정보를 저장하는 데 사용
}
}//
// ViewController.swift
// ddd
//
// Created by 소프트웨어컴퓨터 on 2025/03/26.
//
import UIKit // UIKit 프레임워크를 임포트하여 UI 관련 기능을 사용 가능하게 함
class ViewController: UIViewController { // ViewController 클래스 선언, UIViewController를 상속받음
override func viewDidLoad() { // 뷰가 메모리에 로드된 후 호출되는 메서드
super.viewDidLoad() // 부모 클래스의 viewDidLoad 메서드를 호출하여 기본 동작 수행
// 뷰가 로드된 후 추가적인 설정을 수행할 수 있음
}
}
- 소스 설명
func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
1. **메서드의 역할**:
- 이 메서드는 새로운 장면(session)이 연결될 때 호출됩니다. 주로 앱이 멀티태스킹을 지원하는 경우, 새로운 장면을 생성하고 초기화하기 위한 설정을 반환하는 데 사용됩니다.
2. **매개변수**:
- `application`: 현재 실행 중인 애플리케이션의 인스턴스를 나타냅니다.
- `connectingSceneSession`: 새로 연결될 장면의 세션을 나타내는 객체입니다. 이 객체는 장면에 대한 정보를 담고 있습니다.
- `options`: 장면 연결과 관련된 추가 옵션을 포함하는 객체입니다. 예를 들어, 사용자가 특정 작업을 통해 장면을 생성했는지에 대한 정보가 포함될 수 있습니다.
3. **반환값**:
- `UISceneConfiguration`: 새 장면을 구성하는 데 필요한 설정을 포함하는 객체입니다. 이 설정은 장면의 이름과 역할을 정의합니다.
### 코드의 흐름
- 메서드가 호출되면, 새로운 장면 세션을 생성하기 위해 적절한 `UISceneConfiguration` 객체를 반환해야 합니다.
- 일반적으로 기존에 정의된 설정(예: "Default Configuration")을 반환하거나, 특정 요구 사항에 맞는 새로운 설정을 생성할 수 있습니다.
- 위의 코드에서는 "Default Configuration"이라는 이름의 기본 구성 객체를 반환하고, 연결된 장면의 역할(sessionRole)을 설정합니다. 이로 인해 새로운 장면이 해당 설정에 따라 초기화됩니다.
- 언더바를 쓴 이유는?
언더바(`_`)는 Swift에서 매개변수의 레이블을 생략하기 위해 사용됩니다. 언더바를 사용함으로써 다음과 같은 효과를 얻을 수 있습니다.
### 매개변수 레이블 생략
1. **코드 간결성**:
- 매개변수 앞의 레이블을 생략하면 메서드 호출 시 더 간결한 형태로 작성할 수 있습니다. 예를 들어, 다음과 같은 호출이 가능합니다:
```swift
application(application, configurationForConnecting: connectingSceneSession, options: connectionOptions)
```
- 여기서 첫 번째 매개변수인 `application`의 레이블을 생략하기 위해 언더바를 사용합니다.
2. **의미 명확화**:
- 메서드의 첫 번째 매개변수는 `application`으로, 메서드의 호출 문맥에서 그 의미가 분명하므로 레이블을 생략해도 코드의 가독성을 해치지 않습니다.
- 아래 코드 두개를 다 쓴 이유?
configurationForConnecting connectingSceneSession:'configurationForConnecting'과 'connectingSceneSession'을 모두 사용하는 이유는 Swift 메서드의 매개변수를 정의할 때 역할과 의미를 명확하게 하기 위해서입니다. 각각의 요소가 어떤 의미를 가지는지 아래에서 설명하겠습니다.
1. 매개변수 레이블: 'configurationForConnecting'
- **목적**: 이 레이블은 메서드 호출 시 매개변수의 역할을 설명합니다. 즉, 이 매개변수가 "새로운 장면을 연결할 때 사용할 구성"이라는 것을 나타냅니다.
- **예시**: 메서드 호출 시 다음과 같이 사용됩니다.
application(application, configurationForConnecting: connectingSceneSession, options: connectionOptions)
여기서 `configurationForConnecting`은 호출하는 쪽에서 이 매개변수가 어떤 목적을 가지고 있는지를 명확히 알려줍니다.
### 2. 매개변수 이름: `connectingSceneSession`
- **목적**: 이 이름은 메서드 내에서 해당 매개변수를 참조할 때 사용됩니다. 실제로 연결될 장면의 세션을 나타내며, 장면의 상태와 관련된 정보를 포함합니다.
- **예시**: 메서드 내부에서 다음과 같이 사용할 수 있습니다.
let sceneRole = connectingSceneSession.role여기서 `connectingSceneSession`을 통해 해당 세션의 역할(role)을 가져올 수 있습니다.
### 요약
- **구성 요소의 역할**:
- **`configurationForConnecting`**: 매개변수의 목적을 설명하는 레이블.
- **`connectingSceneSession`**: 메서드 내부에서 사용할 수 있는 실제 매개변수 이름.
이 두 가지 요소를 함께 사용함으로써 코드의 가독성을 높이고, 메서드의 동작을 이해하기 쉽게 만듭니다. 즉, 매개변수의 역할과 내용을 명확히 구분하여 코드의 의도를 보다 쉽게 파악할 수 있도록 돕습니다.
func application(_ application: UIApplication, configurationForConnecting/*외부*/ connectingSceneSession/*내부*/: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {- argument vs parameter
import UIKit
func sayHello() -> Void { //매개변수가 없는 경우, 빈 괄호를 쓴다.
print("Hello") //리턴값이 없는 경우, -> Void는 생략 가능
}
sayHello()
↓
- 자료형 출력 (type(of : ))
func add(x:Int, y:Int) -> Int {
return x+y
}
print(add(x: 10, y: 20)) //30
var x = 10
print(type(of: x)) //Int 출력. 타입추론
print(type(of: add)) // (Int, Int) -> Int
- 내부 매개변수, 외부 매개변수
func add(xx x:Int, yy y:Int) -> Int {
return x+y
}
print(add(xx: 10, yy: 20)) //30
// xx yy : argument label, 외부에서 사용
// x y : parameter name, 내부에서 사용
print(type(of: add)) // (Int, Int) -> Int
func add(first x:Int, second y:Int) -> Int {
return x+y
}
print(add(first: 5, second: 10)) //15
func add(x:Int, y:Int) -> Int { //외부 매개변수명 생략하는 경우, 내부가 외부명까지 겸함
return x+y
}
print(add(x: 10, y: 20)) //30
//print(type(of: add)) // (Int, Int) -> Int
※ 함수명 주의
func add(first x:Int, second y:Int) -> Int {
print(#function) //함수명 출력, add(first:second:)
return x+y
}
print(add(first: 5, second: 10)) //15
func add(x:Int, y:Int) -> Int { //외부 매개변수명 생략하는 경우, 내부가 외부명까지 겸함
print(#function) //함수명 출력, add(x:y:)
return x+y
}
print(add(x: 10, y: 20)) //30
func add(_ x:Int, _ y:Int) -> Int { //내부, 외부명이 필요 없다는 것. 가장 안쓰는 방식임.
print(#function) //함수명 출력, add(_:_:)
return x+y
}
print(add(1, 2)) //3
func add(_ x:Int, yy y:Int) -> Int { //
print(#function) //함수명 출력, add(_:yy:)
return x+y
}
print(add(5, yy:3)) //8
//print(type(of: add)) // (Int, Int) -> Int
//위 4가지 모두 타입은 다 똑같음. but, 함수명은 다 다름! add아님!!
//add(first:second:) add(x:y:) add(_:_:) add(_:yy:)
func application(_/*외부*/ application/*내부*/: UIApplication, configurationForConnecting/*외부*/ connectingSceneSession/*내부*/: UISceneSession, options/*왜내부 겸*/: UIScene.ConnectionOptions) -> UISceneConfiguration {
이 함수의 함수명
-> application(_:configurationForConnecting:options:)
외부 매개변수명을 나열하면 됨.
- numberOfRowsInSection 함수란?
'numberOfRowsInSection'은 주로 'UITableViewDataSource' 프로토콜의 메서드 중 하나로, UITableView의 특정 섹션에 표시할 행(row)의 개수를 반환하는 데 사용됩니다. 이 메서드는 UITableView가 데이터를 표시하는 데 필요한 정보를 제공합니다.
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int
#### 매개변수
- **`tableView`**: 행의 개수를 요청하는 UITableView 인스턴스입니다. 이 매개변수는 메서드가 어떤 테이블 뷰에 대한 요청인지 구별하는 데 사용됩니다.
- **`section`**: 행의 개수를 반환할 섹션의 인덱스입니다. UITableView는 여러 섹션을 가질 수 있으며, 각 섹션마다 다른 행의 수를 가질 수 있습니다.
#### 반환값
- **`Int`**: 지정된 섹션에 표시할 행의 개수를 나타내는 정수값입니다.
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
if section == 0 {
return 5 // 첫 번째 섹션에 5개의 행을 보여줌
} else {
return 3 // 두 번째 섹션에 3개의 행을 보여줌
}
}
### 요약
`numberOfRowsInSection` 메서드는 UITableView의 데이터 소스에서 각 섹션에 몇 개의 행을 표시할지를 결정하는 중요한 역할을 하며, UITableView가 데이터를 올바르게 표시할 수 있도록 돕습니다.
- 객체지향 용어
- property
1. 초기값이 있는 경우
class Man {
var age : Int = 0
}
2. init을 이용해서 초기화
3. 옵셔널 변수로 선언
- class 생성
class Man {
var age : Int = 23 //프로퍼티
var weight : Double = 3.5 //프로퍼티
//init(){}
func display(){ //인스턴스 메서드
print("나이=\(age), 몸무게=\(weight)") }
}
var River : Man = Man() // : Man 생략가능
//River -> 프로퍼티
River.display()
- designated initializer
Swift에서 designated initializer는 클래스의 주요 초기화 메서드로, 클래스의 모든 저장 프로퍼티를 초기화하고, 해당 클래스의 기본 구현을 설정합니다. designated initializer는 클래스에서 필수적으로 구현해야 하는 초기화 메서드
class Man { // Man이라는 이름의 클래스를 정의
var age: Int // 나이를 나타내는 저장 프로퍼티 선언
var weight: Double // 몸무게를 나타내는 저장 프로퍼티 선언
// Man 클래스의 정보를 출력하는 메서드
func display() {
print("나이=\(age), 몸무게=\(weight)") // age와 weight 프로퍼티의 값을 출력
}
// Designated initializer: 나이와 몸무게를 초기화하는 메서드
init(age: Int, weight: Double) {
self.age = age // 전달받은 age 값을 저장 프로퍼티에 할당
self.weight = weight // 전달받은 weight 값을 저장 프로퍼티에 할당
}
}
var River = Man(age: 23, weight: 3.5) // Man 클래스의 인스턴스를 생성하고, age와 weight를 초기화
// River는 Man 클래스의 인스턴스이며, 나이는 23, 몸무게는 3.5로 설정됨
River.display() // River 인스턴스의 display() 메서드를 호출하여 나이와 몸무게를 출력
- 상속
class Man{
var age : Int
var weight : Double
func display(){
print("나이=\(age), 몸무게=\(weight)")
}
init(age: Int, weight : Double) {
self.age = age
self.weight = weight
} //designated initializer
}
class Student : Man { // 상속
}
var kim : Student = Student (age: 25, weight: 60.6)
kim.display()
var River = Man(age: 23, weight: 3.5)
//River -> 프로퍼티
River.display()
- super
class Man{
var age : Int
var weight : Double
func display(){
print("나이=\(age), 몸무게=\(weight)")
}
init(age: Int, weight : Double){
self.age = age
self.weight = weight
}
}
class Student : Man {
var name : String
func displayS() {
print("이름=\(name), 나이=\(age), 몸무게=\(weight)")
}
init(age: Int, weight : Double, name : String){
self.name = name
super.init(age:age, weight:weight) //이 줄을 안쓰면?
}//error:'super.init' isn't called on all paths before returning from initializer
} //자식 클래스에서 designated initializer를 만들면 부모 init()상속 안됨
var lee : Student = Student(age:20,weight:65.2,name:"홍길동")
lee.displayS() //이름=홍길동, 나이=20, 몸무게=65.2
lee.display() //나이=20, 몸무게=65.2
- 오류 발생?
self.name = name
super.init(age:age, weight:weight)
//이부분이 순서가 바뀌면 오류가 발생함Swift에서 초기화 과정은 매우 중요하며, 초기화 메서드에서 프로퍼티를 올바르게 초기화해야 합니다.
'self.name = name'과 'super.init(age:age, weight:weight)'의 순서를 바꾸면 오류가 발생하는 이유는 다음과 같습니다.
1. **초기화 순서**:
- Swift에서는 모든 저장 프로퍼티가 사용되기 전에 초기화되어야 합니다. 즉, 클래스의 designated initializer에서 `self`를 사용할 수 있는 상태가 되어야 합니다.
- `super.init(...)`을 호출하기 전에 `self`를 사용하여 프로퍼티를 초기화하는 것은 불가능합니다.
2. **오류 발생**:
- `self.name = name`을 `super.init(...)` 호출 이전에 위치시키면, `self`가 초기화되지 않은 상태에서 `name` 프로퍼티를 설정하려고 시도하게 됩니다. 이 경우, Swift는 `self`가 유효한 상태가 아니기 때문에 "super.init isn't called on all paths before returning from initializer"라는 오류 메시지를 발생시킵니다.
- Swift의 초기화 규칙에 따라 상위 클래스의 초기화가 완료되기 전에는 하위 클래스의 프로퍼티를 설정할 수 없습니다.
### 요약
- 'self'를 사용하기 전에 'super.init(...)'을 호출해야 하며, 이는 Swift의 초기화 규칙에 따른 것입니다.
- 초기화 순서를 바꾸면 'self'가 초기화되지 않은 상태에서 접근하려고 하기 때문에 오류가 발생합니다.
- 부모와 함수 명을 같게 하려면?
class Man{
var age : Int
var weight : Double
func display(){
print("나이=\(age), 몸무게=\(weight)")
}
init(age: Int, weight : Double){
self.age = age
self.weight = weight
}
}
class Student : Man {
var name : String
override func display() { //부모함수에 있는 명과 똑같이 display로 이름이 같게하려면 override라고 하는걸 붙여줘야함.
print("이름=\(name), 나이=\(age), 몸무게=\(weight)")
}
init(age: Int, weight : Double, name : String){
self.name = name
super.init(age:age, weight:weight) //이 줄을 안쓰면?
}//error:'super.init' isn't called on all paths before returning from initializer
} //자식 클래스에서 designated initializer를 만들면 부모 init()상속 안됨
var lee : Student = Student(age:20,weight:65.2,name:"홍길동")
lee.displayS() //이름=홍길동, 나이=20, 몸무게=65.2
lee.display() //나이=20, 몸무게=65.2
- 코드 설명
class Man { // Man이라는 이름의 클래스를 정의
var age: Int // 나이를 나타내는 저장 프로퍼티 선언
var weight: Double // 몸무게를 나타내는 저장 프로퍼티 선언
// Man 클래스의 정보를 출력하는 메서드
func display() {
print("나이=\(age), 몸무게=\(weight)") // age와 weight 프로퍼티의 값을 출력
}
// Designated initializer: 나이와 몸무게를 초기화하는 메서드
init(age: Int, weight: Double) {
self.age = age // 전달받은 age 값을 저장 프로퍼티에 할당
self.weight = weight // 전달받은 weight 값을 저장 프로퍼티에 할당
}
}
class Student: Man { // Man 클래스를 상속받는 Student 클래스 정의
var name: String // 학생의 이름을 저장하는 프로퍼티 선언
// display 메서드를 오버라이드하여 학생 정보를 출력하는 메서드
override func display() {
print("이름=\(name), 나이=\(age), 몸무게=\(weight)") // name, age, weight를 출력
}
// Designated initializer: 나이, 몸무게, 이름을 초기화하는 메서드
init(age: Int, weight: Double, name: String) {
self.name = name // 전달받은 name 값을 저장 프로퍼티에 할당
super.init(age: age, weight: weight) // 상위 클래스의 designated initializer 호출
}
// 이 줄을 안쓰면 초기화 과정에서 상위 클래스의 프로퍼티가 초기화되지 않아 오류 발생
}
var lee: Student = Student(age: 20, weight: 65.2, name: "홍길동") // Student 클래스의 인스턴스를 생성
// lee는 나이 20, 몸무게 65.2, 이름 "홍길동"으로 초기화됨
lee.display() // lee 인스턴스의 display() 메서드를 호출하여 이름, 나이, 몸무게를 출력
- delegate
델리게이트(Delegate) 디자인 패턴은 객체 지향 프로그래밍에서 객체 간의 통신을 위한 패턴으로, 주로 한 객체가 다른 객체에 작업을 위임할 때 사용됩니다. 이 패턴은 이벤트나 행동을 처리하는 데 유용하며, Swift와 같은 언어에서 자주 사용됩니다.
### 델리게이트 패턴의 구성 요소
1. **델리게이트 프로토콜**: 델리게이트가 구현해야 하는 메서드들을 정의하는 프로토콜입니다.
2. **주체(Delegate)**: 이벤트를 발생시키는 객체로, 델리게이트 프로토콜을 사용하여 델리게이트에게 작업을 위임합니다.
3. **델리게이트 객체**: 주체의 델리게이트 프로토콜을 구현하고, 주체에서 발생하는 이벤트에 대한 반응을 정의합니다.
### 예시: Swift에서의 델리게이트 패턴
아래는 델리게이트 패턴을 사용하는 간단한 예시입니다. `MyButton` 클래스가 버튼 클릭 이벤트를 델리게이트에게 알리는 구조입니다.
// 1. 델리게이트 프로토콜 정의
protocol MyButtonDelegate: AnyObject {
func buttonWasClicked() // 버튼 클릭 시 호출될 메서드 정의
}
// 2. 주체 클래스 정의
class MyButton {
weak var delegate: MyButtonDelegate? // 델리게이트 프로퍼티 (weak 참조)
func click() { // 버튼 클릭 메서드
print("버튼이 클릭되었습니다.")
delegate?.buttonWasClicked() // 델리게이트에게 버튼 클릭 알림
}
}
// 3. 델리게이트 객체 구현
class ViewController: MyButtonDelegate {
func buttonWasClicked() {
print("델리게이트가 버튼 클릭을 처리했습니다.") // 델리게이트가 처리하는 로직
}
}
// 4. 사용 예시
let myButton = MyButton() // MyButton 인스턴스 생성
let viewController = ViewController() // ViewController 인스턴스 생성
myButton.delegate = viewController // 델리게이트 설정
myButton.click() // 버튼 클릭 시뮬레이션
### 설명
1. **델리게이트 프로토콜**: `MyButtonDelegate` 프로토콜을 정의하여 버튼 클릭 시 호출될 메서드를 선언합니다.
2. **주체 클래스**: `MyButton` 클래스에서는 클릭 메서드(`click()`)가 버튼 클릭을 처리하고, 델리게이트에게 알리도록 구현합니다. `delegate` 프로퍼티는 `weak`로 선언하여 순환 참조를 방지합니다.
3. **델리게이트 객체**: `ViewController` 클래스는 `MyButtonDelegate` 프로토콜을 준수하며, 버튼 클릭 이벤트를 처리하는 `buttonWasClicked()` 메서드를 구현합니다.
4. **사용 예시**: `MyButton`과 `ViewController` 인스턴스를 생성하고, `myButton`의 델리게이트를 `viewController`로 설정한 뒤 버튼 클릭을 시뮬레이션합니다.
### 요약
델리게이트 패턴은 객체 간의 느슨한 결합을 통해 코드의 재사용성을 높이고, 이벤트 처리를 간단하게 만들 수 있는 강력한 디자인 패턴입니다. Swift에서는 UI 이벤트 처리 및 다양한 상황에서 널리 사용됩니다. 추가적인 질문이 있으시면 말씀해 주세요!
- protocol(프로토콜)
이 에러 메시지 **"Property in protocol must have explicit { get } or { get set } specifier"**는 프로토콜에 정의된 프로퍼티가 읽기 또는 읽기/쓰기 가능성을 명시해야 한다는 의미입니다. 프로토콜에서 프로퍼티를 정의할 때는, 그 프로퍼티가 어떻게 사용될지를 명확히 하기 위해 `{ get }` 또는 `{ get set }`을 지정해야 합니다.
- **`{ get }`**: 해당 프로퍼티는 읽기 전용입니다. 이 프로퍼티는 값에 접근할 수 있지만 수정할 수는 없습니다.
- **`{ get set }`**: 해당 프로퍼티는 읽기 및 쓰기가 가능합니다. 이 프로퍼티의 값에 접근하고 수정할 수 있습니다.
### 수정된 코드
아래는 에러를 수정한 코드입니다. 프로퍼티가 읽기 전용인 경우 `{ get }`을 추가했습니다.
protocol Runnable {
var x: Int { get } // 읽기 전용 프로퍼티로 정의
}
또는, 읽기 및 쓰기가 가능한 프로퍼티로 정의하려면 `{ get set }`을 사용할 수 있습니다.
protocol Runnable {
var x: Int { get set } // 읽기 및 쓰기가 가능한 프로퍼티로 정의
}
### 요약
- 프로토콜에서 프로퍼티를 정의할 때는 반드시 접근 제어를 명시해야 하며, 이를 통해 해당 프로퍼티의 사용 방식이 명확해집니다.
- `{ get }`은 읽기 전용, `{ get set }`은 읽기 및 쓰기가 가능함을 나타냅니다.
프로토콜 Runnable에 적합하지 않는다는 오류 발생.
- 프로토콜 정의, 채택, 준수
protocol Runnable {
var x : Int { get set } //{ get set }이라서 읽기와 쓰기 가능한 프로퍼티
func run() //메서드는 선언만
}
class Man : Runnable { //채택, adopt - Runnable이 부모 상속인지 프로토콜 채택인지 알 수 없을 수 있음
var x: Int = 1 //준수, conform - 초기값 없으면 오류발생.
func run() { //준수, conform
print("Runnnnn")
}
}
var River : Man = Man()
River.run()
- 상속과 프로토콜을 동시에 사용하는 예제
// 1. 작업을 위한 프로토콜 정의
protocol Workable {
var name: String { get } // 이름 프로퍼티
func work() // 작업 메서드
}
// 2. 기본 클래스 정의: Employee
class Employee: Workable {
var name: String // 직원의 이름
var employeeID: Int // 직원 ID
// 초기화 메서드
init(name: String, employeeID: Int) {
self.name = name
self.employeeID = employeeID
}
// 프로토콜의 work() 메서드 구현
func work() {
print("\(name)님이 일을 하고 있습니다.")
}
}
// 3. 매니저 클래스: Employee를 상속
class Manager: Employee {
var department: String // 관리하는 부서
// 초기화 메서드
init(name: String, employeeID: Int, department: String) {
self.department = department
super.init(name: name, employeeID: employeeID) // 상위 클래스 초기화
}
// work() 메서드 오버라이드
override func work() {
print("\(name)님이 \(department) 부서를 관리하고 있습니다.")
}
}
// 4. 인턴 클래스: Employee를 상속
class Intern: Employee {
var mentor: String // 멘토의 이름
// 초기화 메서드
init(name: String, employeeID: Int, mentor: String) {
self.mentor = mentor
super.init(name: name, employeeID: employeeID) // 상위 클래스 초기화
}
// work() 메서드 오버라이드
override func work() {
print("\(name)님이 \(mentor)님의 지도 아래 인턴십을 하고 있습니다.")
}
}
// 5. 사용 예시
let manager = Manager(name: "김부장", employeeID: 101, department: "영업")
manager.work() // 매니저의 작업 메서드 호출
let intern = Intern(name: "홍길동", employeeID: 102, mentor: "이멘토")
intern.work() // 인턴의 작업 메서드 호출
출처 :
뤼튼 사용하러 가기 > https://agent.wrtn.ai/5xb91l
smile han > https://youtube.com/@smilehan8416?si=t6AyWf3K1BVyPd6S