Swift 基础学习(实例方法)

/*
   方法
(1) 实例方法
(2) 方法的参数名称
(3) 实例方法中隐藏的self
(4) mutating方法
(5) 类方法
(6) 下标脚本语法
(7) 单索引值下标脚本
(8) 多索引值下标脚本
*/

//(1)实例方法
class MyPoint {
    var _x: Double = 0.0
    var _y: Double = 0.0
    //当我们定义实例方法时候,第一个参数为内部参数,之后的参数即可作为外部参数也可作为内部参数,如果想要作为内部参数,只需要在y前面加_即可
    func setX(x: Double, y: Double) {
        _x = x
        _y = y
    }
//    func setX(x: Double, _ y: Double) {
//        _x = x
//        _y = y
//    }
    func show() {
        print("x = \(_x), y = \(_y)")
    }
}
var p0 = MyPoint()
//通过实例对象调用方法
p0.setX(10.0, y: 10.0)
p0.show()

//(2)方法的参数名称
func setX(x: Double, y: Double) {

}
setX(10, y: 10)

//(3)self
class MyPoint1 {
    var _x: Double = 0.0
    var _y: Double = 0.0
    func setX(x: Double, y: Double) {
//        _x = x
//        _y = y
        //等同于
        self._x = x
        self._y = y
    }
    func show() {
        print("x = \(_x), y = \(_y)")
    }
}
var p1 = MyPoint1()
p1.setX(10, y: 10) //p1 == self

/*
(4) mutating方法
值类型 (结构体或者枚举) 默认方法是不可以修改属性的,如果要修改需要做特殊处理
*/

class MyPerson {
    var name: String = ""
    var age: Int = 0
    func set(name name: String, age: Int) {
        self.name = name
        self.age = age
    }
    func show() {
        print("name = \(name), age = \(age)")
    }
}
var m0 = MyPerson()
m0.set(name: "Frank", age: 24)
m0.show()

//将class改为struct
struct MyPerson1 {
    var name: String = ""
    var age: Int = 0
    //特殊处理在方法名添加关键字mutating
    mutating func set(name name: String, age: Int) {
        self.name = name
        self.age = age
    }
    func show() {
        print("name = \(name), age = \(age)")
    }
}
var m1 = MyPerson1()
m1.set(name: "Frank", age: 24)
m1.show()

enum LightSwitch {
    case OFF, LOW, HIGH
    mutating func next () {
        switch self {
        case .OFF:
            self = LOW
        case .LOW:
            self = HIGH
        case .HIGH:
            self = OFF

        }
    }
}
var light = LightSwitch.OFF
light.next() //light == .LOW

/*
(5) 类型方法
通过类名来调用的方法,就像类型属性一样.
类方法对应的关键字是static (结构体和枚举) class (类)
类方法里面不存在self
*/
struct TypeMethods {
    var p: Int = 0
    static var sp: Int = 0
    func method() {
        print("p = \(p), sp = \(TypeMethods.sp)")
    }
    //类方法里面不可以访问普通的成员变量
    static func staticMethod() {
//        print("p = \(p)")
        print("sp = \(TypeMethods.sp)")

    }
}
var tm = TypeMethods()
tm.method()
TypeMethods.staticMethod()

//跟结构体一样
class TypeMethods1 {
    var p: Int = 0
    static var sp: Int = 0
    func method() {
        print("p = \(p), sp = \(TypeMethods.sp)")
    }
    //类方法里面不可以访问普通的成员变量
    class func staticMethod() {
//                print("p = \(p)")
        print("sp = \(TypeMethods.sp)")

    }
}
var tm1 = TypeMethods1()
tm1.method()
TypeMethods1.staticMethod()

/*
(6)subscripts(下标)-访问对象中数据的快捷方式
所谓下标脚本语法就是能够通过 实例[索引值]来访问实例中的数据
subscript (index: Int) -> Element //数组
subscript (key: Key) -> Value? //字典
dict[key]
dict.subscript(key)
array[10]
array.subscript(10)
*/
let array = [1,3,5,6]
print(array[2]) // 实例对象[索引] subscripts
let dict = ["1":1] // key:value , key hash
print(dict["1"])  //

let array1:Array<Int> = [1,3,5,6]
print(array1[2]) // 实例对象[索引] subscripts
let dict1:Dictionary<String, Int> = ["1":1] // key:value , key hash
print(dict1["1"])

/*
(7)subscript方法实现
*/
struct Student {
    let name: String = ""
    var math: Int = 0
    var chinese: Int = 0
    var english: Int = 0
    func scoreOf(course: String) -> Int? {
        switch course {
            case "math":
            return math
            case "chinese":
            return chinese
            case  "english":
            return english
            default:
            return nil
        }
    }
    //想要实现下标访问时需要实现自己定义的一个subscript
    subscript (course: String) -> Int? {
        get {
            switch course {
            case "math":
                return math
            case "chinese":
                return chinese
            case  "english":
                return english
            default:
                return nil
            }

        }
        set {
            switch course {
            case "math":
                 math = newValue!
            case "chinese":
                 chinese = newValue!
            case  "english":
                 english = newValue!
            default:
                print("key wrong")
            }

        }
    }


}
var Frackchun = Student(math: 98, chinese: 94, english: 45)
//Frackchun["math"] Frackchun.scoreOf("math")
//想要修改的话要实现setter方法
Frackchun["math"] = 99
print(Frackchun.scoreOf("math"))
print(Frackchun["math"])

/*
(8)多索引subscript
*/
struct Mul {
    subscript (a: Int, b: Int) -> Int {
        return a * b
    }
}
var mul = Mul()
print(mul[3, 5])