Swift —构造函数与存储属性初始化-备

时间：2021-05-13 22:32:06

构造函数的主要作用是初始化实例，其中包括：初始化存储属性和其它的初始化。在Rectangle类或结构体中，如果在构造函数中初始化存储属性width和height后，那么在定义他们时就不需要初始化了。

Rectangle类代码如下：

  1. class Rectangle {
  2. var width: Double
  3. var height: Double
  4. init() {
  5. width   = 0.0
  6. height  = 0.0
  7. }
  8. }

如果存储属性在构造函数中没有初始化，在定义的时候也没有初始化，那么就会发生编译错误。

构造函数还可以初始化常量存储属性，下面我们看示例代码：

  1. class Employee {
  2. let no: Int               //常量类型属性。曾讲过常量只能在定义的同时赋值，而在构造函数中，常量属性可以不遵守这个规则
  3. var name: String?     //存储属性一般在定义的时候初始化。如果不能确定初始值，可以采用可选类型属性
  4. var job: String?      //存储属性
  5. var salary: Double
  6. var dept: Department? //存储属性
  7. init() {
  8. no = 0                 //在构造函数中赋值，这种赋值不能放在普通方法中
  9. salary = 0.0
  10. dept = nil
  11. }
  12. }
  13. struct Department {
  14. let no: Int               //常量类型属性
  15. var name: String
  16. init() {
  17. no = 10            //在构造函数中赋值，这种赋值不能放在普通方法中
  18. name = "SALES"
  19. }
  20. }
  21. let dept = Department()
  22. var emp = Employee()

使用外部参数名

为了增强程序的可读性，Swift中的方法和函数可以使用外部参数名。在构造函数中也可以使用外部参数名。构造函数中的外部参数名要比一般的方法和函数更有意义，由于构造函数命名都是init，如果一个类型中有多个构造函数，我们可以通过不同的外部参数名区分调用不同的构造函数。

下面看示例代码：

  1. class RectangleA {
  2. var width: Double
  3. var height: Double
  4. init(W width: Double,H height: Double) {  //定义构造函数有两个参数width和height，并且为参数提供了外部参数名W和H。
  5. self.width   = width        //函数参数赋值给属性
  6. self.height  = height  //
  7. }
  8. }
  9. var recta = RectangleA(W: 320, H: 480)       //创建RectangleA实例，这里使用了外部参数名
  10. print("长方形A:\(recta.width) x \(recta.height)")

这里我们定义的是类，但也完全适用于结构体。

构造函数中的局部参数名可以直接作为外部参数名使用。

下面看示例代码：

    1. class RectangleB {
    2. var width: Double
    3. var height: Double
    4. init(width: Double, height: Double) { //构造函数，其中没有声明外部参数名。
    5. self.width   = width
    6. self.height  = height
    7. }
    8. }
    9. var rectb = RectangleB(width: 320, height: 480) //代码调用构造函数时，我们使用了外部参数名width和height，这些外部参数名就是局部参数名
    10. print("长方形B:\(rectb.width) x \(rectb.height)")

构造函数作为一种特殊方法，也可以重载。

Swift中构造函数可以多个，他们参数列表和返回值可以不同，这些构造函数构成重载。

示例代码如下：

  1. class Rectangle {
  2. var width: Double
  3. var height: Double
  4. init(width: Double, height: Double) {
  5. self.width   = width
  6. self.height  = height
  7. }
  8. init(W width: Double,H height: Double) {
  9. self.width   = width
  10. self.height  = height
  11. }
  12. init(length: Double) {
  13. self.width   = length
  14. self.height  = length
  15. }
  16. init() {
  17. self.width   = 640.0
  18. self.height  = 940.0
  19. }
  20. }
  21. var rectc1 = Rectangle(width: 320.0, height: 480.0)
  22. print("长方形:\(rectc1.width) x \(rectc1.height)")
  23. var rectc2 = Rectangle(W: 320.0, H: 480.0)
  24. print("长方形:\(rectc2.width) x \(rectc2.height)")
  25. var rectc3 = Rectangle(length: 500.0)
  26. print("长方形3:\(rectc3.width) x \(rectc3.height)")
  27. var rectc4 = Rectangle()
  28. print("长方形4:\(rectc4.width) x \(rectc4.height)")

构造函数代理

为了减少多个构造函数间的代码重复，在定义构造函数时，可以通过调用其他构造函数来完成实例的部分构造过程，这个过程称为构造函数代理。构造函数代理在结构体和类中使用方式是不同，先介绍结构体中构造函数代理。

将上一节的示例修改如下：

  1. struct Rectangle {
  2. var width: Double
  3. var height: Double
  4. init(width: Double, height: Double) {
  5. self.width   = width
  6. self.height  = height
  7. }
  8. init(W width: Double,H height: Double) {
  9. self.width   = width
  10. self.height  = height
  11. }
  12. init(length: Double) {                    //调用了self.init语句
  13. self.init(W: length, H: length)
  14. }
  15. init() {                              //调用了self.init语句
  16. self.init(width: 640.0, height: 940.0)
  17. }
  18. }
  19. var rectc1 = Rectangle(width: 320.0, height: 480.0)
  20. print("长方形:\(rectc1.width) x \(rectc1.height)")
  21. var rectc2 = Rectangle(W: 320.0, H: 480.0)
  22. print("长方形:\(rectc2.width) x \(rectc2.height)")
  23. var rectc3 = Rectangle(length: 500.0)
  24. print("长方形3:\(rectc3.width) x \(rectc3.height)")
  25. var rectc4 = Rectangle()
  26. print("长方形4:\(rectc4.width) x \(rectc4.height)")

将Rectangle声明为结构体类型，其中也有4个构造函数重载。

这种在同一个类型中通过self.init语句进行调用当前类型其它构造函数，其它构造函数被称为构造函数代理。

类构造函数横向代理

由于类有继承关系，类构造函数代理比较复杂，分为横向代理和向上代理。

  • 横向代理类似于结构体类型构造函数代理，发生在同一类内部，这种构造函数称为便利构造函数（convenience initializers）。

  • 向上代理发生在继承情况下，在子类构造过程中要先调用父类构造函数，初始化父类的存储属性，这种构造函数称为指定构造函数（designated initializers）。

将上面的示例修改如下：

  1. class Rectangle {
  2. var width: Double
  3. var height: Double
  4. init(width: Double, height: Double) {
  5. self.width   = width
  6. self.height  = height
  7. }
  8. init(W width: Double,H height: Double) {
  9. self.width   = width
  10. self.height  = height
  11. }
  12. convenience init(length: Double) {
  13. self.init(W: length, H: length)
  14. }
  15. convenience init() {
  16. self.init(width: 640.0, height: 940.0)
  17. }
  18. }
  19. var rectc1 = Rectangle(width: 320.0, height: 480.0)
  20. print("长方形:\(rectc1.width) x \(rectc1.height)")
  21. var rectc2 = Rectangle(W: 320.0, H: 480.0)
  22. print("长方形:\(rectc2.width) x \(rectc2.height)")
  23. var rectc3 = Rectangle(length: 500.0)
  24. print("长方形3:\(rectc3.width) x \(rectc3.height)")
  25. var rectc4 = Rectangle()
  26. print("长方形4:\(rectc4.width) x \(rectc4.height)")

将Rectangle声明为类，其中也有4个构造函数重载。

相关文章