Swift枚举-结构体-类

枚举-enum

1,Swift枚举不会被隐式赋予一个默认的整数值

enum CompassPoint {
  case North
  case South
  case East
  case West
}

2,多个值可以写在同一行上

enum Planet {
  case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}

3,枚举赋值
1,必须说明具体类型

    
    // 1.枚举类型的赋值
enum CompassPoint : Int {
  case North = 1
  case South = 2
  case East = 3
  case West = 4
}

enum Planet {
  case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune
}


// 2.枚举类型的使用
let p = Planet(rawValue: 3)

if let p = p {
    switch p {
    case .Mercury:
        print("Mercury")
    case .Venus:
        print("Venus")
    case .Earth:
        print("Mercury")
    case .Mars:
        print("Mars")
    case .Jupiter:
        print("Jupiter")
    case .Saturn:
        print("Saturn")
    case .Uranus:
        print("Uranus")
    case .Neptune:
        print("Neptune")
    }
}

结构体-struct

mutating(这个关键字修饰的方法,可以在该方法中修改struct的变量 --- 可以变身)

struct Location {
    var x : Double
    var y : Double

    init(x : Double, y : Double) {
        self.x = x
        self.y = y
    }

    init(xyString : String) {
        let strs = xyString.componentsSeparatedByString(",")
        x = Double(strs.first!)!
        y = Double(strs.last!)!
    }

    mutating func moveH(x : Double) {
        self.x += x
    }

    mutating func moveV(y : Double) {
        self.y += y
    }
}

使用extension可以扩展struct的方法

extension Location {
    mutating func moveH(x : Double) {
        self.x += x
    }

    mutating func moveV(y : Double) {
        self.y += y
    }
}

类-class

1,定义的类,可以没有父类,那么该类是rootClass
2,通常情况,继承自NSObject(非OC的NSObject)

class 类名 : SuperClass {
    // 定义属性和方法
}

属性

存储属性

class Student : NSObject {
    // 定义属性
    // 存储属性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0
}

// 创建学生对象
let stu = Student()

// 给存储属性赋值
stu.age = 10
stu.name = "why"

stu.chineseScore = 89.0
stu.mathScore = 98.0

计算属性

class Student : NSObject {
    // 定义属性
    // 存储属性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0

    // 计算属性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) / 2
        }

        // 没有意义,因为之后获取值时依然是计算得到的
        // newValue是系统分配的变量名,内部存储着新值
        set {
            self.averageScore = newValue
        }
    }
}

// 获取计算属性的值
print(stu.averageScore)

类属性

class Student : NSObject {
    // 定义属性
    // 存储属性
    var age : Int = 0
    var name : String?

    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0

    // 计算属性
    var averageScore : Double {
        get {
            return (chineseScore + mathScore) / 2
        }

        // 没有意义.newValue是系统分配的变量名,内部存储着新值
        set {
            self.averageScore = newValue
        }
    }

    // 类属性
    static var corseCount : Int = 0
}

// 设置类属性的值
Student.corseCount = 3
// 取出类属性的值
print(Student.corseCount)

监听属性

通过设置以下观察方法来定义观察者
• willSet：在属性值被存储之前设置。此时新属性值作为一个常量参数被传入。该参数名默认为newValue，我们可以自己定义该参数名
• didSet：在新属性值被存储后立即调用。与willSet相同，此时传入的是属性的旧值，默认参数名为oldValue
• willSet与didSet只有在属性第一次被设置时才会调用，在初始化时，不会去调用这些监听方法

class Person : NSObject {
    var name : String? {
        // 可以给newValue自定义名称
        willSet (new){ // 属性即将改变,还未改变时会调用的方法
            // 在该方法中有一个默认的系统属性newValue,用于存储新值
            print(name)
            print(new)
        }
        // 可以给oldValue自定义名称
        didSet (old) { // 属性值已经改变了,会调用的方法
            // 在该方法中有一个默认的系统属性oldValue,用于存储旧值
            print(name)
            print(old)
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在赋值时,监听该属性的改变
// 在OC中是通过重写set方法
// 在swift中,可以给属性添加监听器
p.name = "why"

//p.name = "yz"

类的构造函数

基本构造

1,类的属性必须有值
2,不在定义时初始化值,就在构造函数中赋值

class Person: NSObject {
    var name : String
    var age : Int

    // 重写了NSObject(父类)的构造方法
    override init() {
        name = ""
        age = 0
    }
}

// 创建一个Person对象
let p = Person()

自定义构造

通过自定义构造函数,在一个对象初始化的时候给属性赋值
会覆盖默认的构造init()方法,既不在有默认的构造函数

class Person: NSObject {
    var name : String
    var age : Int

    // 自定义构造函数,会覆盖init()函数
    init(name : String, age : Int) {
        self.name = name
        self.age = age
    }
}

// 创建一个Person对象
let p = Person(name: "why", age: 18)

类的析构函数

deinit {
    // 执行析构过程
}


class Person {
    var name : String
    var age : Int

    init(name : String, age : Int) {
        self.name = name
        self.age = age
    }

    deinit {
        print("Person-deinit")
    }
}

var p : Person? = Person(name: "why", age: 18)
p = nil

类和结构体的区别

Swift推荐在app中使用结构体(struct), 类(class)不处于主导地位

结构体能实现类的全部功能,它默认实现初始化方法

1,结构体只需声明变量类型

struct Restaurant {
    var name:String
    var type:String
    var location:String
    var image:String
    var isVisited:Bool
}

2,类要初始化变量的值

class Restaurant {
    var name:String
    var type:String
    var location:String
    var image:String
    var isVisited:Bool

    init(name:String,type:String,location:String,image:String,isVisited:Bool) {
        self.name = name
        self.type = type
        self.location = location
        self.image = image
        self.isVisited = isVisited
    }
}