Swift 学习2

第二天学习了swift的高级用法

//可选类型

//对于可能为空  可能有值得  在swift中用optional来表示  要不是nil  要不是some
var possibleStr = "123"
var convertStr:Int = Int(possibleStr)!
print(convertStr)

//强制拆包  解包
//如果没有值 是nil 强制拆包就会造成崩溃
//如果知道有值  可以强制解包

//?  即代表optional  可选类型
var number:Int? = 8
//print(number!)

//可选绑定
//如果不确定是否有值  可以用可选绑定 是一种安全的措施
if var number1 = number {
    print(number1)
}

//隐式解析可选类型   ! 是我们在定义变量的时候去加的
//已初始化 就是确定有值得
//如果不给值  也会崩溃
var sureNumber:Int! = 8
print(sureNumber)

if var suerNumber1 = sureNumber {
    print(suerNumber1)
}

//总结:1. ! 只要遇到可选类型  optional  确定有值，就强拆
//     2. ? 只要见到就是可选类型
//      3. ! 如果初始化就有值  就可以用隐式解析可选类型

这些东西在OC中是没有的，所以也是初学，就像回到了刚学OC那会儿，呵呵。
swift中的结构体和C中的差异很大，我觉得swift中的结构体和类很像，看看它们的定义方法就知道了
结构体定义：

struct Rect{
    //成员变量
    var x:Float
    var y:Float
    var height:Float
    var width:Float

    //结构体变量
    static var descrption:String!

    //计算属性  不存储值  可以用来改变成员变量的值
    var centerX:Float{
        set{
            //newValue 就是调用的时候传进来的centerX
          x = newValue - width/2
        }
        get{
          return x + width/2
        }
    }

    static func sayHello() ->Void{
        print("结构体方法")
    }

    func sayHi() ->Void{
        print("结构体成员方法")
    }

}
//Rect(.....) 系统默认的构造方法
//结构体对象
var rect:Rect = Rect(x: 0, y: 0, height: 100, width: 100)
//访问成员变量
print(rect.height)
rect.centerX = 100  //计算属性的set方法
print(rect.x, rect.centerX)  //进入get  拿到centerX

//结构体变量的赋值和访问
Rect.descrption = "是一个结构体变量"
print(Rect.descrption)


//结构体方法的访问
Rect.sayHello()

//结构体成员方法的访问
rect.sayHi()

类的创建方法

class Student{
    //类的对象属性
    var name:String?
    var age:Int?
    var sex:Bool?
    var height:Float?

    //计算属性  作用:对age进行赋值
    var number:Int {
        set{
            self.age = newValue

        }
        get{
            return age!
        }

    }


    //必须有一个初始化方法 把全部属性初始化出来
    init(name1:String, age1:Int, sex:Bool, height:Float){
        self.name = name1
        self.age = age1
        self.sex = sex
        self.height = height
    }

    //如果我们队属性加上可选类型  就可以添加多个初始化方法
    //因为 可选类型对属性来说是可以有值也可以没有值
    init(name2:String, age2:Int){
        self.name = name2
        self.age = age2
    }

    static func sayHi() ->Void{
        print("一个类方法")
    }

    func sayHello() ->Void{
        print("一个对象方法")
    }

    class func sayHii() ->Void {
        print("又一种类方法")
    }

}

//类中  初始化方法 系统没有帮我们提供 需要我们自己去写
var stu:Student = Student(name1: "sugar", age1: 22, sex: true, height: 170)
print(stu.name!)

//调用其他的初始化方法 对其属性进行赋值
var stu1 = Student(name2: "sugar", age2: 22)
print(stu1.name!)

stu1.number = 30
print(stu1.age!)

//调用类方法
Student.sayHi()
Student.sayHii()

//调用对象方法
stu.sayHello()

//继承
class Student1:Student{

    var teacher:String?

    //重写父类的方法
    override func sayHello() {
        print("我是重写了父类的方法")
    }

    override class func sayHii() ->Void{
        print("重写的类方法")
    }

    //子类初始化方法的声明
    init(name:String, age:Int, sex:Bool, height:Float, teacher:String){
        super.init(name1: name, age1: age, sex: sex, height: height)
        self.teacher = teacher
    }
}

//继承了初始化方法
//var subStu = Student1(name1: "wuxx", age1: 20, sex: true, height: 168)
//print(subStu.name!)

//如果要重写初始化方法 在子类里边直接定义init方法就可以
//但是不再继承父类的初始化方法
var subStu = Student1(name: "jianb", age: 25, sex: true, height: 175, teacher: "kkk")

Student1.sayHii()
subStu.sayHello()

简直差不多好嘛，而且结构体还有系统自带的方法，类还要自己写，我在那一瞬间都觉得有结构体还要类干嘛，后面才知道我太天真了。
值类型 和 引用类型

//结构体 是值类型  直接就是值得拷贝
struct Animal{
    var name:String?
}
var dog = Animal(name: "小黑")
//把dog 赋给 dog1
var dog1 = dog
dog1.name = "小黄"
print("dog____\(dog.name!), dog1____\(dog1.name!)")

//Swift中的类默认是 引用类型  即两个指针指向同一块内存地址
class ClassAnimal{
    var name:String?
    init(name:String){
        self.name = name
    }
}
var whiteCat = ClassAnimal(name: "白猫")
var blackCat = whiteCat
blackCat.name = "黑猫"
print("whiteCat___\(whiteCat.name!), blackCat___\(blackCat.name!)")

学到这我才知道结构体和类的区别，才觉得两者都存在还是蛮合理的。
下面说说协议

//protocol 关键字
//如果协议方法中有可选的  要在protocol前边加上@objc的关键字
@objc protocol ManDelegate{
    //协议方法
    func wash() ->Void
    func work() ->Void
    optional func sleep() ->Void
}

protocol StudentDelegate{
    func study()
}

//"," 后边可以跟上要去遵循的协议
class Person:Student,ManDelegate,StudentDelegate{
    //如果我们遵循的协议方法是在 有可选协议里边的协议方法
    //wash work 协议里边是有可选协议方法的
    //我们要在前边加上  @objc关键字
    @objc func wash() {
        print("是男人就要洗衣服")
    }
    @objc func work() {
        print("是男人就得工作")
    }
    func study() {
        print("是学生就得学习")
    }
}

var person = Person(name2: "sugar", age2: 22)
person.study()
person.work()

协议和OC中的还是挺像的，容易掌握
协议之后学习了扩展，有点像OC中的类目和延展吧

extension Person{
    //只能扩展方法 不能扩展属性

    //扩展对象方法
    func hitDouDou(){
        print("打豆豆")
    }
    func sleep() {
        print("睡觉")
    }
}

person.hitDouDou()
person.sleep()

之前说了协议，OC中有协议和block，swift中有协议，怎么可能少的了block，不过这里不叫block，叫闭包。

//方法的类型   (number1:Int, number2:Int) ->Int    方法是通过{}里边去执行方法的语句
//闭包 相当于把 一整个方法包起来   {(number1:Int, number2:Int) ->Int  in 执行体}

//这里相当于定义了 一个闭包 类型
var maxValue:((number1:Int, number2:Int) ->Int)

//1
maxValue = {
    (number1:Int, number2:Int) ->Int in
    return number1>number2 ? number1 : number2
}

var caculateNumber = maxValue(number1: 3, number2: 5)
print(caculateNumber)

//闭包的实现
//2
maxValue = {
    number1,number2 ->Int in
    return number1>number2 ? number1 : number2
}

caculateNumber = maxValue(number1: 5, number2: 7)
print(caculateNumber)

//3
maxValue = {
    number1,number2  in
    number1>number2 ? number1 : number2
}
caculateNumber = maxValue(number1: 5, number2: 7)
print(caculateNumber)

//4  $0 第一个参数  $1 第二个参数 系统会默认把返回值返回
maxValue = {
    $0 > $1 ? $0 : $1
}
caculateNumber = maxValue(number1: 45, number2: 7)
print(caculateNumber)


var minValue:((num:Int, num2:Int, num1:Int) ->Int)

minValue = {
    $0 + $1 + $2
}
var sum = minValue(num: 5, num2: 5, num1: 6)
print(sum)

上面写了4中不同的实现闭包的方法，还有，本篇文章的代码是前后连接的，想扩展那个地方，是沿用了上面的代码的。

到这里，swift的课程就学完了，还有swift第三天的课程，是通讯录实战，用swift写一个通讯录吧。敬请期待！！