• 构造函数

• 构造函数重载

• 析构函数

构造函数

在面向对象的数据类型中有一种特殊的函数或者叫做特殊的方法，它的作用是用于初始化这种类型的数据成员，这种函数或方法我们称之为构造函数或构造方法。构造函数或构造方法其实是一个概念，有些语言习惯叫构造函数，有些语言习惯叫构造方法。

在Swift语言中其实它就是构造器或析构器，我们将构造方法或构造器统一称为构造函数，将析构器统一称为析构函数。

构造函数概念

结构体和类的实例在构造过程中会调用一种特殊的init方法，称为构造函数。构造函数没有返回值，可以重载。在多个构造函数重载的情况下，运行环境可以根据它的外部参数名或参数列表调用合适的构造函数。
类似的方法在Objective-C和C++中也称为构造函数，Java中称为构造方法。不同的是，Objective-C中的构造函数有返回值，而C++和Java中的构造函数名必须与类名相同，没有返回值。

默认构造函数

1、类默认构造函数

注：类中的构造函数是无参的构造函数。类中没有提供构造函数，系统会提供一个没有参数的类默认构造函数

//类默认构造函数

class Rectangle {
    var width: Double = 0.0
    var height: Double = 0.0
//    init() {
//
//    }
}

var rect = Rectangle()//默认有一个无参的构造函数
rect.width = 320.0
rect.height = 480.0

print("长方形：\(rect.width) x \(rect.height)")

2、结构体的默认构造函数

注: 与类默认构造函数相比，结构体默认构造函数除了有一个无参的构造函数，还多了一个与属性相对应的构造函数，这些属性主要是指它的实例存储属性，参数顺序与初始化时的顺序一致

  //结构体默认构造函数
struct Rectangle2 {
   var width: Double = 0.0
   var height: Double = 0.0

//    init() {
//
//    }

//    init(width: Double, height: Double) {
//        self.width = width
//        self.height = height
//    }
}

var rect2 = Rectangle() //默认有一个无参的构造函数
rect2.width = 320.0
rect2.height = 480.0

print("长方形：\(rect2.width) x \(rect2.height)")

//默认有一个有参的构造函数， 
//与类默认构造函数相比，结构体默认构造函数多一个与属性相对应的构造函数，
//这些属性主要是指它的实例存储属性
var rectb = Rectangle2(width: 320, height: 480) 

注：类或结构体中已经声明一个构造函数了，就没有默认构造函数的说法了，就没有默认构造函数可以使用，只能使用定义和声明的构造函数

如下图：已经声明了不带参数的构造方法init了，所以不存在默认的带参的构造函数了，所以报错

image.png

构造函数与存储属性初始化

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

• 计算属性不保存数据， 所以不需要初始化

• 构造函数也不需要初始化静态属性，因为它们与具体实例个体无关。(构造函数与个体有关系，它初始化的都是个体属性，就是我们说的实例属性，静态属性与个体无关，所以它们不能在构造函数中初始化)

在构造函数存储属性

class Rectangle4 {
    var width: Double
    var height: Double

      //在构造函数初始化存储属性
    init() {
        width = 0.0
        height = 0.0
    }
}

var rect4 = Rectangle()
rect4.width = 320.0
rect4.height = 480.0

print("长方形4：\(rect4.width) x \(rect4.height)")

在构造函数中不仅可以对变量属性进行初始化，还可以对常量属性进行初始化

class Employee {
    let no: Int //常量
    var name: String?
    var job: String?
    var salary: Double
    var dept: Department?

    //在构造函数中不仅可以对变量属性进行初始化，还可以对常量属性进行初始化
    init() {
        no = 0 //常量在构造函数中可以被初始化（常量在其他普通方法中是不可以进行初始化的）
        salary = 0.0
        dept = nil
    }
}

struct Department {
    let no: Int
    var name: String
    init() {
        no = 10
        name = "SALES"
    } 
}

使用外部参数名

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

//使用外部参数名
class RectangleA {
    var width: Double
    var height: Double

    init(W width: Double, H height: Double) {
        self.width = width
        self.height = height
    }
}

var recta = RectangleA(W: 320, H: 480)
print("长方形A：\(recta.width) x \(recta.height)")

注：方法调用时第一个参数不需要指定外部参数名，可省略，而构造函数调用时不能省略第一个参数的外部参数名。

局部参数名可以作为外部参数名

//局部参数名可以作为外部参数名
class RectangleB {
    var width: Double
    var height: Double

    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }
}

var rectbb = RectangleB(width: 320, height: 480);
print("长方形B：\(rectbb.width) x \(rectbb.height)")

结构体中使用默认构造函数

 //结构体中使用默认构造函数
struct RectangleC {
    var width: Double = 0.0
    var height: Double = 0.0
}

var rectc = RectangleC(width: 320, height: 480)
print("长方形C:\(rectc.width) x \(rectc.height)")

注：这种写法是一种默认构造函数，但只适用于结构体，在类中不能使用。

构造函数重载

构造函数重载有2个条件

1、参数列表不同

2、外部参数名不同

以下代码中有4个构造函数

class RectangleD {
    var width: Double
    var height: Double

    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }

    init(W width: Double, H height: Double) {
        self.width = width
        self.height = height
    }

    init(length: Double) {
        self.width = length
        self.height = length
    }
    init() {
        self.width = 640.0
        self.height = 940.0
    }
}

结构体构造函数代理

为了减少多个构造函数间的代码重复，在定义构造函数时可以通过调用其他构造函数来完成实例的部分构造过程，这个过程称为构造函数代理

如下面代码

//结构体构造函数代理
    struct RectangleD {
    var width: Double
    var height: Double

    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }

    init(W width: Double, H height: Double) {
        self.width = width
        self.height = height
    }

    init(length: Double) {
    //        self.width = length
    //        self.height = length
            self.init(W: length, H: length)
        }
        init() {
//        self.width = 640.0
//        self.height = 940.0
        self.init(width: 640.0, height: 940.0)
    }
}

类构造函数横向代理

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

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

//类构造函数横向代理
class RectangleE {
   var width: Double
    var height: Double

    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }

    init(W width: Double, H height: Double) {
        self.width = width
        self.height = height
    }

    //使用convenience修饰的构造函数叫做便利构造函数
    //便利构造函数通常用在对系统的类进行构造函数的扩充时使用。
    //便利函数init前面需要加载convenience
    //在便利构造函数中需要明确的调用self.init()
    convenience init(length: Double) {
//        self.width = length
//        self.height = length
        self.init(W: length, H: length)
    }
   convenience init() {
//        self.width = 640.0
//        self.height = 940.0
        self.init(width: 640.0, height: 940.0)
    }
}

注：
使用convenience修饰的构造函数叫做便利构造函数
便利构造函数通常用在对系统的类进行构造函数的扩充时使用
便利函数init前面需要加载convenience
在便利构造函数中需要明确的调用self.init()

析构函数

与构造过程相反，实例最后释放的时候需要清除一些资源，这个过程就是析构过程。析构过程中也会调用一种特殊的方法 deinit,称为析构函数。 析构函数deinit没有返回值，也没有参数，也不需要参数的小括号，所以不能重载。

注 :
1、在Swift语言中一个类中只能有一个析构函数
2、析构函数与构造函数不同，构造函数可以在类和结构体中定义
3、析构函数只能在类中定义使用，结构体和枚举中是不能定义析构函数的

提示：

• 析构函数只适用与类，不适用于枚举和结构体。

• 类似的方法在C++中也称为析构函数，不同的是， C++中的析构函数常常用来释放不再需要的内存资源。而在Swift 中，内存管理采用自动引用计数（ARC）， 不需要析构函数释放不需要的实例内存资源，但还是有一些清除工作需要在这里完成，如关闭文件等处理。

class Rectangle {
    var width: Double
    var height: Double

    init(width: Double, height: Double) {
        self.width = width
        self.height = height
    }

    init(W width: Double, H height: Double) {
        self.width = width
        self.height = height
    }
    deinit {
        print("调用析构函数");
        self.width = 0.0
        self.height = 0.0
    }
}

var rect1: Rectangle? = Rectangle(width: 320, height: 480)
print("长方形：\(rect1!.width) x \(rect1!.height)")
rect1 = nil

var rect2: Rectangle? = Rectangle(W: 320, H: 480)
print("长方形：\(rect2!.width) x \(rect2!.height)")
rect2 = nil

打印结果如下图：

image.png