[Swift] 기초 문법2

- 구조체

/* struct 구조체 이름{
	프로퍼티와 메서드
}*/

struct User {
	var nickname: String
    var age: Int
    
    func information() {
    	print("\(nickname) \(age)")
    }
}

var user = User(nickname: "ked", age: 20)
print(user.nickname)

user.nickname = "albert" // 변경
user.information() // method 호출

 

- 클래스

/*class 클래스 이름 {
	 프로퍼티와 메서드
 }*/
 
 class Dog {
 	var name: String = ""
    var age: Int = 0
    
    init() {
    	// 인스턴스가 생성되면 호출
    }
    
    func introduce() {
    	print("name \(name) age \(age)")
    }
}

var dog = Dog()
dog.name = "ked"
dog.introduce()

class User {
	var nickname: String
    var age: Int
    
    init(nickanme: String, age: Int) {
    	self.nickname = nickname
        self.age = age
    }
    
    init(age: Int) {
    	self.nickname = "albert"
        self.age = 22
    }
    
    deinit {
    	print("deinit user")
    }
}

var user = User(nickname: "ked", age:20)

var user2 = User(age:20)

var user3: User? = User(age:22)
user3 = nil // 인스턴스가 필요하지 않아서 deinit 호출됨.

 

- 프로퍼티

struct Dog {
	var name: String
    let gender: String
}

var dog = Dog(name: "ked", gender: "Male")

dog.name = "albert"
dog.gender = "female" // 에러

let dog2 = Dog(name: "ked", gender: "Male")
dog2.name = "albert" // 에러, 내부 프로퍼티도 상수가 됨.


class Cat {
	var name: String
    let gender: String
    
    init(name: String, gender: String) {
    	self.name = name
        self.gender = gender
    }
}

let cat = Cat(name: "ked", gender: "Male")
cat.name = "albert"
cat.gender = "female" //에러

// 클래스는 참조타입
// 구조체는 밸류타입


strung Stock {
	var averagePrice: Int
    var quantity: Int
    var purchasePrice: Int {
    	get {
        	return averagePrice * quantity
        }
        
        set(newPrice) {
        	averagePrice = newPrice / quantity
        }
        
        // 매개변수 설정 안하면 newValue 가 디폴트
        /*
        set {
        	averagePrice = newValue / quantity
        }*/
    }
}

var stock = Stock(averagePrice: 2300, quantity:3)
stock.purchasePrice = 3000
stock.average // 1000


class Account {
	var credit: Int = 0 {
    	willSet {
        	print("\(credit)에서 \(newValue)로 변경 예정")
        }
        
        didSet {
        	print("\(oldValue)에서 \(credit)으로 변경됨")
        }
    }
}

// 타입 프로퍼티
// 인스턴스를 생성하지않고 접근함
struct SomeStructure {
	static var storedTypeProperty = "some value"
    static var computedTypeProperty: Int {
    	return 1
    }
}

SomeStructure.storedTypeProperty
SomeStructure.computedTypeProperty
SomeStructure.storedTypeProperty = "hello"

 

- 클래스와 구조체 차이

클래스
- 참조타입
- 실제 데이터는 힙 영역에 저장
- ARC로 메모리를 관리
- 상속이 가능
- deinit 가능
- 타입 캐스팅을 통해 런타임에서 클래스 인스턴스의 타입을 확인할 수 있음
- 같은 클래스 인스턴스를 여러 개의 변수에 할당한 뒤 값을 변경 시키면 모든 변수에 영향을 줌
(메모리가 복사 됨)

구조체
- 값 타입
- 구조체 변수를 새로운 변수에 할당할 때마다 새로운 구조체가 할당됨
(값 자체를 복사)

 

- 상속

class Vehicle {
	var currentSpeed = 0.0
    var description: String {
    	return "\(currentSpeed) 속도"
    }
    func makeNoise(){
    	print("소리 온")
    }
}

class Bicycle: Vehicle {
	var hasBasket = false
    
    //overriding
    override func makeNoise(){
    	super.makeNoise() // 슈퍼클래스의 메소드 호출
    	print("따르릉")
    }
}
var bicycle = Bicycle()
bicycle.currentSpeed // 0.0
bicycle.currentSpeed = 15.0 // 15.0

bicycle.makeNoise() // 소리 온, 따르릉

class Car: Vehicle {
	var gear = 1
    override var description: String {
    	return super.description + " in gear \(gear)"
    }
}

let car = Car()
car.currentSpeed = 30.0
car.gear = 2
print(car.description) //30.0의 속도 in gear 2

class AutomaticCar: Car {
	override var currentSpeed: Double {
    	didSet {
        	gear = Int(currentSpeed / 10) + 1
        }
    }
}

let automatic = AutomaticCar()
automatic.currentSpeed = 35.0 // 오버라이딩된 currentSpeed를 수정함으로써 gear의 값을 변경
print("AutomaticCar : \(automatic.description)")

// super class의 프로퍼티 앞에 final을 추가하면 재정의를 할 수 없음

 

- 타입캐스팅

// is 연산자
// 타입 확인
for item in library {
	if item is Movie {
    	movicount += 1
    } else if item is Song {
    	songCount += 1
    }
}

// as 다운캐스팅
for item in library {
	if let movie = item as? Movie {
		print("Movie \(movie.name)")
    } else if let song = item as? Song {
    	print("Song \(song.name)")
    }
}