struct Sample{
    var mutableProperty = 100 // 가변 프로퍼티 - 값 변경 가능
    let immutableProperty = 100 // 불변 프로퍼티 - 값 변경 불가
    static var typeProperty = 100 // 타입 프로퍼티 - struct 자체가 사용하는 프로퍼티
}

var a:Sample = Sample()
print(a.immutableProperty) // 100
print(a.mutableProperty) // 100
//print(a.typeProperty) // 사용 불가

struct Sample{
    func instanceMethod() {
        print("instance method")
    }
    
    static func typeMethod() {
        print("type method")
    }
}

var a:Sample = Sample()
a.instanceMethod()
//a.typeMethod() // 사용 불가

struct Sample{
    var mutableProperty = 100 // 가변 프로퍼티 - 값 변경 가능
    let immutableProperty = 100 // 불변 프로퍼티 - 값 변경 불가
    static var typeProperty = 100 // 타입 프로퍼티 - struct 자체가 사용하는 프로퍼티
    func instanceMethod() {
        print("instance method")
    }
    
    static func typeMethod() {
        print("type method")
    }
}

var mutableStruct: Sample = Sample()
let immutableStruct: Sample = Sample()

//mutableStruct.immutableProperty = 200 // 할당 불가
mutableStruct.mutableProperty = 200 // 할당 가능

//immutableStruct.immutableProperty = 200 // 할당 불가
//immutableStruct.mutableProperty = 200 // 할당 불가

Sample.typeProperty = 300
Sample.typeMethod()

struct Student{
    var name: String = "unknown"
    var `class`:String = "Swift" // 키워드도 `로 묶어주면 이름으로 사용가능
    static var totalNumOfStudent: Int = 0
    
    // self를 명시하지 않아도 기본적으로 사용가능
    func selfIntroduce(){
        print("저는 \(self.class)반 \(name)입니다.")
    }
    
    // static 키워드를 사용할 경우 오버로딩 가능
    static func selfIntroduce() {
//        print("저는 \(self.class)반 \(name)입니다.") // static 변수만 타입 메서드에서 사용 가능
        print("학생 타입입니다. 현재 등록된 학생 인스턴스는 \(totalNumOfStudent)입니다.") // static property는 사용가능
    }
}

Student.selfIntroduce() // 학생 타입입니다. 현재 등록된 학생 인스턴스는 0입니다.
var wansik: Student = Student()
wansik.class = "스위프트"
wansik.name = "wansik"
wansik.selfIntroduce() // 저는 스위프트반 wansik입니다.

let wansik2: Student = Student()
//wansik2.class = "스위프트" // 불변 인스턴스로 선언했기 때문에 값 변경 불가
//wansik2.name = "wansik"
wansik2.selfIntroduce() // 저는 Swift반 unknown입니다.

class Sample {
    var mutableProperty: Int = 100
    let immutableProperty: Int = 100
    static var typeProperty: Int = 100
    
    // 인스턴스에서 사용할 수 있는 메서드
    func instanceMethod() {
        print("instance Method")
    }
    
    // 해당 타입 안에서 사용할 수 있는 메서드
    // struct는 애초에 상속 개념이 없기 때문에 얘기하지 않았지만
    // class에서 static은 상속했을 때 오버라이딩이 불가하다.
    static func typeMethod() {
        print("type method - static")
    }
    
    // 상속해서 사용하기 위한 타입 메서드는 class 키워드를 붙여야 한다.
    class func classMethod() {
        print("class method - static")
    }
}
var a: Sample = Sample()
a.instanceMethod() // instance Method
Sample.classMethod() // class method - static
Sample.typeMethod() // type method - static

class SampleInheritance: Sample{
    // 인스턴스를 만들었을 때, 인스턴스메서드를 상속하여 오버라이딩 가능
    override func instanceMethod(){
        print("inheritance instance method")
    }
    // 상속했을 때, class 키워드가 붙은 함수는 슈퍼 클래스의 타입 메서드를 상속할 수 있음
    override class func classMethod(){
        print("inheritance class method - static")
    }
}

var b:SampleInheritance = SampleInheritance()
b.instanceMethod() // inheritance instance method
SampleInheritance.classMethod() // inheritance class method - static

class Sample{
    var mutableProperty = 100 // 가변 프로퍼티 - 값 변경 가능
    let immutableProperty = 100 // 불변 프로퍼티 - 값 변경 불가
    static var typeProperty = 100 // 타입 프로퍼티 - class 자체가 사용하는 프로퍼티
}

var mutableClass: Sample = Sample()
let immutableClass: Sample = Sample()

//mutableClass.immutableProperty = 200 // 할당 불가
mutableClass.mutableProperty = 200 // 할당 가능

// 클래스는 참조 타입(포인터)이기 때문에 접근해서 인스턴스 프로퍼티의 값을 변경할 수 있다.
//immutableClass.immutableProperty = 200 // 할당 불가
immutableClass.mutableProperty = 200 // 할당 가능

// 다만 해당 참조 정보(포인터)를 변경할 수는 없다.
//immutableClass = mutableClass // 에러

class Student{
    var name: String = "unknown"
    var `class`: String = "Swift"
    
    static func selfIntroduce() {
        print("학생타입입니다. static 키워드 사용")
    }
    class func selfIntroduce2() {
        print("학생타입입니다. class 키워드 사용")
    }
    func instanceMathod(){
        print("인스턴스 메서드 입니다. 저는 \(self.class)반 \(name)입니다")
    }
}

var a: Student = Student()
a.name = "wansik"
a.class = "스위프트"
a.instanceMathod() // 인스턴스 메서드 입니다. 저는 스위프트반 wansik입니다
Student.selfIntroduce() // 학생타입입니다. static 키워드 사용
Student.selfIntroduce2() // 학생타입입니다. class 키워드 사용

class HighStudent: Student {
    override class func selfIntroduce2() {
        print("상속 받은 학생타입입니다. class 키워드 사용")
    }
    override func instanceMathod() {
        print("상속 받은 인스턴스 메서드 입니다. 저는 \(self.class)반 \(name)입니다")
    }
}

var b: HighStudent = HighStudent()
b.name = "jungmoo"
b.class = "iOS"
b.instanceMathod() // 상속 받은 인스턴스 메서드 입니다. 저는 iOS반 jungmoo입니다
// 슈퍼클래스의 함수는 다형성 때문에 사용가능
HighStudent.selfIntroduce() // 학생타입입니다. static 키워드 사용
// 재정의된 타입 메서드
HighStudent.selfIntroduce2()  // 상속 받은 학생타입입니다. class 키워드 사용

enum Weekday {
    case mon
    case tue
    case wed
    case thu, fri, sat, sun
}
// 열거형은 열거형에 정의된 case중의 하나를 변수로 매길수 있음
var day: Weekday = Weekday.mon // var day = Weekday.mon 이것도 되긴 함
day = .tue // day라는 것이 Weekday라는 열거형 타입이 명확하므로 케이스로 표현해도 가능

print(day) // tue

switch day {
case .mon, .tue, .wed, .thu:
    print("평일입니다. 일하세요.")
case Weekday.fri: // 이렇게 명시적으로 enum타입과 case를 적어도 됨
    print("금요일은 좀 쉬어야죠")
default:
    print("시체가 되는 주말입니다.")
}

switch day {
case .mon, .tue, .wed, .thu:
    print("평일입니다. 일하세요.")
case Weekday.fri: // 이렇게 명시적으로 enum타입과 case를 적어도 됨
    print("금요일은 좀 쉬어야죠")
case .sat, .sun:
    print("시체가 되는 주말입니다.")
}

enum Fruit: Int {
    case apple
    case grape = 3
    case peach // 굳이 설정하지 않을 경우 자동으로 1이 증가한 값이 할당됨
//    case mango = 0 // 불가능, 이미 순서대로 0, 1, 2가 들어간 상태
}

print(Fruit.apple) // apple
print(Fruit.apple.rawValue) // 0
print(Fruit.grape.rawValue) // 3
print(Fruit.peach.rawValue) // 4

enum School: String {
    case elementry = "초등"
    case middle = "중등"
    case high = "고등"
    case university
}

print(School.elementry, School.elementry.rawValue) // elementry 초등
print(School.middle, School.middle.rawValue) // middle 중등
print(School.high, School.high.rawValue) // high 고등
print(School.university, School.university.rawValue) // university university

let schoolLevel: School? = School(rawValue: "중등")
print(schoolLevel) // Optional(__lldb_expr_1.School.middle)

// 메서드도 추가가 가능하다.
enum Month {
    case dec, jan, feb
    case mar, apr, may
    case jun, jul, aug
    case sep, oct, nov
    
    func printMessage() {
        switch self {
        case .mar, .apr, .may:
            print("따스한 봄~")
        case .jun, .jul, .aug:
            print("여름 더워요~")
        case .sep, .oct, .nov:
            print("가을은 독서의 계절!")
        case .dec, .jan, .feb:
            print("추운 겨울입니다")
        }
    }
}

Month.mar.printMessage()

struct ValueType{
    var property = 1
}

let firstStructInstance = ValueType()
var secondStructInstance = firstStructInstance
secondStructInstance.property = 2

print(firstStructInstance.property) // 1
print(secondStructInstance.property) // 2

class ReferenceType {
    var property = 1
}

let firstClassInstance = ReferenceType()
var secondClassInstance = firstClassInstance
secondClassInstance.property = 2

print(firstClassInstance.property) // 2
print(secondClassInstance.property) // 2