Swift3.0 - 属性

Swift3.0 - 真的很简单
Swift3.0 - 数据类型
Swift3.0 - Array
Swift3.0 - 字典
Swift3.0 - 可选值
Swift3.0 - 集合
Swift3.0 - 流控制
Swift3.0 - 对象和类
Swift3.0 - 属性
Swift3.0 - 函数和闭包
Swift3.0 - 初始化和释放
Swift3.0 - 协议protocol
Swift3.0 - 类和结构体的区别
Swift3.0 - 枚举
Swift3.0 - 扩展
Swift3.0 - 下标
Swift3.0 - 泛型
Swift3.0 - 异常错误
Swift3.0 - 断言
Swift3.0 - 自动引用计数(strong,weak,unowned)
Swift3.0 - 检测API
Swift3.0 - 对象的标识
Swift3.0 - 注释
Swift3.0 - 元类型
Swift3.0 - 空间命名
Swift3.0 - 对象判等
Swift3.0 - 探究Self的用途
Swift3.0 - 类簇
Swift3.0 - 动态调用对象(实例)方法
Swift3.0 - 文本输出
Swift3.0 - 黑魔法swizzle
Swift3.0 - 镜像
Swift3.0 - 遇到的坑

• 存储属性

a.你应该注意的

1.类和结构体中,不能在枚举中使用
2.不能被子类重写,但可以在子类中给它添加监测功能

b.定义

struct Range {  // 结构体定义存储属性
    let first:Int
    var length:Int
}
class Student{  // 类定义存储属性
    var name:String!
    var score:String!
}

• 计算属性

a.能在哪里使用

类 、结构体、枚举

b.定义

1.结构体使用

struct Range {
var first:Int
var length:Int
var myFirst:Int{  // 有setter 和 getter的计算属性
    set{
        first = newValue
    }
    get{
        return first
    }
}

var myLength:Int{ // 只有get方法计算属性
    get{
      return length
    }
  }
}

2.枚举中使用

enum Person : String{
    case Man = "男"
    case Women = "女"

    // get
    var name:String{
        return self.rawValue
    }

    // setter  getter
     var rename:String{
    set(newName){
        self = Person(rawValue: newName)!
    }
    get{
        return self.rawValue
    }
}
}

var person  = Person.Man
print(person.name)
person.rename = "女"
print(person.rawValue)

运行结果:

男
女

提示:

1.如果计算属性只有getter 方法,那么这个get 可以被省略
2.setter 可以设置新值名字,如果没有设置默认为newValue
3.let 不能修饰计算属性

• 监测属性

  例子1:

class Circle{
    var area:Double = 0.0
    var r:Double = 0.0 {
        willSet{
            area = Double.pi*newValue*newValue
        }
    }    
}
let circle = Circle()
circle.r = 10.0
print(circle.area)

运行结果:

0.0
314.159265358979

例子2:

class Circle{
   lazy var area: Double = 0.0
    var r:Double = 0.0 {
        willSet{
            print("有新值")
            area = Double.pi*newValue*newValue
        }
    }
}
let circle = Circle()
func calcalate(r:inout Double){
   print("函数执行开始")
   r = 2.0
print("函数执行结束")
}
calcalate(r: &circle.r)

运行结果:

函数执行开始
函数执行结束
有新值

提示:

1.监测属性,其实是给存储属性上添加的一种监测功能,willSet 监测新值,didSet 监测旧值
2.如果函数的参数是inout 修饰的,你如果将监测的属性传入这个函数的时候,此时会将属性的值拷贝一份,在函数结束的时候,将值重新付给属性,所以函数执行完毕后,会触发监测函数

• Lazy 关键字使用(只能用于存储属性)

使用时Lazy必须注意

1.只能用于存储属性
2.修饰的属性必须有初始化
3.在结构体中使用Lazy 修饰的属性,在访问的方法前必须加mutating 修饰
4.不能用于全局属性或者静态变量
5.存储属性被lazy修饰,只被初始化一次,在多线程访问时,不需要使用lazy标记

例子:

struct Animal{
lazy var name = "动物"
mutating func calculate(){
    let name = self.name
}
var myName: String{ // 只有get方法计算属性
    mutating get{
        return name
    }
}

• static 和 class 关键字的用法

相同点:

1.可以修饰方法,static 修饰的方法叫做静态方法,class修饰的叫做类方法
2.都可以修饰计算属性

不同点:

class 不能修饰存储属性
class 修饰的计算属性可以被重写,static 修饰的不能被重写
static 可以修饰存储属性,static修饰的存储属性称为静态变量(常量)
static 修饰的静态方法不能被重写,class 修饰的类方法可以被重写
class 修饰的类方法被重写时,可以使用static 让方法变为静态方法
class 修饰的计算属性被重写时,可以使用static 让其变为静态属性,但它的子类就不能被重写了
class 只能在类中使用,但是static 可以在类,结构体,或者枚举中使用

下面是个例子:

class Person{
 static var describe:String = " 这是一个人类"
 class var score:Int{
    return 0
 }
 // class 修饰的类方法可以被子类重写,static 修饰的静态方法不能被重写
 class func  getScore()->Int{
    return score
 }
}

class Man: Person {

// 重写计算属性 可以使用static 来重写哦,但是static 重写后,就不能被它的子类再次重写了
 class override var score:Int{
    return 1
}

// 重写类方法时可以使用static 让其变成静态方法
static override func  getScore()->Int{
    return score
}
}

帮你撸清这些东西

1.参数是闭包执行的结果 和 参数是闭包

class Person{
    var name:String
    var score:Int
    init(name:String,score:Int) {
        self.name = name
        self.score = score
    }
    let describe: String = {
        print("闭包已经执行")
        return "我在\(getTime())被创建了"
    }()
}
// 获取时间
func getTime()-> Date{
    return Date()
}
let p = Person(name: "酷走天涯", score: 3)

运行结果:

闭包已经执行
Program ended with exit code: 0

分析:

属性describe 是一个String 类型 ,获取闭包函数执行的结果

其实和下面的代码是一个意思

class Person{
var name:String
var score:Int
init(name:String,score:Int) {
    self.name = name
    self.score = score
}
let describe: String = myDescribe()
}

// 获取时间
func getTime()-> Date{
    return Date()
}
func myDescribe()->String{
    return "我在\(getTime())被创建了"
}
let p = Person(name: "酷走天涯", score: 3)

注意:

属性 = 号后面的函数不能定义在类内,因为初始化未完成之前是不能调用对象方法的

接下来我们看参数是闭包

class Person{
    var name:String
    var score:Int
    init(name:String,score:Int) {
        self.name = name
        self.score = score
    }
    // 注意看和上面的区别
    let describe: ()->String = {
        print("闭包被执行了")
        return "我在\(getTime())被创建了"
    }
    }

// 获取时间
func getTime()-> Date{
    return Date()
}
func myDescribe()->String{
    return "我在\(getTime())被创建了"
}
let p = Person(name: "酷走天涯", score: 3)

运行结果:

啥都没有

分析:

属性describe 是一个()->String 类型,后面跟的是他的值,它的值刚好是一个闭包类型 ,但是没有执行,我们让它执行一下

添加下面代码

let pd = p.describe()

运行结果

闭包被执行了
Program ended with exit code: 0

其实我们还可以使用下面的等价代码

class Person{
    var name:String
    var score:Int
    init(name:String,score:Int) {
        self.name = name
        self.score = score
    }
    let describe: ()->String = myDescribe
}
// 获取时间
func getTime()-> Date{
    return Date()
}
func myDescribe()->String{
    return "我在\(getTime())被创建了"
}
let p = Person(name: "酷走天涯", score: 3)
let pd = p.describe()

搞清楚上面两者的区别,我们做一个练习

需求: 有个自定义类,类中有一个数组,数组中包含20位斐波那契数列

class Calculate{
    var fibo:[Int] = {
       // 定义一个数组
        var nums:[Int] = []
        func Func(n:Int)->Int{
            if n < 2{
                return n
            }else{
                return Func(n: n-1)+Func(n: n-2)
            }
        }
        for i in 0..<20{
            nums.append(Func(n: i))
        }
        return nums
    }()
}
let c = Calculate()
print(c.fibo)

运行结果:

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]
Program ended with exit code: 0