1. 枚举: 

      ->在Swift中依然适用整数来标示枚举值,需搭配case关键字

       enum  Celebrity{  case DongXie,XiDu,Nandi,BeiGai }  // 从左到右对应0,1,2,3

enum CompassPoint {

  case North

  case South

  case East

  case West

  //enum中可以定义方法

    func show(){

      print(self)

    }

}   

//定义enum 变量

var p = CompassPoint.North

var p2 = CompassPoint.South

p.show()

p2.show()

var point:CompassPoint = .West

switch point{

case .North:

    print("北")

case .South:

    print("南")

case .East:

    print("东")

case .West:

    print("西")

}

enum Week:Int {

   case Sun, Mon, Tur, Wen, Thu, Fri, Sat

}

 //原始的(裸值)需要进行类型标注，

// notice:这里通过调用枚举类型  Week 调用 枚举成员Sun 裸值(及C中所述的枚举整型值),需要在赋值的变量后面加上的的类型标示符号

var  weekDay:Int = Week.Sun.rawValue 

//也可以直接通过Week的 rawValue方法调用得道当前的 枚举成员

var week:Week? = Week(rawValue:7)  //这里如果rawValue 超出了枚举值的返回，则返回为空，所以week需要使用可选值来接收

//还可以利用元组特性设置关联的枚举成员

enum BarCode {

    case UIPCA(Int,Int,Int)  //条形码

    case QRCode(String)     //二维码

}

//定义个枚举变量

var barcode = BarCode.UPCA(690,3322323,2)

barcode = Bar.QRCode("http://fdsafdsfa.com")

switch barcode {

  case BarCode.UPCA(let(num,id,check)):

    print("这是一个条形码 \(num)-\(id)-\(check)")

case BarCode.QRCode(let string):

     print("这是一个二维码 对应的字符串是:\(string)")

}

}

/**使用新的写法,在绑定变量的同时，指定条件判断，类似于SQL*/

switch aPoint {

    //在绑定一个变量的同时,可以绑定x == y

  case let(x,y) where x == y:

    print("x 与 y相等斜线上 x ＝ y")

case let(x,y) where x == -y:

    print("x 与 －y斜线上 x = -y")

  default:

    print("other")

}

2. 结构体和类：

    相同点： 

    结构题和类，都在定义一种类型

    都可以在内部定义属性和方法

    都可以定义下标运算符

    都可以定义初始化方法(Int 初试化器,  构造器  构造方法)

    都可以使用扩展现有的功能(OC中有分类，Swift中没有分类,叫扩展)   

    都可以遵循制定的协议

    不同点:

    类可以继承，结构体不能

    类有多态，结构体没有

    类的内存支持自动引用技术，结构体不支持引用技术，结构体变量都是在栈中分配内存空间,不需要手动管理

    类是引用类型 结构体是值类型     

//属性的初始化就提供了一个无参 和统一的初始化器

struct Resolution {

   var width = 0.0

   var height:Float = 0.0

}

//类中申明属性必须进行初始化，除非它是可选值

class VideoMode {

   var resolution = Resolution()

   var interlocaed = false

   var frameRate = 0.0

   var name:String?

}

//结构体是值类 类是引用类型

var res = Resolution()

var res2 = res

res.width = 1024

res2.width

var vmode = VideoMode()

var vmode2 = vmode

vmode.name = "zhanshang"

vmode2.name

/** ===比较地址是否相等*/

if vmode === vmode2 {

   print("两个引用是同一个值")

}

if vmode2 !== vmode {

   print("两个引用不是同一个地址")

}

/** 结构体的统一初始化器,这与C中的结构题嵌套非常相识，紧紧是指把变量的定义方式改变了一下，另外支持 点语法访问层级嵌套属性*/

struct Point {

    var x :Float

    var y :Float

}

struct Size {

    var w :Float

    var h :Float

}

struct Rect {

    var origin: Point

    var size: Size

}

var rect = Rect(origin: Point(x: 100, y:20), size: Size(w : 2 ,h: 3))

rect.size.w

rect.origin.x

3. 属性,在Swift中属性有两个分类方式

    第一种方式:

/**

1. Swift中属性有两个分类方式

   第一种方式:

   -> 存储属性(Stored Properties):用变量或者常量来保存属性值

   -> 计算属性(calculate Properties): 通过计算得来的。

    举例:

    出生日期: 存储树形 ， 年龄:需要通过两个时间进行计算

   -> 第二中分类方式:

      实例属性 和 类型属性

*/

// 存储属性

struct MyRange {

    var location:Int

    let length:Int

}

var myRnage = MyRange(location: 0, length:100)

struct Point {

    var x = 0.0, y = 0.0

}

struct Size {

    var w = 0.0, h = 0.0

}

struct Rect {

    //存储属性,使用变量或者常量来保存存储属性

    var orign = Point()  //创建 point对象

    var size =  Size()   

    var center: Point {

        get{

           let centerX = orign.x + size.w * 0.5     

           let centerY = orign.y + size.h * 0.5

            return Point(x: centerX, y: centerY)    //返回一个point类型 

        }

        //这里如果没有参数 则使用默认的 newValue

        set{

            let newOrignX = newValue.x - size.w * 0.5   

            let newOrignY = newValue.y - size.h * 0.5

            orign = Point(x: newOrignX, y: newOrignY)    //实现origin的赋值

        }

        /* set(newCenter){

        let newOriginX = newCenter.x - size.w * 0.5   

        let newOriginY = newCenter.y - size.h * 0.5

        origin = Point(x: newOriginX, y: newOriginY)

        } */

        //假设做一个只读的计算属性

    }

    //如果只读计算属性，只有一行代码可以省略return

    var center2:Point {

        get {

            return Point(x: 500 + 100,y: 100)

        }

    }

}

var rect = Rect(orign:Point(x: 0, y: 0), size: Size(w:300,h: 200))

rect.center.x

rect.center.y

rect.center = Point(x: 200, y: 200)

rect.orign.x

rect.orign.y

/** 延迟属性 类似 OC的懒加载，或者延迟加载*/

class DataImporter {

    init(){

      print("DataImporter create")

    }

    var fileName = "data.txt"

    //这个需要用到的时候才去加载

}

class DataManager {

    lazy var dataImporter = DataImporter()

}

//创建DataManager这个对象

var dataManager = DataManager()

/**在需要执行懒加载的属性前面加上layz*/

dataManager.dataImporter

4. 属性监视器:是一段代码，这段代码会在属性发生变化的时候自动调用  

    ->计算属性，延迟属性，不能设置监视器，只有存存储属性才能设置监视器 

    ->属性监视器，在属性初始化的时候不调用

    ->属性监视器有两种，willSet,didSet

class StepCounter {

    var labelText = " text content"

    /**storeage property*/

    var  a :Int = 10

    //只读计算属性

    var b:Int {

      return 10

    }

    // 给属性 加属性监视器

    var totalSteps:Int = 10 {

        willSet (newValue){

           print("属性将要变化时调用 要改变成\(newValue) 现在是\(totalSteps)")

        }

        didSet{

          print("属性值已经发生改变了嗲用原来的值时\(oldValue)现在是\(totalSteps)")

          labelText = "改变的值时\(totalSteps)"

        }

    }

}

   var propertyName:Int = 10{  willSet(newValue){ //inserCode here  }  didSet{  //insertCode here } }

var stepCounter = StepCounter()

stepCounter.totalSteps = 50

stepCounter.labelText

stepCounter.totalSteps = 20

stepCounter.labelText

5. 类型属性:

    在结构体或者枚举中，使用static修饰的属性以及在类中使用class关键字修饰的属性叫做类型属性，属于整个类和对象无关。

   在struct 中定义的类型属性，可以是存储属性，也可以是计算属性

   在class 中定义的类型属性，只能是计算属性(如果需要使用存储树形座位设计类型属性，可以加上static关键字)

struct SomeStrut {

    //存储属性

    var a = 10

    //计算属性

    var b:Int {

      return 10

    }

    //类型属性

    static var x = 10

    static var y:Int {

       return  10

    }

}

var someStruct1 = SomeStrut()

someStruct1.a    //10

var someStruct2 = SomeStrut()

someStruct2.a    //10

SomeStrut.x   //10

SomeStrut.y   //10

class SomeClass {

    var a = 10

    var b :Int {

     return 10

    }

    /** 类型属性,太奇葩了*/

    static var y :Int {

      return 100

    }

    class var x:Int {

       return 100

    }

    static var storeagePorperty:Int = 10 //编译通过。优先使用static

    // Swift编译无法通过❌class var storagePorperty1:Int = 100

}

SomeClass.y

SomeClass.storeagePorperty = 123

SomeClass.x

6.实例方法，类方法，几乎同OC一样

//实例方法 与类方法，类中的实例方法几乎和OC一样

/** 类类型的实例方法*/

class Counter{

    var count = 0

    func increment(){

        count++

    }

    func incrementBy(amount: Int){

        count += amount

    }

    func incrementBy(amount: Int ,numberOffTimes: Int) {

        count += amount * numberOffTimes

    }

}

/** create a instance */

var counter = Counter()

/** invoke instance method*/

counter.increment()

/** 值类型的实例方法 */

struct Point {

  var x = 10, y = 10  //实例 值类型属性，由对象调用，或者对象 self指针调用

  var z = 250

  static var sx = 10   //类类型属性，由类调用，或者类 self指针调用

    func show() {

      print("点点\(x)")

      Point.sx = 1111

    }

  //值类型的实例方法，默认不可以修改实例属性，如果非要修改则加上mutating

     mutating func setX(px: Int,AndY y:Int) {

      // x = px 

        self.x = px

      //防止参数和属性重名

        self.y = y

        Point.sx = 111

    }

}

enum StatusSwitch{

   case Study,Dining,Review,Sleep

   func show(){

        switch self{

        case .Study:

         print("正在学习")

        case .Dining:

         print("正在吃饭")

        case .Review:

         print("正在复习")

        case .Sleep:

         print("正在睡觉")

        }

    }

    /** 切换状态, 这里如果想修改self需要在前面加上 mutating*/

    mutating func nextStatus(){

        switch self {

        case .Study:

            print("下一步吃饭")

            self = .Dining

        case .Dining:

            print("下一步 去复习")

            self = .Review

        case  .Review:

            print("下一步 去睡觉")

            self = .Sleep

        case .Sleep:

            print("下一步 去学习")

            self = .Study

        }

    }

}

var ss = StatusSwitch.Study

ss.show()

ss.nextStatus()

ss.nextStatus()

ss.nextStatus()

ss.nextStatus()

ss.nextStatus()

ss.nextStatus()

ss.nextStatus()

ss.nextStatus()

7. 类型方法：

//类型方法 和 OC中的类方法，含义相同

class SomeClass {

    var prop:Int = 0   //实例属性必须要有了对象之后能方位

    class var a:Int {   //类属性 ，class也可以使用static

        return 10

    }

    func instanceMethod() {

      print("this is a instance method")

      self.prop

      SomeClass.a

        //self.a  a为类属性，所以无法调用

    }

    class func typeMethod(){  // class func 代表定义个类方法

        print("这是一个类型方法")

         //同OC，类方法中不能访问实例属性,但是可以访问类型属性

        // self.prop

        self.a  //self带表调用这个方法的对象，self相当于调用类方法的对象，类对象

        SomeClass.a

    }

}

var p = SomeClass()

p.prop

SomeClass.a

//类方法的调用

SomeClass.typeMethod()

//先创建一个类的对象－》

var instanceObject = SomeClass() //类名+()可以创建一个类的对象

instanceObject.prop

instanceObject.prop = 10

instanceObject.prop

struct SomeStruct {

    var prop:Int = 0

    /**声明一个static的存储属性*/

    static var a: Int = 0

    func show(){}

    func instanceMethod(){

     //此处实例属性可以读但是不能修改   prop = 1000,如果需修改采用 

        self.show()

        print(prop)

    }

    /**结构体中， 类方法使用static,在类中可以使用static和class定义类方法和变量方法, C++里面叫做静态方法,但是在结构体中只能是static */

    static func typeMethod(){

       print("这是一个类型方法")

       //self.show() 实例方法，❌，此处无法使用

    }

}

/**枚举中 类型方法*/

enum StatusSwitch {

  case Study,Dinig,Review,Sleep 

  static func typeMethod() {

    print("这是一个类型方法")

  }

  static func create()->StatusSwitch {

    return self.Study  //StatusSwitch 类对调用 create 类方法，self 指向StatusSwitch，所以返回为StatusSwitch类型

  }

  func show() {

        print("这是一个实例方法")

  }

}

StatusSwitch.create().show() //  

StatusSwitch.Study.show() //与上面等价   //枚举成员可以调用枚举类的方法,这样理解会好记一点，搞不明白的就暂时当成一种格式来记，等代码积累量上去了再回过头来研究。

8. 下标脚本,主要用于检查数组边界是否越界;使用断言的方式

class MyArray {

     //private 私有的,越界返回真，不越界返回假

    pravate var array = [0,1,2,3,4,5,6,7,8,9]

     func indexIsValid(index:Int) -Bool {

     if index < 0 || index >array.count - 1 { return ture } else { return false }

     /**增加数据*/

     func addObjectAtIndex(index:Int ,object:Int) {

     assert(indexIsValid(index))

     array.insert(object,atIndex:Index)

}

     func show(){   print(array)  }    

} 

    //让MyArray支持下标，写法一

      定义一个 通过subscript构建一个整型的下标函数，创建set 和 get方法,其中set方法中newValue和数组赋值时,外界传入的形参

     subscript(index:Int)->Int {

     get {  return array[index] }

     set {  array[index] = newValue }

}  

   方法二：通过改写set方法

    subscript(index:Double)->Int {

    get{ return  array[Int(index + 0.5)]}

    set{  array[Int(index + 0.5)] = newValue }

//此处的newValue为set方法调用时外部带的参数 类似于 (int)setnewValue:(int)newValue

}

var myArray = MyArray()

myArray.show()

myArray.addObjectAtIndex(1, object: 100)

myArray.show()

myArray.array + [30,300]

myArray.array.removeAtIndex(5)

myArray.show()

myArray.array[0]

9. 继承:

   父类 子类 (基类，派生类) 

   Swift中的特点: 一个类可以没有父类,不像OC所有的类都继承于NSObject，Swift中是单即成类，一个类只能由一个父类，但是可以有多个子类。

class Vehicle {

   //存储属性  storage properties

    var currentSpeed = 0.0

   //计算属性 calculate properties

    var description:String {

      return "当前速度是每小时\(currentSpeed)公里"

    }

    func makeNoise() {

      print("父类发生的方法")

    }

    func show(){

      print("父类显示的方法")

    }

}

/** inheritance*/

class Bicycle: Vehicle {

    /** extension propertie*/

    var hasBasket = false

    /** extension method*/

    func test(){

       print("subClass extension method")

    }

    /** override parent method*/

    override func makeNoise() {

       print("subClass dong dong ...")

    }

}

var bike = Bicycle()

bike.show()

bike.makeNoise()

bike.hasBasket

bike.currentSpeed

/**父类型指向子类型,前面obj为交通对象，makeNoise重写后被覆盖,先调用子类的方法

*/

var obj:Vehicle = Bicycle()

obj.makeNoise()

}

 /**

覆盖父类的方法只需要在方法前面使用override关键字， override func 。。。。

重写父类属性只需要在子类定义与父类相同的属性，并在后面加上{  didSet{  //inertCode 需要重写的内容 } }

在父类中 变量和方法前面只要加上 final关键字则表示该方法不能被重写

*/

class  Car : Vehicle{

    var  gear = 1

    // 重写覆盖父类的方法

    override func  makeNoise(){

        print("汽车滴滴")

    }

    // 重写计算属性

    override var  description : String {

        return  super.description + "在\(gear)档上"

    }

    // 重写父类的存储属性

    override var currentSpeed : Double{

        didSet{

            gear = Int(currentSpeed/10.0) + 1

        }

    }

}

var  car = Car()

car.gear

car.currentSpeed = 40

car.description

car.gear

/*final */ class Base { // 限制这个类不能被继承

    final var  a = 10 // final 不能被重写

    final func show(){ } //final 的方法不能被重写

}

class Child: Base {

}

// 开发中还有一种常见的形式 组合

class Radio{

    var  price : Double = 0.0

    func radio(){

        print("收听广播")

    }

}

class  MyCar{

    var radio = Radio()

}

var  mc = MyCar()

mc.radio.radio()

mc.radio.price = 10000000