Swift-- 方法

来源：互联网发布：mac地址ip地质作用编辑：程序博客网时间：2024/05/17 02:13

//swift中声明类用class
    /*swift中属性有两种，存储属性和计算属性，存储属性就是存储在对象（实例）中的一个变量或者常量
        存储属性类似于其他面向对象语言中的成员变量
    */
        class student {

            var name = "tony"
            var age = 13
            let grade = 3

        }

    //系统并不会自动初始化上面的3个存储属性，需要进行手动初始化
    //直接通过点运算符（.），就可以读写某个对象的存储属性

        let stu = student()
        print("name = \(stu.name)")
        print("age = \(stu.age)")

    //延迟存储属性：第一次使用时才进行初始化的属性，用lazy来标识一个延迟存储属性，延迟存储属性必须是变量，不能是常量

        class tea {

            var name = "teatea"
        }

        class teacher {

            lazy var tea1 : tea = tea()

        }

        let teacher1 = teacher()
        print("\(teacher1.tea1)")//此时才会初始化tea属性


        /*计算属性（用get set 存值取值）
        1.因为计算属性的值不是固定的，因此只能用var修饰计算属性，不能用let
        2.
        */

        class Square {

            var width : Double = 4.0

            var circle: Double {
                get {

                    return width * 4

                }

                set(newValue) {

                    width = newValue / 4

                }

            }

        }
        let s2 = Square()
            s2.width = 10
        print(s2.width)

        s2.circle = 100
        print(s2.width)

        /*类型属性:一个类只会有一份，类的多个实例对象都共享这唯一的一份
        什么是类型属性
        用class关键字修饰的属性，就是类型属性，也可以称为“类属性”
        class修饰的类型属性只能是计算属性，不能是存储属性
        */

        class number {

            class var age : Int {

                return 20
            }
        }

        //直接使用，不依赖于类名而存在
        print(number.age)

        /*
        属性监视器：计算属性可以直接在set方法中监视，存储属性中用willSet 和 didSet两个属性监视器
        willSet:在设置新的属性值之前调用,会将新的属性值作为参数传入，参数名默认是newValue
        didSet:在设置新的属性值之后调用,会将旧的属性值作为参数传入，参数名默认是oldValue
        使用注意：willSet和didSet在属性初始化过程中不会被调用，只会当属性的值在初始化之外的地方被设置时被调用，并且willSet、didSet和set、get不能共存

        */

        class school{

            var history: Int = 120 {

                willSet{

                    print("------\(newValue)")
                }
                didSet {

                    print("--------\(oldValue)")
                }

            }
        }

        let sch = school()
        sch.history = 30

        //swift 中的方法跟OC类似，也是分为两类：类方法和实例方法
        //实例方法（对象方法）:语法和函数差不多

        class person {

            func paly_basketball() {
                print("------person-- basketball")
            }

        }

        let p = person()
        p.paly_basketball()

        //方法和函数区别：方法的第1个参数名仅仅是局部参数名，方法的其他参数名（除第1个参数名以外）既是局部参数名，又是外部参数名

        class calculator {

            func sum(sum1: Int, sum2:Int) ->Int{

                return sum1 + sum2

            }
        }

        let c = calculator()
        //num1 仅仅是局部参数名， num2既是局部参数名，又是外部参数名
        c.sum(10, sum2: 21)
        print(c.sum(10, sum2: 21))

        //可以在参数名前面加个下划线 _，去掉默认的外部参数名
        //("#"不能用作默认外部参数名了)
        class Calculator {
            func sum(num1 num1: Int, num2: Int) -> Int {
                return num1 + num2
            }
        }

        let d = Calculator()
        d.sum(num1: 12, num2: 32)

        /*类型方法
        用class来修饰
        */

        class blabla {

            class func sum(sum1 sum1: Int, sum2:Int)->Int {

                return sum1 + sum2

            }
        }

        print(blabla.sum(sum1: 12, sum2: 12))

        //类型方法和实例方法的方法名可以一样

        class type {

            class func sum(sum1: Int, sum2:Int)-> Int {

                return sum1 + sum2
            }

            func sum(sum1: Int, sum2:Int)-> Int {

                return sum1 + sum2
            }

        }

        //调用类方法
        type.sum(12, sum2: 12)

        //调用实例方法
        let t = type()
        t.sum(12, sum2: 12)

        /*
        self代表的是什么
        谁调用这个方法，self就代表谁
        在实例方法中：self代表调用方法的某个对象
        在类型方法中：self代表调用方法的某个类
        */

0 0