Swift初探(二)

结构体

在OC中的属性有三个特征:
1.声明了get和set方法
2.实现了get和set方法
3.声明了一个同名的带下划线的成员变量

创建一个结构体,可以创建存储属性和计算属性

struct Frame {
    // 存储属性: 仅仅做存储用
    var x : Float
    var y : Float
    var width : Float
    var height : Float
 // 计算属性: 通过计算获取自己的值
    var centerX : Float {
        get{
            return x + width / 2
        }
        set{
            self.centerX = newValue
        }
    }
    
    var centerY : Float {
        get{
            return y + height / 2
        }
        set{
            self.centerY = newValue
        }
    }
    
}

Swift结构体中可以创建初始化方法,但是不需要func修饰,其实在Swift的结构体中是可以随便创建方法的,只不过是init方法不需要添加func作为修饰.

init(x newX : Float, y newY : Float, width newWidth : Float, height newHeight : Float){
        self.x = newX
        self.y = newY
        self.width = newWidth
        self.height = newHeight
    }

注:
上面的代码是在Frame这个结构体中的,其中init方法的参数中,"x"是外部参数的名字,而"newX"是内部参数的名字,在函数的内部是不可以使用外部参数名的.

如上所言,Swift中的结构体中是可以随意创建函数的,但是如果需要在函数里面修改属性的值的话,那么就需要在函数的前面添加mutating关键字进行修饰,下面代码依然实在Frame这个结构之中

mutating func haha(){
        self.x = 100
    }

结构体属性是不能在普通函数中进行调用的,创建结构体属性的方法是在属性前面使用static关键字进行修饰

static var name : String? = nil

结构体函数创建的方式如同结构体属性同样是需要添加static关键字修饰.

关于结构体函数有三点需要注意的:
1.结构体函数中不能调用普通的属性
2.结构体函数中可以调用结构体属性
3.结构体函数里面可以调用一些本结构体存在的函数

代码如下:

static func sayName (){
        self.name = "张三"
        print("my name is \(name)")
    }

在上面我们创建了一个名叫Frame的结构体,注意上面的代码都是写在结构体内部的.

而关于结构体调用的调用通常有两种方式:

第一种方式:
我们可以通过结构体点出其中的属性或者方法

第一种方式

第二种方式:
我们可以直接使用结构体名+ "()"调用

第二种方式

注:
如果们想要调用结构体函数,那么必须 通过这个结构体本身去调用

Frame.sayName()

调用结构体函数

类

在Swift中创建类的格式为:

class关键字 + 类名 {类的实现}

创建一个Person类:

class Person {
    var name: String? = nil
    var age: Int? = nil
    private var gender: String? = nil
    static var country: String? = nil
}

上面代码中创建了一个Person类,这个类中有四个属性,这里需要注意一点,在Swift的类中创建一个属性的时候,必须为这个属性指定一个初值,如果不想设置初值,那么就设置成为可选类型,其中private修饰的是私有属性,而static修饰的则为类属性

在类中创建一个初始化方法

init(name newName: String, age newAge: Int){
        name = newName
        age = newAge
    }

这里说明一下,由于gender属性是private私有属性,所以在init方法中初始化它是没有什么意义的,而country是一个类属性,在实例方法中我们不能够直接使用类属性.

实例方法

1.实例方法不能直接调用类属性
2.实例方法可以直接对实例对象进行修改赋值
3.在方法声明之前,添加一个private表示私有方法

创建一个私有的实例方法:

private func haha() {
        self.age = 20
        self.name = "张三"
        self.gender = "男"
        print("name is \(name),age is \(age), gender is \(gender)")
    }

在Swift中创建类方法的方式有两种:

第一种:

使用static修饰来创建类方法,这种方式创建出来的类方法,不可以被子类重写

static func heihei() {
        self.country = "中国"
        print("\(country)")
    }

第二种:

使用class修饰的也是类方法,但是它不同于static修饰的类方法的就是它可以被子类重写

class func hehehe() {
        self.country = "China"
        print("\(country)")
    }

类的调用

类的调用跟结构体相似,下面分别调用init方法,调用实例方法,调用类方法

类的调用

类的继承

在创建了类的时候其实还有一种格式,就是下面的这种功能,它指定了类的继承关系,":"后面是当前类的父类.

class Student: Person {
    override init(name newName: String, age newAge: Int) {
        super.init(name: newName, age: newAge)
    }
}

上面的代码中重写了父类的init方法,在Swift中如果想在子类中重写父类方法,那么需要在这个方法前面加override关键字修饰

协议

如同OC在Swift我们同样可以声明协议,声明一个协议个格式如下

protocol关键字 + 协议名字 {}

****Swift中协议里面的方法是必须实现的****,下面声明一个协议

protocol myDelegate {
// 没有返回值
    func hehehe()
// 有返回值
    func hehehe() ->String
}

在Swift中结构体也是可以遵守协议的,但是需要注意的是,如果需要修改结构体里面的参数,那么必须在协议方法前面添加mutating修饰,而对于类来说会自动的忽略mutating

如上所言,Swift是必须实现协议中所有的方法的,但是如果我们需要可选实现的协议,那么我们可以在最前面加@objc修饰,内部的方法使用optional修饰可选实现的方法,其他的与上面的创建方式保持不变,代码如下:

@objc protocol newDelegate {
    optional func lalala()
}

遵守协议

1.一般情况

class Person : myDelegate {
    func hehehe() {
        print("hhhh")
    }
    func hehehe() -> String {
        return "hhhh"
    }
}

2.需要遵守协议的类有一个父类,格式是:

class + 类名: 父类, 协议名字

class Teacher: Person, newDelegate {
    
}

由于上面协议中的方法是我们使用@objc创建的一个OC的可选择实现的方法,所以可以不用实现.

3.结构体遵守协议,在上面我们创建了一个OC的协议,注意在Swift中结构体只能遵守Swift中的协议

struct Animal: myDelegate {
    func hehehe() {
        print("...")
    }
    func hehehe() -> String {
        return "..."
    }
}

extension

extension可以给各类添加新的协议,但是extension不能给类添加新的属性,可以添加新的函数,为Person添加一个fly函数.

extension Person : myDelegate {
    func hehehe() {
        print("...")
    }
    func hehehe() -> String {
        return "..."
    }
    // extension不可以添加新的属性
    // 可以给类添加新的函数
    func fly() {
        
    }
}

extension可以给结构体拓展新的协议,但是会覆盖掉原油的方法

extension Frame: myDelegate {
    func hehehe() {
        print("...")
    }
    func hehehe() -> String {
        return "..."
    }
}

枚举

在Swift中创建的枚举不会像OC中从0开始为枚举中的元素排序

创建一个枚举

enum time {
    case spring
    case summer
    case autumn
    case winter
}

在使用枚举的时候,初次给变量赋值,必须使用枚举名.case名

var timer = time.spring

第二次使用的时候就可直接通过.case来使用了,这个时候编译器已经知道timer在使用time这个枚举了

timer = .summer

枚举搭配switch来使用

// switch的value要填写一个枚举类型的实例变量
switch timer {
// case 用 .枚举的case的名字
case .spring:
    print("春")
case .summer:
    print("夏")
case .autumn:
    print("秋")
case .winter:
    print("冬")
}

闭包表达式

闭包类似于OC中的block,闭包的创建:

闭包的名字: ((参数) ->返回值类型)

var newPassValue: ((a: Int, b: Int) ->Int)

闭包的五种写法

1.标准写法

newPassValue = {(a: Int, b: Int) ->Int in
    return a > b ? a : b
}

2.苹果推荐写法,省略参数类型

newPassValue = {(a, b) ->Int in
    return a > b ? a : b
}

3.全部省略, 使用$0代表第一个元素,$1代表第一个第二个元素,一次类推

newPassValue = {
    $0 > $1 ? $0 : $1
}

4.省略返回值,参数类型

newPassValue = {(a, b) in
    return a > b ? a : b  
}

5.省略返回值,return,参数类型

newPassValue = {(a, b) in
    a > b ? a : b
}