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")

    }

}

阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/wzc10101415/article/details/79963587
文章标签: swift 对象
上一篇Swift学习笔记四:类与对象(一)
下一篇Swift学习笔记五:扩展协议
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭