Type Casting

• 인스턴스의 타입을 확인하거나
• 해당 인스턴스를 다른 상위 클래스 or 하위 클래스로 취급하는 방법
• is, as 연산자로 구현된다.
• 프로토콜을 준수하는지도 확인할 수 있음.

예시 클래스 정의

class MediaItem {
    var name: String
    init(name: String) {
        self.name = name
    }
}

class Movie: MediaItem {
    var director: String
    init(name: String, director: String) {
        self.director = director
        super.init(name: name)
    }
}

class Song: MediaItem {
    var artist: String
    init(name: String, artist: String) {
        self.artist = artist
        super.init(name: name)
    }
}


// MediaType 과 그걸 상속한 Movie, Song 으로 이루어져 있기 때문에
// [MediaType] 으로 추론됨.
let library = [
    Movie(name: "Casablanca", director: "Michael Curtiz"),
    Song(name: "Blue Suede Shoes", artist: "Elvis Presley"),
    Movie(name: "Citizen Kane", director: "Orson Welles"),
    Song(name: "The One And Only", artist: "Chesney Hawkes"),
    Song(name: "Never Gonna Give You Up", artist: "Rick Astley")
]

1. 타입 검사

• is 로 해당 인스턴스가 하위 클래스 타입이면 true 아니면 false
• 정말 그 타입인지 확인만 필요할 때 사용.

var movieCount = 0
var songCount = 0

for item in library {
    if item is Movie {
        movieCount += 1
    } else if item is Song {
        songCount += 1
    }
}

print("Media library contains \(movieCount) movies and \(songCount) songs")
// Prints "Media library contains 2 movies and 3 songs"

2. 다운캐스팅

• 특정 클래스 타입의 상수/변수는 하위 클래스의 인스턴스를 참조할 수 있다고 확신되는 경우,
• as? as! 를 이용해서 하위 클래스 타입으로 다운캐스트 할 수 있다.
• 실패가 가능하기 때문에, Optional 값을 반환하는 ? 과 강제로 다운캐스트 하는 !

for item in library {
    // 하위 타입이어야 movie.director, song.artist 에 접근할 수 있다.
    if let movie = item as? Movie {
        print("Movie: \(movie.name), dir. \(movie.director)")
    } else if let song = item as? Song {
        print("Song: \(song.name), by \(song.artist)")
    }
}

3. Any, AnyObject 에 대한 타입캐스팅

• 특정되지 않은 타입을 위해서
  • Any : 함수 타입을 포함한 모든 타입의 인스턴스를 나타낼 수 있음.
  • AnyObject : 모든 클래스 타입의 인스턴스를 나타낼 수 있음.
• 두가지 타입을 제공한다.
• optional 값을 Any 로 사용하는 경우 as Any 로 캐스트하자.

var things: [Any] = []

things.append(0)
things.append(0.0)
things.append(42)
things.append(3.14159)
things.append("hello")
things.append((3.0, 5.0))
things.append(Movie(name: "Ghostbusters", director: "Ivan Reitman"))
things.append({ (name: String) -> String in "Hello, \(name)" })

let optionalNumber: Int? = 3
things.append(optionalNumber as Any) // optional 값을 넣으려면 Any 로 캐스트하자.

// switch 구문을 통해서 확인할 수 있다.
for thing in things {
    switch thing {
    case 0 as Int:
        print("zero as an Int")
    case 0 as Double:
        print("zero as a Double")
    case let someInt as Int:
        print("an integer value of \(someInt)")
    case let someDouble as Double where someDouble > 0:
        print("a positive double value of \(someDouble)")
    case is Double:
        print("some other double value that I don't want to print")
    case let someString as String:
        print("a string value of \"\(someString)\"")
    case let (x, y) as (Double, Double):
        print("an (x, y) point at \(x), \(y)")
    case let movie as Movie:
        print("a movie called \(movie.name), dir. \(movie.director)")
    case let stringConverter as (String) -> String:
        print(stringConverter("Michael"))
    default:
        print("something else")
    }
}

Nested Types

• 복잡한 타입의 컨텍스트 내에서 사용하기 위해 struct, class, enum 안에 중첩하여 struct, class, enum 을 선언할 수 있다.
• 필요한 만큼 중첩할 수 있다.

1. 동작

struct BlackjackCard > enum Suit
struct BlackjackCard > enum Rank > struct Values

struct BlackjackCard {

    // nested Suit enumeration
    enum Suit: Character {
        case spades = "♠", hearts = "♡", diamonds = "♢", clubs = "♣"
    }

    // nested Rank enumeration
    enum Rank: Int {
        case two = 2, three, four, five, six, seven, eight, nine, ten
        case jack, queen, king, ace
        struct Values {
            let first: Int, second: Int?
        }
        var values: Values {
            switch self {
            case .ace:
                return Values(first: 1, second: 11)
            case .jack, .queen, .king:
                return Values(first: 10, second: nil)
            default:
                return Values(first: self.rawValue, second: nil)
            }
        }
    }

    // BlackjackCard properties and methods
    let rank: Rank, suit: Suit
    var description: String {
        var output = "suit is \(suit.rawValue),"
        output += " value is \(rank.values.first)"
        if let second = rank.values.second {
            output += " or \(second)"
        }
        return output
    }
}

지정된 init이 없기 때문에 멤버별 초기자 사용 가능.

let theAceOfSpades = BlackjackCard(rank: .ace, suit: .spades)
print("theAceOfSpades: \(theAceOfSpades.description)")
// Prints "theAceOfSpades: suit is ♠, value is 1 or 11"

2. 참조

중첩된 타입의 이름을 chaining 처럼 . 을 붙여서 참조할 수 있다.

let heartsSymbol = BlackjackCard.Suit.hearts.rawValue
// heartsSymbol is "♡"