//1.Swift可以定义枚举，结构体，类，3种面向对象的类型，面向对象的两大核心是类和对象
//2.面向对象编程的3大特征，封装，继承(Swift使用协议弥补了单继承灵活性不足的缺点)，多态
//3.C语言中结构体和枚举不具有面向对象的特征，Swift中多了结构体和枚举这两种程序单元


//1.枚举
//Swift的枚举不像c那么简单，是完全重新定义的类型，支持计算属性，实例方法，类型方法，支持定义构造器来完成初始化，允许通过扩展来增强原有枚举的功能，允许遵守指定协议来提供标准的功能
//1.1定义枚举，使用enum
//语法格式，枚举名首字母大写
/** * enum 枚举名 { //使用case关键字列出所有的枚举值 //枚举的其他成员 } */
enum People
{
    //每一个case定义一个枚举实例
    case Man
    case Female
}

enum StrongPeople
{
    //一个case 定义多个枚举实例
    case Man,Female
}

/** * 面向对象编程的五大点（牢记） 1，声明变量 2.创建实例 3，访问类型属性 4调用类型方法 5，派生子类，但是Swift只有类支持继承，枚举和结构体不支持继承 */

//使用枚举声明变量
var manPeople :StrongPeople
//赋值
manPeople = StrongPeople.Man
//当Swift能推断出枚举类型时，允许省略枚举名前缀
//manPeople = .Man
println(manPeople)

//1.2枚举值和switch语句
var choosePeople = StrongPeople.Man
//使用switch语句判断枚举
//是个男的
switch (choosePeople)
{
case StrongPeople.Man:
    println("是个男的")
case StrongPeople.Female:
    println("是个女的")
}

//带有原始值的枚举
//需要注意的是，Swift可以通过已指定的原始的枚举来推断它前后的枚举值
/** * enum 枚举名 : 原始类型 { case 枚举值 = 原始值 } */

//定义枚举，原始值类型为Int
enum Weekday : Int
{
    //使用一个case,swift推断Monday= 0,Thursday = 6,Friday = 7
    case Monday,Tuesday = 1,Wednesday = 5,Thursday,Friday
}

//如果指定的原始值类型不是Int，而是String，Character，Swift不能推断枚举的原始值
enum Season : Character
{
    case Spring = "S"
    case Summer = "U"
}

var day = Weekday.Monday
//获取枚举值的原始值
println("\(day.rawValue)")//0
day = .Thursday
println("\(day.rawValue)")//6

//根据原始值获取枚举值
//is U
var mySea = Season(rawValue: "S")
if mySea != nil
{
    switch mySea!
    {
    case .Spring:
        println("is U")
    case .Summer:
        println("is S")
    }
}

//rawValue是枚举值的属性，该属性用于获取枚举的原始值

//关联值，Swift不要求各枚举成员具有相同的关联值 associated value
/** * 语法格式 case 枚举值（元组语法） */
//定义枚举
enum Plant
{
    //不同枚举值可以携带数量不等，类型不等的关联值
    case Mercury(weight:Double,density:Double,name:String)
    case valus(Double,Double)
    case Jupiter
    case Saturn
}

//引用类型的比较
//===,!==返回true，false

//self关键字

class Dog1
{
    //实现一个jump的方法
    func jump()
    {
        println("正在jump")
    }

    //实现一个跑的方法
    func run()
    {
        jump()
// self.jump()
        println("正在跑")
    }
}


//局部变量隐藏存储属性
class Wolf
{
    //定义两个属性
    var name : String = ""
    var age : Int = 2
    //显示定义带参数的构造器
    init (name :String,age : Int)
    {
        //当局不变量隐藏存储属性时
        //可用self代表调用该构造器正在初始化的实例
        //这个可以为该构造器正在初始化的实例的存储属性赋值

        self.name = name
        self.age = age
    }
    //定义一个info
    func info()
    {
        println("\(name),\(age)")
    }
}
var wolf = Wolf(name:"JiangJum",age: 24)
wolf.info()//JiangJum,24

//当self作为方法的调用者
class ReturnSelf
{
    var age : Int = 0
    func grow() -> ReturnSelf
    {
        age++
        return self
    }
}
var rt = ReturnSelf()
rt.grow()
    .grow()
    .grow()

println("\(rt.age)")//3

struct FixedLengthRange {
    var strat :Int
    let length : Int
    //由于系统会为该结构体提供初始化所有存储属性的构造器
    //因此程序可以在定义时不为实例存储属性指定初始值

}

//初始化
var rg = FixedLengthRange(strat: 2,length: 3)
println("\(rg.strat),\(rg.length)")//2.3

rg.strat = 5
//rg.length = 6//常量存储属性，无法重新赋值

struct FkRange {
    //定义两个变量存储属性
    var start : Int
    var length : Int
}

let rg1 = FkRange(start: 3,length: 4)
println("\(rg1.start),\(rg1.length)")//3,4
//rg1.strat = 4//编译错误
//由于实例被赋值给一个let声明的常量，因此FkRange就是一个不可变的，不允许修改


//lazy load 懒加载
class Dept3
{
    var id : Int
    var info : String
    init (id : Int)
    {
    self.id = id
        //暂停2秒
        NSThread.sleepForTimeInterval(2)
    self.info = "模拟读取数据"
    }
}

class User {
    var id : Int = 0
// var dept = Dept3(id: 4)
    lazy var dept = Dept3(id: 3)
    var nicks = [String]()
}
//创建user实例
var user = User()
user.nicks.append("JiangJun")
user.nicks.append("jiangjum")
println(user.nicks)