Swift学习笔记四：类与对象（二）

9.类析构方法（deinit）的使用

//系统会自动释放不再需要的实例，以释放各种资源，在一个类的实例被释放之前，析构函数会被调用

class Animal4

{

    var name: String

    var age: Int

    

    init(name: String, age: Int)

    {

        self.name = name

        self.age = 0

    }

    

    func say()

    {

        print("I am \(name).")

    }

    

    //使用关键词deinit来定义析构函数，析构函数是在实例释放发生之前被自动调用的

    deinit

    {

        print("I'm deinited")

    }

}

var animal5: Animal4? = Animal4(name: "Jerry", age: 33)

animal5?.say()

animal5 = nil

10.给类添加下标（subscript）

//下标是访问集合、列表、序列中的元素的快捷方式，结构体、枚举和类都可以定义下标。

class Person2

{

    var name: String = "Rocky"

    var age: Int = 20

    var height: Double = 130

    

    subscript(index: Int) -> AnyObject //添加一个下标操作，该下标拥有一个整型参数，并返回任意类型的对象。

    {

        switch index

        {

        case 0:

            return name as AnyObject

        case 1:

            return age as AnyObject

        case 2:

            return height as AnyObject

        default:

            return name as AnyObject

        }

    }

}

let person5 = Person2()

person5[0]

person5[1]

person5[2]

11.类的静态方法（class func）

//类的静态方法，也称为类型方法。实例方法是被类型的某个实例调用的方法，而静态方法则是被类型本身调用的方法。

class MathTool

{

    func alert()

    {

        print("Caculating...")

    }

    func sum(num1: Int, num2: Int) -> Int

    {

        alert()

        return num1 + num2

    }

    

    //使用关键词class定义一个静态方法

    class func multiply(num1: Int, num2: Int) -> Int

    {

        return num1 * num2

    }

}

let tool = MathTool()

tool.sum(num1: 1, num2: 1)

//当需要调用静态方法时，需要使用类型而不是实例。静态方法使用方便，项目中的工具类，往往包含大量的静态方法。

MathTool.multiply(num1: 2, num2: 3)

12.讲一个类的实例作为另一个类的属性

class Animal5

{

    var name: String = "Lovely Dog"

    var age: Int = 1

}

class Person3

{

    var name: String = "Jerry"

    var age: Int = 33

    lazy var pet: Animal5 = Animal5() //初始化一个懒加载的属性，具有懒加载特性的对象，只有在使用到它时，才会真正被加载到内存中。

}

var person7 = Person3()

person7.age = 11

person7.pet = Animal5()

person7.pet.name = "Sweety Cat"

person7

13.类的继承以及方法的重写（override）

//一个类可以继承另一个类的方法、属性和其他特性。当一个类继承其他类时，继承类叫子类，被继承类叫父类。继承是区分类和其他类型的一个重要特性。

class Animal6

{

    func say()

    {

        print("I'm animal.")

    }

}

//父类的名称位于子类名称的后方，并用冒号进行分割

class Dog: Animal6

{

    var name: String

    

    init(name: String)

    {

        self.name = name

    }

    

    //子类可以为继承来的实例方法、静态方法、实例属性或下标，提供自己定制的实现。我们把这种行为叫做重写。

    override func say()

    {

        super.say()

        print("I'm a dog, my name is \(name).")

    }

}

var dog = Dog(name: "Nono")

dog.say()

14.父类在实例类型转化时的应用

class Creature

{

    var name: String

    init(name: String)

    {

        self.name = name

    }

}

class Dog1: Creature

{

    var master: String

    init(name: String, master: String)

    {

        self.master = master

        super.init(name: name)

    }

}

//创建作为父类的生物类型的数组

let creatures:[Creature] =

    [

        Dog1(name: "Nono", master: "John"),

        Dog1(name: "BAILEY", master: "Smith"),

        Dog1(name: "TOBY", master: "Bill")

]

for object in creatures

{

    //通过as!标识符将遍历到的元素，将他们的类型从父类，强制转换为子类的类型。

    let dog = object as! Dog1

    print("Dog: '\(dog.name)', belongs to \(dog.master)")

}

for dog in creatures as! [Dog1]

{

    print("Dog: '\(dog.name)', belongs to \(dog.master)")

}

15.使用is语句检查实例的类型

//类型检查是一种检查类实例的方式，并且也是让实例作为它的父类或者子类的一种方式

//类型检测使用is和as操作符实现。这两个操作符提供了一种简单达意的方式，去检查值的类型或者转换它们的类型。

class Creature1

{

    var name: String

    init(name: String)

    {

        self.name = name

    }

}

class Dog2: Creature1

{

    var master: String

    init(name: String, master: String)

    {

        self.master = master

        super.init(name: name)

    }

}

class Bird: Creature1

{

    var food: String

    init(name:String, food: String)

    {

        self.food = food

        super.init(name: name)

    }

}

let creatures1:[Creature1] =

    [

        Dog2(name: "Nono", master: "John"),

        Bird(name: "MAX", food: "Bugs"),

        Dog2(name: "BAILEY", master: "Smith"),

        Bird(name: "CHARLIE", food: "Spider"),

        Dog2(name: "TOBY", master: "Bill")

]

var dogCount = 0

var birdCount = 0

for item in creatures1

{

    if item is Dog2

    {

        dogCount += 1

    }

    else if item is Bird

    {

        birdCount += 1

    }

}

dogCount

birdCount

for item in creatures1

{

    if let dog = item as? Dog2

    {

        print("Dog: \(dog.name), belongs to \(dog.master)")

    }

    else if let bird = item as? Bird

    {

        print("Bird: '\(bird.name)', loves \(bird.food)")

    }

}

16.使用Any表示任意值类型

//Anyobject可以代表任何class类型的实例。此外还有一个Any，它可以表示任何类型，除了方法类型。

var anythings = [Any]() //定义一个Any类型的数组，该数组可以装载各种类型的数据。

anythings.append(8)

anythings.append(3.14156)

anythings.append("hello")

anythings.append((3.0, 5.0))

anythings

for item in anythings

{

    switch item

    {

    case let someInt as Int:

        print("An integer value of \(someInt)")

    case let someDouble as Double:

        print("A double value of \(someDouble)")

    case let someString as String:

        print("A string value of \(someString)")

    case let (x, y) as (Double, Double):

        print("An (x, y) point at \(x), \(y)")

    default:

        print("Something else")

    }

}