1.属性

属性区分为：存储属性 和 计算属性 swift创建实例对象要求必须所有存储属性有初始值
1.存储属性:
类似于成员变量，在实例对象中有内存

2.计算属性：
本质上就是方法（类似于OC 分类中添加属性， 生成对应的方法，但是并不会占用实例对象内存）
如果需要声明自读（readOnly）属性，只需要实现get方法即可

class TestClass {
    /// 存储属性
    var name : Int
    /// 计算属性 （自动生成get set方法 set方法参数默认为：newValue）
    var age : Int {
        set{
            
        }
        
        get{
            22
        }
    }
}

延迟存储属性

用lazy修饰存储属性，在初始化实例对象时用lazy修饰的属性并不是即时创建，但是还是必须有初始值，用lazy修饰的属性是在使用到这个属性的时候才会创建分配内存。
注意： 用lazy修饰的属性，只能使用var定义。

lazy var name : String = "shine"

属性观察器 （Property Observer）

类似于OC中的kvo,属性观察期只能使用于不被lazy修饰的存储属性，swift中直接在存储属性中实现willSet 和 didSet 方法

class Shine {
    
    var money : Double {
        willSet{
            /// 默认参数 newValue
            print(newValue)
        }
        didSet{
            /// 默认参数 oldValue
            print(oldValue, money)
        }
    }
}

~父类的属性观察器在自己的初始化器中赋值不会触发，但是在子类的初始化器中赋值会触发属性观察器

inout关键字

本质上就是地址传递
1.使用inout修饰的参数，如果有物理内存地址，且没有属性观察器，会直接修改该物理地址的值
2.对于其他情况，比如：计算属性， 属性观察期； 则采取的是copy In copy Out的操作，先把改值copy in到一块临时内存，经过处理后再copyOut到你写入的属性的内存中。

类型属性（Type Property）

·类似于OC的类对象的属性， 但是类型属性的内存地址在全局区，并不是在类对象的内存中
·只不过这个全局变量关联了类型

static var name: String = "shine"///必须有初始值

2.方法

方法的定义：方法分为实例方法（instance method）和类型方法（type method）基本等同于OC

实例方法（Instance Method）

通过对象调用

    var name = "shine"
    
    func printName() -> Void {
        print(self.name)
    }

类型方法（Type Method）

通过类型调用

    static func printClassName() -> Void {
        print(type(of: self))
    }

3.下标（subscript）

subscript(index: Int) -> Void {
        
        set{
            
        }
        
        get{
            
        }
        
    }

subscript可以没有set方法，但是必须有get方法

4.继承（Inheritance）

• 值类型不支持继承，只有类支持继承
• swift可以没有基类，没有基类，自己就是基类
• 子类可以重写父类的方法，下标，属性，需要加上override关键字

5.内存结构

swift的类的内存结构默认有16个字节，前8个字节存储类型信息，后8个字节存储引用计数相关信息，再往后才是存储属性的内存，并且64位系统对齐方式是16位

6.多态

父类的指针指向子类对象

• swift中的多态技术使用的是数据结构中的续表

7.初始化

• swift中的初始化分为两种，指定初始化，和便携初始化

class Animal {
    var name : String = "大黄"
    var age : Int = 7
    
    // 指定初始化
    init() {
        
    }
    
    // 便携初始化
    convenience init(name: String, age: Int) {
        // 内部必须调用指定初始化
        self.init()
        self.name = name
        self.age = age
    }
    
}

• 如果指定初始化器用require修饰，子类可以不重写任何初始化器，获取用require修饰指定初始化器

class Animal {
    var name : String = "大黄"
    var age : Int = 7
    
    
    required init() {
        super.init()
    }
    
    
    convenience init(name: String, age: Int) {
        self.init()
        self.name = name
        self.age = age
    }
    
}


class Dog: Animal {
    
    var species: String = ""
    
    required init() {
        
    }
    
     init(category : String) {
        super.init()
    }
    
}

• 可失败初始化器

class Person {
    var name : String
    init?(name: String) {
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
}

8.反初始化（deinit）

• 反初始化器，类似于OC中的dealloc
• 当实例对象释放内存是会调用实例对象的deinit方法
• 子类的deinit调用结束会调用父类的deinit

class Person {
    deinit {
        // person对象呗销毁
    }
}