关键字修饰)和常量存储属性(由,属性可以将值与

作者: 编程  发布:2019-11-21

属性

苹果官方文档 Properties

苹果官方文档翻译 属性

属性可以将值与特定的类、结构体或者是枚举联系起来。

1. 存储属性

存储属性包括变量存储属性(由var关键字修饰)和常量存储属性(由let关键字修饰)。

// 定义了一个名为 FixedLengthRange 的结构体
struct FixedLengthRange {
    var firstValue: Int   // 变量存储属性
    let length: Int       // 常量存储属性
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
// rangeOfThreeItems 代表整数范围为 0, 1, 2
rangeOfThreeItems.firstValue = 6
// rangeOfThreeItems 的整数范围现在为 6, 7, 8

注意: 上面栗子中,rangeOfThreeItems实例一旦创建并为常量属性length分配值,则length不能再赋新值,这也是常量属性和变量属性的根本区别。

属性可以将值与特定的类、结构体或者是枚举联系起来。

本页内容包括:

存储属性
计算属性
属性观察器
全局变量和局部变量
类型属性

属性的定义:属性将值跟特定的类、结构或枚举关联。存储属性存储常量或变量作为实例的一部分,计算属性计算(而不是存储)一个值。计算属性可以用于类、结构体和枚举里,存储属性值只能用于类和结构体。

存储属性

struct FixedLengthRange {
    var firstValue: Int
    let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
rangeOfThreeItems.firstValue = 6
// the range now represents integer values 6, 7, and 8

常量结构体实例的存储属性

如果把结构体的实例赋给常量,则不能修改这个实例的属性,即使是声明为变量的属性:

let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// rangeOfFourItems表示的整数范围为 0, 1, 2, 3
rangeOfFourItems.firstValue = 6
// 即使firstValue是变量属性,这里也会报错,因为rangeOfFourItems是一个常量结构体

总结: 由于结构体是值类型,当一个值类型的实例被标记为常量时,该实例的其他属性也均为常量。
而类是引用类型,给一个常量赋值引用类型实例,仍可以修改那个实例的变量属性。

一、简介

一、存储属性

即:存储在特定类或结构体的实例里的一个常量或变量
//例子

struct LengthRanuge {
    var firstValue: Int
    let length: Int
}

var rangeOfThreeItems = LengthRanuge(firstValue: 0, length: 3)
该区间表示整数0,1,2
rangeOfThreeItems.firstValue = 6
该区间表示整数6,7,8
该结构体的实例包含一个名为firstValue的变量存储属性和一个名为length的常量存储属性。length在创建实例的时候被赋值,因为是一个常量存储属性,之后无法修改它的值。

常量结构体实例的储存属性

let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// this range represents integer values 0, 1, 2, and 3
rangeOfFourItems.firstValue = 6
// this will report an error, even though firstValue is a variable property

延迟存储属性

延迟存储属性的初始值在其第一次使用时才进行计算,可以通过lazy var修饰语来表示一个延迟存储属性。(延迟存储属性一定是变量,因为它的初始值可能在实例初始化完成之前无法取得。常量属性则必须在初始化完成之前有值,因此不能声明为延迟。)
举个栗子:

// 假装DataImporter类用来导入数据,是一项耗时的操作。
class DataImporter {
    var fileName = "data.txt"
}

// 假装DataManager类用来管理数据
class DataManager {
    lazy var importer = DataImporter()
    var data = [String]()
}

let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")
// manager初始化后,其importer属性并未赋值给它一个DataManager类的实例,
// 因为它是lazy修饰的延迟存储属性,只有第一次使用它时这个属性才会真正被赋值,如:

print(manager.importer.fileName)
// 此时DataManager的实例被创建,并赋值给manager的importer属性
// 结果为: "data.txt"

注意: 如果被标记为lazy修饰符的属性同时被多个线程访问并且属性还没有被初始化,则无法保证属性只初始化一次。

存储属性计算属性的差异:

存储属性会存储敞亮或者变量作为实例的一部分,反之计算属性会计算值(而不是存储值)。
计算属性可以由类、结构体和枚举定义;存储属性只能由类和结构体定义。

常量和存储属性

如果创建一个结构体的实例并赋给了一个常量,则无法修改实例内的任何属性,即使是变量存储属性

let rangeOfFourItems = LengthRanuge(firstValue: 0, length: 4)
//rangeOfFourItems.firstValue = 6  
//尽管firstValue是变量属性,这里也会报错

延迟储存属性

延迟存储属性的初始值在其第一次使用时才进行计算。声明前标注 9159.com ,lazy 修饰语来表示一个延迟存储属性。且声明必须为变量。

class DataImporter {

    //DataImporter is a class to import data from an external file.
    //The class is assumed to take a non-trivial amount of time to initialize.

    var fileName = "data.txt"
    // the DataImporter class would provide data importing functionality here
}

class DataManager {
    lazy var importer = DataImporter()
    var data = [String]()
    // the DataManager class would provide data management functionality here
}

let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")
// the DataImporter instance for the importer property has not yet been created

print(manager.importer.fileName)
// the DataImporter instance for the importer property has now been created
// prints "data.txt"

2. 计算属性

计算属性并不存储值,只提供一个读取器和一个可选的设置器来间接得到和设置其属性值。举个栗子:

// 结构体Point表示一个点的位置
struct Point {
    var x = 0.0, y = 0.0
}

// 结构体Size表示图形的尺寸
struct Size {
    var width = 0.0, height = 0.0
}

// 结构体Rect表示一个矩形
struct Rect {
    var origin = Point()   // 矩形的原点
    var size = Size()      // 矩形的尺寸
    var center: Point {    // 用计算属性来表示矩形的中心点的位置
        get {              // 读取器get{} 中表示获取center属性的逻辑
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {   // 设置器set{} 中表示设置center属性时参与的逻辑,
                           // 这里改变了矩形原点的位置
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}

// 创建一个矩形的实例给变量square  (0.0, 0.0, 10.0, 10.0)
var square = Rect(origin: Point(x: 0.0, y: 0.0),
    size: Size(width: 10.0, height: 10.0))
// 用常量initialSquareCenter表示此事矩形的中心点位置
let initialSquareCenter = square.center
// 打印出来,结果为:square.center is at (5.0, 5.0)
print("square.center is at ((initialSquareCenter.x), (initialSquareCenter.y)")
// 将矩形的中心点设置为(15.0, 15.0)
square.center = Point(x: 15.0, y: 15.0)
// 此时矩形原点的位置也发生改变,结果为: "square.origin is now at (10.0, 10.0)"
print("square.origin is now at ((square.origin.x), (square.origin.y))")
类型属性

与类型本身相关联的属性就是类型属性

延迟存储属性

延迟存储属性是指第一次被调用的时候才会计算器初始值的属性。在属性声明前使用lazy来标识一个延迟存储属性。必须将延迟存储属性声明为变量
//使用场所:当属性的值依赖于在实例的构造过程结束前无法知道具体指的外部因素时,或者当属性的值需要复杂或大量计算时,可以只在需要的时候来计算它。
//例:

class DataImporter {
    /*
     DataImporter 是一个将外部文件中的数据导入的类
     这个类的初始化会消耗不少时间
     */
    var fileName = "data.txt"
    //这里提供数据导入功能
}

class DataManager {
    lazy var importer = DataImporter()
    var data = String()
    //这里提供数据管理功能
}

let manager = DataManager()
manager.data += "Some data"
manager.data += "Some more data"
//DataImporter 实例的 importer 属性还没有被创建

print(manager.importer.fileName)
//DataImporter 实例的 importer 属性现在才被创建了

储存属性与实例变量

Swift 属性没有与之相对应的实例变量,并且属性的后备存储不能被直接访问。

简写设置器(setter)声明

如果一个计算属性的设置器没有为将要被设置的值定义一个名字,那么他将被默认命名为newValue。举个栗子:

struct AlternativeRect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set { // newValue 是设置器的默认参数
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}

二、个个击破

二、计算属性

计算属性不直接存储值,而是提供一个getter来获取值,一个可以选择的setter来间接设置其他属性或变量的值
//例:

struct Point {
    var x = 0.0, y = 0.0
}

struct Size {
    var width = 0.0, height = 0.0
}

struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + size.width/2
            let centerY = origin.y + size.height/2
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {
            origin.x = newCenter.x - size.width/2
            origin.y = newCenter.y - size.height/2
        }
    }
}

var square = Rect(origin: Point.init(x: 0.0, y: 0.0), size: Size(width: 10.0, height: 10.0))
let initialCenter = square.center
print(initialCenter.x, initialCenter.y)
square.center = Point(x: 15.0, y: 15.0)
print(square.center.x, square.center.y)

计算属性

9159.com 1

struct Point {
    var x = 0.0, y = 0.0
}
struct Size {
    var width = 0.0, height = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}
var square = Rect(origin: Point(x: 0.0, y: 0.0),
    size: Size(width: 10.0, height: 10.0))
let initialSquareCenter = square.center
square.center = Point(x: 15.0, y: 15.0)
print("square.origin is now at ((square.origin.x), (square.origin.y))")
// prints "square.origin is now at (10.0, 10.0)"

只读计算属性

一个有读取器但是没有设置器的计算属性就是所谓的只读计算属性。只读计算属性返回一个值,也可以通过点语法访问,但是不能被修改为另一个值。语法上,可以通过去掉get关键字和它的大扩号来简化只读计算属性的声明:

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
        return width * height * depth
    }
}
let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
print("the volume of fourByFiveByTwo is (fourByFiveByTwo.volume)")
// 结果为: "the volume of fourByFiveByTwo is 40.0"

注意,包括只读计算属性,所有计算属性一律用var来修饰,因为计算属性的值不确定。计算属性可以由类、结构体和枚举定义;存储属性只能由类和结构体定义。

1、存储属性

正如默认属性值中所述,你可以为存储属性提供一个默认值作为它定义的一部分。你也可以在初始化的过程中设置和修改存储属性的初始值。

1  struct FixedLengthRange {
2      var firstValue: Int
3      let length: Int
4  }
5   var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
6   // the range represents integer values 0, 1, and 2
7   rangeOfThreeItems.firstValue = 6
8   // the range now represents integer values 6, 7, and 8

FixedLengthRange 的实例有一个名为 firstValue 的变量存储属性和一个名为 length 的常量存储属性。在上面的例 子中,当新的值域创建时 length 已经被创建并且不能再修改,因为这是一个常量属性。

只读计算属性

只有geter没有setter的计算属性就是制度计算属性。只读计算属性总是返回一个值,可以通过点运算符来访问,但不能设置新的值
只读计算属性的声明可以去掉get关键字

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
        return width * height * depth
    }
}
let vol = Cuboid(width: 4, height: 7, depth: 6)
print(vol.volume)

简写设置器(setter)声明

如果一个计算属性的设置器没有为将要被设置的值定义一个名字,那么他将被默认命名为 newValue 。

struct AlternativeRect {
    var origin = Point()
    var size = Size()
    var center: Point {
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set {
            origin.x = newValue.x - (size.width / 2)
            origin.y = newValue.y - (size.height / 2)
        }
    }
}

3. 属性观察者

  • 属性观察者会观察并对属性值的变化做出回应。
  • 可以为定义的任意存储属性添加属性观察者,除了延迟存储属性。
  • willSet在该值被存储之前被调用。 (默认参数名字为newValue)
  • didSet在一个新值被存储后被调用。(默认参数名字为oldValue)

举个栗子:

class StepCounter {
    var totalSteps: Int = 0 {     
        willSet(newTotalSteps) {        // 创建willSet观察者(自定义newTotalSteps参数)
            print("About to set totalSteps to (newTotalSteps)")
        }
        didSet {
            if totalSteps > oldValue  { // 创建didSet观察者(使用默认参数oldValue)
                print("Added (totalSteps - oldValue) steps")
            }
        }
    }
}
let stepCounter = StepCounter()
stepCounter.totalSteps = 200
// 结果为: About to set totalSteps to 200
// 结果为: Added 200 steps
stepCounter.totalSteps = 360
// 结果为: About to set totalSteps to 360
// 结果为: Added 160 steps
stepCounter.totalSteps = 896
// 结果为: About to set totalSteps to 896
// 结果为: Added 536 steps
常量结构体实例的存储属性

如果你创建了一个结构体的实例并且把这个实例赋给常量,你不能修改这个实例的属性,即使是声明为变量的属性:

1 let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
2 // this range represents integer values 0, 1, 2, and 3
3 rangeOfFourItems.firstValue = 6
4 // this will report an error, even though firstValue is a variable property

由于 rangeOfFourItems 被声明为常量(用 let 关键字),我们不能改变其 firstValue 属性,即使 firstValue 是一个 变量属性。
这是由于结构体是值类型。当一个值类型的实例被标记为常量时,该实例的其他属性也均为常量。

扩展:对于类来说则不同,它是引用类型。如果你给一个常量赋值引用类型实例,你仍然可以修改那个实例的变量属 性。*

三、属性监视器

定义:属性监视器监控和响应属性值的变化,每次属性被设置值得时候都会被调用属性监视器。

添加属性监视器
willSet 在设置新的值之前调用
didSet 在新的值被设置之后立即调用
willSet会将新的属性值作为常量参数传入,在willSet的实现代码中可以为这个参数指定一个名称,如果不指定则参数默认名称为 newValue 表示
类似的,didSet 会将旧的属性值作为参数传入,可以命名或者使用默认参数名 oldValue

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("about to set totalSteps to (newTotalSteps)")
        }
        didSet {
            if  totalSteps > oldValue {
                print("added (totalSteps - oldValue) steps")
            }
        }
    }
}
let stepCounter = StepCounter()
stepCounter.totalSteps = 200
//about to set totalSteps to 200
//added 200 steps

stepCounter.totalSteps = 360
//about to set totalSteps to 360
//added 160 steps

stepCounter.totalSteps = 400

只读计算属性

一个有读取器但是没有设置器的计算属性就是所谓的只读计算属性。

去掉 get 关键字和他的大扩号来简化只读计算属性的声明:

struct Cuboid {
    var width = 0.0, height = 0.0, depth = 0.0
    var volume: Double {
        return width * height * depth
    }
}
let fourByFiveByTwo = Cuboid(width: 4.0, height: 5.0, depth: 2.0)
print("the volume of fourByFiveByTwo is (fourByFiveByTwo.volume)")
// prints "the volume of fourByFiveByTwo is 40.0"

4. 全局和局部变量

  • 全局变量是定义在任何函数、方法、闭包或者类型环境之外的变量。局部变量是定义在函数、方法或者闭包环境之中的变量。
  • 全局常量和变量永远是延迟计算的,与延迟存储属性有着相同的行为。不同于延迟存储属性,全局常量和变量不需要标记lazy修饰符。
延迟存储属性

延迟存储属性的初始值在其第一次使用时才开始计算。你可以通过在其声明前标注lazy修饰语来表示一个延迟存储属性。

注意:你必须把延迟存储属性声明为变量(使用var关键字),因为它的初始值可能在实例初始化完成之前无法获得。敞亮属性则必须在初始化完成之前有值,因此不能声明为延迟。

四、全局变量和局部变量
  • 全局变量:是在函数,方法,闭包或任何类型之外定义的变量
  • 局部变量:是在函数,方法或闭包内部定义的变量
    PS:全局的常量或变量都是延迟计算的,跟延迟存储属性相似,不过不用标记为lazy特性

属性观察者

属性观察者会观察并对属性值的变化做出回应。

  • willSet 会在该值被存储之前被调用。
  • didSet 会在一个新值被存储后被调用。
class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            print("About to set totalSteps to (newTotalSteps)")
        }
        didSet {
            if totalSteps > oldValue  {
                print("Added (totalSteps - oldValue) steps")
            }
        }
    }
}
let stepCounter = StepCounter()
stepCounter.totalSteps = 200
// About to set totalSteps to 200
// Added 200 steps
stepCounter.totalSteps = 360
// About to set totalSteps to 360
// Added 160 steps
stepCounter.totalSteps = 896
// About to set totalSteps to 896
// Added 536 steps

5. 类型属性

属于类型本身的属性叫做类型属性。这个属性只有一个拷贝,无论你创建了多少个类对应的实例。

注意: 不同于存储实例属性,你必须总是给存储类型属性一个默认值是因为类型本身不能拥有能够在初始化时给存储类型属性赋值的初始化器。
存储类型属性是在它们第一次访问时延迟初始化的。它们保证只会初始化一次,就算被多个线程同时访问,他们也不需要使用 lazy 修饰符标记。

2、计算属性

除了存储属性,类、结构体和枚举也能够定义计算属性,而它实际并不存储值。相反,他们提供一个读取器和一 个可选的设置器来间接得到和设置其他的属性和值。

1  struct Point {
2      var x = 0.0, y = 0.0
3  }
4  struct Size {
5      var width = 0.0, height = 0.0
6  }
7  struct Rect {
8      var origin = Point()
9      var size = Size()
10     var center: Point {
11          get {
12              let centerX = origin.x + (size.width / 2)
13              let centerY = origin.y + (size.height / 2)
14              return Point(x: centerX, y: centerY)
15            }
16          set(newCenter) {
17          origin.x = newCenter.x - (size.width / 2)
18          origin.y = newCenter.y - (size.height / 2) 
19          }
20      }
21  }
22  var square = Rect(origin: Point(x: 0.0, y: 0.0)
23  size: Size(width: 10.0, height: 10.0))
24  let initialSquareCenter = square.center
25  square.center = Point(x: 15.0, y: 15.0)
26  print("square.origin is now at ( (square.origin.x), (square.origin.y))")
27  // prints "square.origin is now at (10.0, 10.0)"

注意:你必须用 var 关键字定义计算属性——包括只读计算属性——为变量属性,因为它们的值不是固定的。 let 关键字只用于常量属性,用于明确那些值一旦作为实例初始化就不能更改。

五、类型属性

使用关键字static来定义类型属性。
在为类定义计算型类型属性时,可以改用关键字class来支持子类对父类的实现进行重写。

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        //这里返回一个 Int 值
        return 9
    }
}

enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        //这里返回一个 Int 值
        return 8
    }
}

class SomeClass {
    static var storedTypeProperty = "Some value."
    class var computedTypeProperty: Int {
        return 7
    }
    class var overrideableComputedTypeProperty: Int {
        return 11
    }
}

全局变量和局部变量

计算属性和观察属性的能力同样对全局变量和局部变量有效。

类型属性语法

  • 一般使用 static 关键字来表示类型属性。
  • 对于类类型的计算类型属性,可以使用 class 关键字来允许子类重写父类的实现

举个栗子:

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 1
    }
}
enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 6
    }
}
class SomeClass {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 27
    }
    class var overrideableComputedTypeProperty: Int {
        return 107
    }
}

注意: 上边的计算类型属性示例时对于只读计算类型属性的,但我们还是可以使用与计算实例属性相同的语法定义可读写计算类型属性。

3、属性观察者

属性观察者会和观察并对属性值得变化做出回应。每当一个属性的值被设置时,属性观察者都会被调用,即使这个值与该属性当前的值相同。

你可以为你定义的任意存储属性添加属性观察者,除了延迟存储属性。

你可以选择将这些观察者或其中之一定义在属性上:

  • willSet 会在该值被存储之前被调用。
  • didSet 会在一个新值被存储后被调用。

如果你实现了一个 willSet 观察者,新的属性值会以常量形式参数传递。你可以在你的 willSet 实现中为这个参数定义名字。如果你没有为它命名,那么它会使用默认的名字 newValue 。
同样,如果你实现了一个 didSet观察者,一个包含旧属性值的常量形式参数将会被传递。你可以为它命名,也可 以使用默认的形式参数名 oldValue 。如果你在属性自己的 didSet 观察者里给自己赋值,你赋值的新值就会取代 刚刚设置的值。

获取和设置类型属性的值

跟实例属性一样,类型属性也是通过点运算符来访问。但是,类型属性是通过类型本身来访问,而不是通过实例。
//如:

print(SomeStructure.storedTypeProperty)
print(SomeEnumeration.computedTypeProperty)
print(SomeClass.computedTypeProperty)

类型属性

可以定义属于类型本身的属性,不是这个类型的某一个实例的属性。这个属性只有一个拷贝,无论你创建了多少个类对应的实例。这样的属性叫做类型属性。
详细参考文档介绍。

查询和设置类型属性

使用点语法,但针对的对象是类而不是类的实例:

print(SomeStructure.storedTypeProperty)
// 结果为: "Some value."
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// 结果为: "Another value."
print(SomeEnumeration.computedTypeProperty)
// 结果为: "6"
print(SomeClass.computedTypeProperty)
// 结果为: "27"
4、全局和局部变量

上边描述的计算属性和观察属性的能力同样对全局变量和局部变量有效。全局变量是定义在任何函数、方法、闭 包或者类型环境之外的变量。局部变量是定义在函数、方法或者闭包环境之中的变量。
你在之前章节中所遇到的全局和局部变量都是存储变量。存储变量,类似于存储属性,为特定类型的值提供存储 并且允许这个值被设置和取回。
总之,你同样可以定义计算属性以及给存储变量定义观察者,无论是全局还是局部环境。计算变量计算而不是存 储值,并且与计算属性的写法一致。

注意 全局敞亮和变量永远是延迟计算的,与延迟存储属性有着相同的行为。不同于延迟存储属性,全局常量和变量不需要标记 lazy 修饰符。

类型属性语法

static 关键字来开一类型属性

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 1
    }
}
enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 6
    }
}
class SomeClass {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 27
    }
    class var overrideableComputedTypeProperty: Int {
        return 107
    }
}
5、类型属性

你同样可以定义属于类型本身的属性,不是这个类型的某一个实例的属性。这个属性只有一个拷贝,无论你创建 了多少个类对应的实例。这样的属性叫做类型属性
存储类型属性可以是变量或者常量。计算类型属性总要被声明为变量属性,与计算实例属性一致。

注意:1.不同于存储实例属性,你必须总是给存储类型属性一个默认值。这是因为类型本身不能拥有能够在 初始化时给存储类型属性赋值的初始化器。
2.存储类型属性是在它们第一次访问时延迟初始化的。它们保证只会初始化一次,就算被多个线程同 时访问,他们也不需要使用 lazy 修饰符标记。

类型属性在类里查询和设置,而不是这个类型的实例

查询和设置类型属性

类型属性在类里查询和设置,而不是这个类型的实例。

print(SomeStructure.storedTypeProperty)
// prints "Some value."
SomeStructure.storedTypeProperty = "Another value."
print(SomeStructure.storedTypeProperty)
// prints "Another value."
print(SomeEnumeration.computedTypeProperty)
// prints "6"
print(SomeClass.computedTypeProperty)
// prints "27"

接下来的例子使用了两个存储类型属性作为建模一个为数字音频信道音频测量表的结构体的一部分。每一个频道都有一个介于 0 到 10 之间的数字音频等级。

下边的图例展示了这个音频频道如何组合建模一个立体声音频测量表。当频道的音频电平为 0,那个对应频道的灯就不会亮。当电平是 10 ,所有这个频道的灯都会亮。在这个图例里,左声道当前电平是 9 ,右声道的当前电平是 7 :

9159.com 2

struct AudioChannel {
    static let thresholdLevel = 10
    static var maxInputLevelForAllChannels = 0
    var currentLevel: Int = 0 {
        didSet {
            if currentLevel > AudioChannel.thresholdLevel {
                // cap the new audio level to the threshold level
                currentLevel = AudioChannel.thresholdLevel
            }
            if currentLevel > AudioChannel.maxInputLevelForAllChannels {
                // store this as the new overall maximum input level
                AudioChannel.maxInputLevelForAllChannels = currentLevel
            }
        }
    }
}

var leftChannel = AudioChannel()
var rightChannel = AudioChannel()

leftChannel.currentLevel = 7
print(leftChannel.currentLevel)
// prints "7"
print(AudioChannel.maxInputLevelForAllChannels)
// prints "7"

rightChannel.currentLevel = 11
print(rightChannel.currentLevel)
// prints "10"
print(AudioChannel.maxInputLevelForAllChannels)
// prints "10"

完结!!!

本文由9159.com发布于编程,转载请注明出处:关键字修饰)和常量存储属性(由,属性可以将值与

关键词: