형변환 : Type Casting(2)

ex01.playground.zip

0.02MB

import UIKit

 

// 형변환 :  Type Casting

 

let intNum: Int = 10

let floatNum: Float = 3.64

let str1: String = "1234"

 

// Int -> Double

let doubleNum: Double = Double(intNum)

 

print("intNum :",intNum)

print("doubleNum :",doubleNum)

 

// Float -> Int: 소숫점 이하가 표현 안 되고, 반올림도 안 됨

let intNum2: Int = Int(floatNum)

print("floatNum :",floatNum)

print("intNum2 :",intNum2)

 

// Int -> String

let strNum: String = String(intNum)

print("intNum :",intNum)

print("strNum :",strNum)

 

// String       -> Int  : 숫자모양의 문자열만 Int 로 형변환 가능

// str1("1234")    1234

// str1 에 숫자모양의 문자열이 아닌 문자열이 할당되어 있을 때

// 형변환하면 nil 이 됨 <- intNum3 는 Optional 로 선언해야 함

let intNum3: Int? = Int(str1)

print("str1 :",str1)

print("intNum3 :",intNum3!)

 

// Optional Binding (if let)

if let intNum4 = Int(str1){

    // 형변환 성공: nil 이 아님

    print("intNum4 :",intNum4)

}else{

    print("숫자모양의 문자열이 아니라서 형변환이 안 됨")

}

 

let str2: String = "hello"

if let intNum5 = Int(str2){

    print("intNum5 :",intNum5)

}else{

    print("intNum5 : 숫자모양의 문자열이 아니라서 형변환이 안 됨")

}

 

// class casting : 클래스 형변환 - 수직관계

class GrandParent{

    var name: String = ""

    func home(){

        print("은퇴하심")

    }

}

class Parent: GrandParent{

    var company: String = ""

    func gotoWork(){

        print("출근하심")

    }

}

class Child: Parent{

    var school: String = ""

    func gotoSchool(){

        print("학교에 감")

    }

}

 

/*

 var gp: GrandParent = GrandParent()

 var gp: GrandParent = Child()

 var p: Parent = Parent()

 var chd: Child = Child()

 */

 

// type : (사용할 수 있는)권한

var p2: Parent = Child()

// p2 는 Parent 타입이므로

// Parent 클래스와 GrandParent 클래스에

// 정의된 멤버변수와 멤버메소드만 사용할 권한이 있음

// Child 클래스(Parent입장에서 자식클래스)에서

// 정의된 멤버변수와 멤버메소드들은 사용할 권한이 없음

p2.name

p2.home()

p2.company

p2.gotoWork()

// Value of type 'Parent' has no member 'school'

// p2.school

// Value of type 'Parent' has no member 'gotoSchool'

// p2.gotoSchool()

 

 

// gp 는 GrandParent 클래스의 멤버변수에만 접근권한이 있음

//                         메소드만 사용권한이 있음

var gp: GrandParent = GrandParent()

print("gp.name :",gp.name)

gp.name = "이순신"

print("gp.name :",gp.name)

gp.home()

// Value of type 'GrandParent' has no member 'company'

// gp.company

// Value of type 'GrandParent' has no member 'gotoWork'

// gp.gotoWork()

// Value of type 'GrandParent' has no member 'school'

// gp.school

// Value of type 'GrandParent' has no member 'gotoSchool'

// gp.gotoSchool()

var p: Parent = Parent()

p.name = "이순신"

print("p.name :",p.name)

p.home()

p.company

p.gotoWork()

// Value of type 'Parent' has no member 'school'

// p.school

// Value of type 'Parent' has no member 'gotoSchool'

// p.gotoSchool()

 

var chd: Child = Child()

chd.name = "이순신"

print("chd.name :",chd.name)

chd.home()

chd.company

chd.gotoWork()

chd.school

chd.gotoSchool()

 

 

 

//  is 연산자 : 상속관계를 파악함

// 객체(객체와 연결된 변수) is 클래스이름

//  ㄴ 객체가 클래스의 속성을 가지고 있으면 True 를 반환

//  ㄴ 객체가 클래스를 상속한 자식클래스(자신클래스)이면 True 를 반환

//  ㄴ 자식(자신) is 클래스이름 -> True

print("gp is GrandParent :",gp is GrandParent)

print("gp is Parent :",gp is Parent)

print("gp is Child :",gp is Child)

 

print("p is GrandParent :",p is GrandParent)

print("p is Parent :",p is Parent)

print("p is Child :",p is Child)

 

print("chd is GrandParent :",chd is GrandParent)

print("chd is Parent :",chd is Parent)

print("chd is Child :",chd is Child)

print("----------------")

 

// as 연산자: 클래스 형변환 연산자

//            ㄴ 상속관계에 있는 경우만 가능함

// as? 연산자: nil 일 수도 있는 경우

var optionalCast: Parent?

print("gp is Child :",gp is Child)

// var gp: GrandParent = GrandParent()

// gp에 연결된 객체는 GrandParent()이지 Child()객체가 아니라서

// 형변환이 안 됨

// gp is Child 결과가 false 이면

// gp as? Child: 형변환이 안 됨 <- nil이 할당됨

optionalCast = gp as? Child

 

// gp2에 연결된 객체는 Child()객체

// gp2 as? Child: 형변환이 됨 <- Child()객체가 할당됨

var gp2: GrandParent = Child()

optionalCast = gp2 as? Child

 

// ??  연산자: nil인 경우,

//           default(기본값: 지정해 준 값)으로 할당해 주는 연산자

optionalCast = gp as? Child ?? Child()

 

// as! 연산자: nil이더라도 강제 형변환을 하라는 의미

var forcedCast: Parent?

forcedCast = gp as? Child

 

// !: 강제 unwrapping

// nil이 아닌 것이 확실하지 않으면 사용하면 error 발생함

// 지금은  nil 이라서 안 됨

// forcedCast = gp as! Child

 

// nil 이 아닌 것이 확실할 때 사용함

// var gp2: GrandParent = Child()

forcedCast = gp2 as! Child