Swift 学习一函数&函数属性&懒加载

函数
  • 函数相当于OC中的方法
  • 格式:
    • func 函数名(参数列表) -> 返回值类型 {
          代码块
          return 返回值
      }
    • func 函数名(参数列表){  // 返回值为Void 可以省略
          代码块
          return 返回值
      }
 
  • 常见函数类型
    • // 1.没有参数,没用返回值
      func run() -> Void {
          print("I am running")
      }

      // 如果没用返回值,Void可以写成()
      func run1() -> () {
          print("I am running")
      }
      // 如果没有返回值,后面的内容可以都不写
      func run2() {
          print("I am running")
      }

      // 调用函数
      run2()

      // 2.有参数,没用返回值
      func callPhone(phoneNum : String) {
          print("打电话给\(phoneNum)")
      }
      callPhone("10086")

      // 3.没用参数,有返回值
      func greetings() -> String {
          return "吃饭了吗?"
      }
      var str1 = greetings()
      print(str1)

      // 4.有参数,有返回值
      func sum(num1 : Int, num2 : Int) -> Int {
          return num1 + num2
      }
      var result = sum(20, num2: 30)
      print(result)

  • 函数使用注意
    • 在函数内部可以看到的参数,就是内部参数
    • 在函数外面可以看到的参数,就是外部参数
    • 默认情况下,从第二个参数开始,参数名称既是内部参数也是外部参数
    • 如果第一个参数也想要有外部参数,可以设置标签:在变量名前加标签即可
    • 如果不想要外部参数,可以在参数名称前加_
      • // 默认情况下,从第二个参数开始,参数名称既是内部参数也是外部参数
        func calculate(num1 : Int, num2 : Int, num3 : Int) -> Int {
            return num1 * num2 * num3
        }
        var result1 = calculate(20, num2: 4, num3: 5)

        // 如果第一个参数也想要有外部参数,在变量名前加标签即可,如果不想要,在参数名前加 _
        func calculate1(myNum1 num1 : Int, _ num2 : Int, num3 : Int) -> Int {
            return num1 * num2 * num3
        }
        var result2 = calculate1(myNum1: 20, 4, num3: 5)

        // 方法的重载:方法名称相同,但是参数不同,可以称之为方法的重载
        func calculate(num1: Int, _ num2 :Int) -> Int {
            return num1 * num2
        }
        var result3 = calculate(20, 20)

 
    • 默认参数:某些情况,如果没有传入具体参数,可以使用默认参数
      • func makecoffee(type :String = "卡布奇诺") -> String {
            return "制作一杯\(type)咖啡。"
        }
        print(makecoffee("拿铁"))
        print(makecoffee())
        制作一杯拿铁咖啡。
        制作一杯卡布奇诺咖啡。
 
    • 可变参数:函数的参数个数可以不确定,但必须是相同类型,在参数类型名后面加入(…)来指示这是可变参数
      • func sum(numbers:Double...) -> Double {
            var total: Double = 0
            for number in numbers {
                total += number
            }
            return total
        }

        sum(100.0, 20, 30)
        sum(30, 80)

 
    • 引用类型(指针传递): 默认情况函数的参数是值传递,如果想改变外面的变量,则需要传递变量的地址,swift 提供 inout关键字就可以实现。注意:必须是变量
      • // 函数一:值传递
        func swap(var a : Int, var b : Int) {
            let temp = a;
            a = b;
            b = temp  
            print("a:\(a), b:\(b)")
        }

        var a = 10
        var b = 20
        swap(a, b: b)
        print("a:\(a), b:\(b)")
        a:20, b:10
        a:10, b:20

        // 函数二:指针的传递
        func swap2(inout m : Int, inout n : Int) {
            let temp = m
            m = n
            n = temp
            print("m:\(m), n:\(b)")
        }
        var m = 10
        var n = 20
        swap2(&m, n: &n)
        print("m:\(m), n:\(n)")
        m:20, n:20
        m:20, n:10

 
    • 嵌套函数:swift中可以嵌套函数,但是不推荐使用
      • let value = 55
        func test() {
            func demo() {
                print("value \(value)")
            }
            print("test")
            demo()
        }

        //demo() // 错误
        test()
        test
        value 55

 
类的构造函数
  • 构造函数:
    • 构造函数类似于OC中的初始化方法:init方法
    • 默认情况下创建一个类时,必然会调用一个构造函数,如果没有编写任何构造函数,编译器也会提供一个默认的构造函数。
    • 如果是继承自NSObject,可以对父类的构造函数进行重写
 
  • 构造函数的基本使用
  • 1、类的属性必须有值,如果不是在定义时初始化值,可以在构造函数中赋值
      • class Student1: NSObject {
            var name : String
            var age : Int
           
            // 重写了NSObject(父类)的构造方法
            override init() {
                name = ""
                age = 0
            }
        }

        // 创建一个Student1对象
        let student1 = Student1()

         Swift 学习一函数&函数属性&懒加载
 
  • 2、初始化时给属性赋值
    • 我们经常在创建对象是就给属性赋值,可以自定义构造函数
    • 注意:自定义了构造函数会覆盖init()方法,也就不再有默认的构造函数
      • class Student2: NSObject {
            var name : String
            var age : Int
            // 自定义构造函数,会覆盖init()函数
            init(name : String, age : Int) {
                self.name = name
                self.age = age
            }
        }
        // 创建一个Student2对象
        let student2 = Student2(name: "why", age: 18)
 
  • 3、字典转模型(初始化时传入字典)
    • 创建对象时,更多的是将字典转成模型
    • 注意:从字典中取出的是NSObject,任意类型,可以通过 as! 转成需要的类型再赋值(不可以直接赋值)
      • class Student3: NSObject {
            var name : String
            var age : Int
            // 自定义构造函数,会覆盖init()函数
            init(dict : [String : NSObject]) {
                name = dict["name"] as! String
                age = dict["age"] as! Int
            }
        }

        // 创建一个student3对象
        let dict = ["name" : "Siri", "age" : 18]
        let student3 = Student3(dict: dict)
        student3.name  // "Siri"

 
  • 4、字典转模型(利用KVC转化)
    • 利用KVC字典转模型会更加方便
    • 注意:KVC并不能保证会给所有的属性赋值,因此属性必须要有默认值
      • 基本数据类型默认值设置为0
      • 对象或者结构体类型定义为可选类型即可(可选类型没有赋值前为nil)
      • class Student4: NSObject {
            // 结构体或者类的类型,必须是可选类型.因为不能保证一定会赋值
            var name : String?
            // 基本数据类型不能是可选类型,否则KVC无法转化
            var age : Int = 0
            var address : String?
            // 自定义构造函数,会覆盖init()函数
            init(dict : [String : NSObject]) {
                // 必须先初始化对象
                super.init()
                // 调用对象的KVC方法字典转模型
                setValuesForKeysWithDictionary(dict)
            }
        }
        // 创建一个student4对象
        let dict4 = ["name" : "why", "age" : 18]
        let student4 = Student4(dict: dict)
        Swift 学习一函数&函数属性&懒加载 
                              
 
类的定义
  • 类的定义,可以没有父类,那么该类是rootClass
    • class 类名 : SuperClass {
          // 定义属性和方法
      }
 
类的属性
  • swift中类的属性有三种
    • 存储属性:存储实例的常量和变量
    • 计算属性:通过某种方式计算出来的属性
    • 类属性:与整个类自身相关的属性
 
  • 存储属性
    • class Person {   // 这种定义属性必须写初始值,因为系统不会自动初始化初始值,可选类型除外
         
          var age:Int = 1   // var 关键字修饰变量
         
          let life = 1      // let 修饰常量,不能修改
         
          var name: String?
         
      }

      var person = Person()

      person.age = 20          // 直接通过点运算符读写

      person.name = "Siri"

      print("person的名字是\(person.name), person的生命是\(person.life), person的年龄是\(person.age)")

 
  • 计算属性
    • 并不存储实际的值,而是提供一个getter和一个可选的setter来间接获取和设置其它属性
    • 存储属性一般只提供getter方法
    • 如果只提供getter,而不提供setter,则该计算属性为只读属性,并且可以省略get{}
      • //  注意:计算属性的值是不固定的,只能声明为变量,不能使用let
        class Square {
            var width: Double = 0   // 边长
            var girth: Double {     // 周长 
                get {  
                    returnwidth * 4 
                    }
                set {               // 默认有一个newValue 的值 
                    width = newValue / 4
                    }
                }
            }
        var square = Square()
        square.width = 10
        print(square.girth)   // 调用 girth 属性的 get,输出结果是40
        square.girth = 200
        print(square.width)   // 调用 girth 属性的 set,并且把200传递给 newValue,输出结果是 50
      • // 注意:一个属性不能既是存储属性有事计算属性
        // 只读计算属性:只有get方法,没有set方法
        class Square3 {  
            var girth: Double {   // 周长 
                get {  
                    return40  
                }
            }
        }

        //也可以简写成:
        class Square4 {
            var girth: Double {   // 周长 
                return40
            }
        }

 
 
  • 类属性
    • 所有的类和实例都共有一份类属性.因此在某一处修改之后,该类属性就会被修改
    • 类属性的设置和修改,需要通过类来完成
      • // 类型属性:用类来访问的属性,用class关键字修饰的属性,也可以称为“类属性” 。
        // 特点:一个类只会有一份,类的多个实例对象都共享这唯一的一份。
        // 使用:类型属性不依赖于对象而存在,用类名来访问。
        // 注意:class修饰的类型属性只能是计算属性,不能是存储属性。
        class Circle {
            classvar PI: Double {// 所有用到的PI的值都是一样的,可以写成类属性
                return3.14  
            }
        }
        print("圆周率 = \(Circle.PI)")
 
 
  • 属性监视器
    • 可以监视属性值的修改过程。需要在属性值被修改的时候做出响应的情况可以用属性监视器。计算属性可以在set方法中监听 ,而存储属性没有set,可以为存储属性添加willSet和didSet两个属性监视器。
      • // 属性监视器
        //可以监视属性值的修改过程。需要在属性值被修改的时候做出响应的情况可以用属性监视器。计算属性可以在set方法中监听,而存储属性没有set,可以为存储属性添加willSet和didSet两个属性监视器。
        class Square5 {
            var width: Double = 0.0 {
                 willSet {// willSet 有 newValue
                     print("willSet---new=\(newValue), current=\(width)")
                 }
                 didSet {// oldSet 有 oldValue 
                     print("didSet---old=\(oldValue), current=\(width)")
                 }
             }
         }
      • var square5 = Square5()
        square5.width = 10.0
        willSet---new=10.0, current=0.0
        didSet---old=0.0, current=10.0
 
      • //注意:willSet和didSet在属性初始化过程中不会被调用,只会当属性的值在初始化之外的地方被设置时被调用。也就是在声明时不会引发willSet和didSet的调用
        //如果在didSet方法中修改了属性的值,就不会再引发didSet的调用,也就不会循环引用。
        class Square6 {
            var width: Double = 0.0 {
                willSet {
                }
                didSet {
                    width = 80
                }
            }
        }

        var square6 = Square6()
        square6.width = 40
        print("width=\(square6.width)")  // 打印:width=80.0

 
 
延迟属性
  • 第一次使用时才进行初始化的属性(相当于懒加载),使用关键字 @lazy 来标识一个延时属性。
  • 好处:让某些资源用到时再去加载,避免不必要的资源浪费。
  • 注意:延迟存储属性必须是变量,不能是常量。
    • class Dog {
          var name: String = "timo"
          init() {
              print("你是一条狗")
          }
      }
      class Person1 {   
          var dog: Dog = Dog() 
      }
      class LazyPerson {
          lazyvar dog: Dog = Dog()
      }
      var person1 = Person1() // 会直接打印  你是一条狗
      var lazyPerson = LazyPerson()     // 不会直接打印lazyPerson.dog// 调用才会打印
 
 
 
上一篇:解读CSS的背景(background)样式


下一篇:Swift - 懒加载(lazy initialization)