Swift(七)类

2017-08-11  本文已影响83人  YvanLiu

更新:2018.05.24

整理了一下demo:SwiftDemo


Swift类是构造代码的一种通用而灵活的构造体。

1. 定义

与结构体的定义方法相同,类使用class关键字

class 类名 {
  属性列表
方法列表
}

这里我们同样以人类为例,创建一个类:

   class People {
       var age:Int
       var sex:String
       var name:String
       
       init() {
           self.age = 0
           self.sex = ""
           self.name = ""
       }
       
       func introduce() {
           print("My name is \(name), I`m a \(sex), \(age) years old.")
       }
   }

a -> 我们定义了一个类People,给People设置了三个属性:namesexage
b -> Swift要求定义类时,类的属性一定要初始化,这里我加了一个init()方法初始化属性,当然也可以直接给属性赋值。

       var age:Int = 0
       var sex:String = ""
       var name:String = ""

c -> 接着又给People添加了一个实例方法introduce,输出属性信息。

接下来让我们使用一下这个类

        let people = People()
        people.name = "LiLei"
        people.sex = "boy"
        people.age = 15
        people.introduce()

#输出结果:
        My name is LiLei, I`m a boy, 15 years old.

如果你觉得一个一个给属性赋值比较麻烦的话,也可以这样做:

    class People {
        var age:Int
        var sex:String
        var name:String
        
        init() {
            self.age = 0
            self.sex = ""
            self.name = ""
        }
        
        init(name:String, age:Int, sex:String) {
            self.name = name
            self.age = age
            self.sex = sex
        }
        
        func introduce() {
            print("My name is \(name), I`m a \(sex), \(age) years old.")
        }
    }
#调用
        let people2 = People.init(name: "LiLei", age: 15, sex: "boy")
        people2.introduce()

2. 类属性的 setget 方法

相信OC中的set和get方法大家都很熟悉了,基本来说,set就是设置,get就是获取。

    class Time {
        var hour:Int = 1
        var minute:Int {
            get {
                return self.hour * 60
            }
            set(newMinute) {
                self.hour = newMinute/60
            }
        }
    }

#调用
        let time = Time()
        print(time.hour)
        print(time.minute)

#输出
1
60

a -> 在上面代码中,我们创建了一个Time的类,给它两个属性,hourminute
b -> 我们给hour了一个初始值 1 ,其中hourminute是有换算关系的,所以我们为minute添加setget方法。
c ->minute属性进行get操作时,返回hour乘以60之后的结果;当minute进行set操作时,同时设置hour的值为minute除以60后的结果。
d -> 输出:我们可以看到,hour的值依然是1,mintue的值是60。

如果我们给mintue赋值了呢?

        time.minute = 360
        print(time.hour)
        print(time.minute)
#输出
6
360

e -> 可以看到,hour的值变成了6。

3. willSet和didSet

    class Role {
        var skill : Int = 1
        var level : Int = 1 {
            
            willSet {
                print("角色即将升级,等级将要到达 \(newValue) ")
            }
            
            didSet {
                if oldValue >= level {
                    print("升级失败!!!")
                } else {
                    print("角色已经升级,等级到达 \(level)")
                }
            }
        }
    }

#调用
        let role = Role()
        role.level = 2
        role.level = 2

#输出

角色即将升级,等级将要到达 2 
角色已经升级,等级到达 2
角色即将升级,等级将要到达 2 
升级失败!!!

a -> 在上面代码中,我们创建了一个Role的类,给它两个属性,levelskill
b -> 我们为level添加了willSetdidSet方法。
c ->willSet方法中,调用此方法时,输出提示语,其中newValue是默认参数名。
d ->didSet方法中,调用此方法,判断level是否有增长,输出条件语句。oldValue是旧值的默认参数名。

4. 静态方法

    class MathTool {
        class func sum(number1:Int ,number2:Int) -> Int {
            return number1 + number2
        }
        class func multiply(num1:Int ,num2:Int) -> Int {
            return num1 * num2
        }
    }

#调用
        print(MathTool.sum(number1: 10, number2: 1))
        print(MathTool.multiply(num1: 2, num2: 4))

#输出
11
8

a -> 在上面代码中,创建了一个MathTool的类,并创建了两个静态方法summultiply
b -> 调用的时候可以直接用类名调用,不需要实例化。如果某些地方不需要实例化,建议使用静态方法。

5. 类的析构

Swift和Object-C都是通过ARC来管理内存的,不需要我们对实例化的对象进行释放操作,但有些环境中,可能需要我们自己去清理一些额外的资源,比如创建了一个自定义的类,这个类打开了一个文件,并写入若干数据,就需要我们再类实例被释放之前关闭该文件。

    class FileManager {
        func openFile() {
            print("open file from the resorce")
        }
        func writeFile() {
            print("Write the data into the file")
        }
        deinit {
            print("delete the fileManager")
        }
    }

#调用
        var fileManager:FileManager? = FileManager()
        fileManager?.openFile()
        fileManager?.writeFile()
        fileManager = nil

#输出
open file from the resorce
Write the data into the file
delete the fileManager

a -> 在上面例子中,我们定义了一个FileManager类,用于读取和编辑文件,并定义了两个方法openFilewriteFile
b -> 在最后,添加了一个deinit,这个方法就是析构函数,当实例的引用计数为0时,系统自动调用这个方法,在输出结果中可以看出。

6. 继承

我们拿动物来举例:

    class Animal {
        func run() {
            print("I can run")
        }
    }

a -> 我们创建了一个Animal的类,给它一个方法 run,然后我们去创建一个大象的子类。

    class Elephant:Animal {
        var name:String
        override init() {
            self.name = "elephant"
        }
        
        override func run() {
            print("I'm a \(name), I can run.")
        }
        
    }

b -> 我们定义了一个子类 Elephant 请注意定义子类的写法,Elephant:Animal和OC的很像。
c -> 在子类中可以添加父类没有的方法或属性,这里添加了一个name属性并初始化。
d -> 请注意在initrun前面都有关键字 override。在重写一个父类的方法时,你需要在重写的方法前面加上override 关键字。如不使用的话,可能会出现各种错误,并且没有使用override关键字的重写,都被编译器诊断为错误。

如果不希望父类的属性、下标或方法被重写,可以在父类中的属性或方法前加final关键字,比如 final varfinal func 等。
当子类中尝试重写 final方法或属性时,编译器将会编译错误。

7. 延时加载属性lazy

延时加载属性:当第一次被调用的时候,才对其进行初始化操作的属性。当一个类拥有一个重度且不经常使用的属性时,比如这个属性是一个复杂的类,初始化时会占用很多的资源,而这个属性当前并不是必须使用的,此时就可以在声明前加lazy关键字,添加一个延时加载,这样就可以使用时再去进行初始化操作,提高程序运行效率。

    class Point {
        var pointValue:String = "1000"
    }
    
    class UserInfo {
        var username:String = "Coco"
        lazy var point:Point = Point()
    }
    
#调用
        let user = UserInfo()
        print(user.point.pointValue)

#输出
1000

a -> 首先我们定义了一个积分类PointPoint中有一个属性pointValue,然后定义了一个UserInfo类,有一个属性是Point类型,但我们并不是马上要使用这个属性,假设这个属性比较占用资源,所以在前面加了lazy关键字。


b -> 从图中我们可以看出,我们此时已经实例化了UserInfo类,username属性有值,但point属性还是nil,并没有被实例化。

c -> 我们点击step over按钮往下走, point就不是nil了。

8. 类的引用特性

举例说明:

    class Car {
        var brand:String = "BMW"
    }

#调用
        let bmw = Car()
        print(bmw.brand)
        let toyota = bmw
        toyota.brand = "toyota"
        print(bmw.brand)
        print(toyota.brand)

#输出
BMW
toyota
toyota

a -> 首先我们建立了一个Car类,里面有个属性brand,然后我们在viewDidLoad中实例化一个类实例,输出。
b -> 然后再创建一个常量 toyota等于bmw,并重新给brand赋值,然后输出。
c -> 从结果我们可以看出,brand属性的新值都是toyota。

9. 总结

好累呀,不想写了。

上一篇下一篇

猜你喜欢

热点阅读