Swift之初体验(二)

继Swift初探之后,我们来继续学习下Swift里的结构体,类,协议,闭包

结构体

struct Frame {
    //存储属性 : 仅仅做存储值得作用
    //计算属性 : 通过计算获取自己的值
    var x : Float
    var y : Float
    var width : Float
    var height : Float

    var centerX :Float{
    //属性的作用:
        //1.声明了setter,getter方法
        //2.实现了setter,getter方法
        //3.声明了一个名字带下划线的成员变量

        //设置属性的set和get方法
        //属性里面的set方法不能单独存在,必须有一个同属性的get方法存在之后才可以写set
        get{
        return self.x + width/2
        }
        set{
        self.centerX = newValue
        }
    }

    var centerY : Float{
        get{

        return self.y + height/2
        }
        set{
        self.centerY = newValue
        }

    }

    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
    }

    //Swift的结构体可以任意的创建函数
    //如果需要在函数里面修改属性的值得话,需要在函数前面添加mutating(不加会报红)关键字修饰
   mutating  func hhh(){
    self.x = 100
    }

    //结构体属性
    //结构体属性是不能再普通的函数里面调用的
    static var name :String? = nil

    //结构体函数
    //结构体函数里面不能调用普通的属性
    //结构体函数里面可以调用结构体属性
    //结构体函数里面可以调用一些本结构体存在的函数
    static func sayName(){
    self.name = "我是一个frame"
        print(self.name)
    }
}

两种调用结构体的方法

1.调用结构体里的init方法

let frame : Frame = Frame.init(x: 10, y: 10, width: 10, height: 10)
print(frame.centerY, frame.centerX)

2.直接调用属性

let frame1 : Frame = Frame(x: 100, y: 100, width: 100, height: 100)
print(frame1.centerX, frame1.centerY)

调用结构体函数,必须通过这个结构体去调用

Frame.sayName()

类

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

class Person {
    //在类里面创建一个属性的时候,必须有初值,如果不想设置初值,那么就设置成为可选类型
    var name : String? = nil
    var age : Int? = nil
    //private 表示的是私有属性
    private var gender : String? = nil

    //static修饰的属性表示类属性
    static var country : String? = nil

    init(name myname : String, age myAge : Int){
        name = myname
        age = myAge
       // country = myCountry

    }

实例方法里面不能直接调用类属性

实例方法可以直接对实例对象进行修改赋值

在函数声明之前添加一个private 表示私有方法

    private func sayHi(){
    self.gender = "女"
        print(self.gender)
    }

static修饰的是类方法

static修饰的类方法是不可以被子类重写的

    static func sayHello(){

    }

class修饰的也是类方法

class修饰的类方法可以被子类重写

    class func sayNiHao(){
    self.country = "china"
        print(self.country)
    }

}

调用方法:

let person : Person = Person(name: "路飞", age: 18)

person.sayHi()

Person.sayHello()
Person.sayNiHao()
class Student : Person{

    //如果子类想重写父类方法,需要添加override修饰
    override init(name myname: String, age myAge: Int) {
        super.init(name: myname, age: myAge)

    }

    //class修饰的  可以重写方法
    override class func sayNiHao(){

    }
}

协议

格式 protocol 关键字 + 协议名字 Swift的协议默认是必须要实现的

protocol myDelegate {
    //协议方法前面添加mutating修饰的关键字之后,可以修饰结构体里面的参数,在类里面会自动的忽略mutating
   mutating func hhh()
}

如果有需要可选实现的协议在最前面添加 @objc 修饰, 内部的方法用optional修饰可选实现的方法,其他的不变

@objc protocol newDlegate{

  optional func lalala()
}

如果一个类既有父类 也遵守了某个协议 那么格式是
class + 类名:父类,协议名字

class Teacher: Person, myDelegate,newDlegate {
    func hhh(){

    }
}

结构体可以遵守协议但是结构体只能遵守Swift的协议

struct kakasi {
    var name : String
   mutating  func hhh(){
    self.name = "旗木"
    }
}

extension 可以给一个类拓展新的协议

extension Person : myDelegate{

    func hhh() {

    }
    //extesion不可以添加新的属性
    //var height : Float? = nil
    //可以给一个类添加新的函数
    func mingren(){

    }
}

extesion 可以给一个结构及拓展新的协议

extension Frame : myDelegate {

}

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

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

var timer = time.autumn

第二次使用的时候 可以直接通过.case名使用

timer = .spring

switch 搭配枚举使用
switch 的value 要填写一个枚举类型的实例变量
case .枚举的case名字

switch timer {

case .spring:
    print("春")
case .summer:
    print("夏")
case .autumn:
    print("秋")
case .winter:
    print("冬")
}

闭包

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

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

第一种闭包表达式的写法

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

第二种写法 苹果推荐的写法

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

第三种写法

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

第四种写法

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

第五种写法

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

}

OVER!