Swift基础二

一、可选类型

?表示可选类型，代表该变量可以正常赋值，也可以为nil

如果一个对象用”?”修饰，就代表这是一个可选类型的对象，其值可以为nil，但是如果取值的时候想使用其真正的值，就需要在该对象后面加上”!”，表示解包，取出真实值使用

虽然可选类型可以为nl，但是如果其值为nil的时候去使用该对象，会崩溃

var a:Int? = 8
var b = a! //解包，取a真实的值
print(b)

二、闭包

闭包：封闭的代码块，类似于block
语法格式：
{
(参数列表) ->返回值类型 in
闭包的代码块
}

函数类型：参数个数，参数类型，返回值类型
int maxValue(int a,int b)
函数类型是：有两个int型的参数，一个int型返回值

例：求两个数的最大值
var maxValue:((a:Int,b:Int)->Int)
maxValue = {
    (a:Int,b:Int)->Int in//关键字 in
    return a > b ? a : b
}
print(maxValue(a:5,b:6))

三、结构体

声明一个协议
如果一个协议里面有可选方法，那么久需要在该协议面前加上@objc
//Swift中结构体只能遵守必须执行的协议，如果一个协议中有可选方法，只能用类去实现

//@objc
protocol proMethodDelegate{
    //默认就是必须执行的方法
    func proMethod()->String

    /*
        可选方法,用关键字optional修饰
        optional func proOptionalMethod()->String
    */
}

//定义一个点的结构体
struct Point {
    var x = 0
    var y  0
}
//定义一个size的结构体
struct Size {
    var w = 0
    var h = 0
}

struct Rect:proMethodDelegate {//在结构体名后面遵守协议
    //1、Swift中不叫成员变量，叫属性
    var origin = Point()
    var size = Size()
    //构造函数(就是OC中的初始化方法)

    //2、为该结构体创造一个构造函数
    init(x:Int,y:Int,w:Int,h:Int){
        self.origin.x = x
        self.origin.y = y
        self.size.w = w
        self.size.h = h
        print("创建了一个Rect对象")
    }

    //3、在Rect结构体里面定义一个静态方法(和OC中的类方法类似)，要用static修饰
    static func classMethod(){
        print("结构体静态方法")
    }

    //4、结构体可以实现协议方法
    func proMethod()->String{
        return "结构体实现的协议方法"
    }
}

结构体的使用

var rect:Rect = Rect(x:10, y:10, w:10, h:10)
print(rect)

//结构体调用静态方法
Rect.classMethod()
//结构体对象调用协议方法
print(rect.proMethod())

四、类和对象

Swift中也是单继承，但并不是所有的类都必须要继承NSObject
可以自定义基类

class Person {
    //在Swift中属性有三种
    //1、储存属性：就是用来保存某个值而使用的，类似于OC的实例变量，储存属性还有延迟储存属性(懒加载)
    var name:String
    var age = 20
    var chines = 0
    var math = 0
    var english = 0

    //延迟属性的关键字lazy
    lazy var f:File = File()

    //2、计算属性：专门用来处理属性数据的运算
    计算属性一定是变量
    计算属性一定会重写setter 和 getter方法
    var num:Int{

        get{
            return chinese+math+english
        }

        set(newValue){
            print("newValue为\(newValue)")
        }
    }

    //3、类属性：用类直接调用的属性
    类属性只能是计算属性
    class var cVar:String{
        get{
            return "类属性"
        }
    }


方法：
Swift中所有的属性都必须赋初始值，如果在类里面声明属性的时候没有初始值，那么在构造函数中就必须初始化，如果有多个初始化方法，那么每个初始化方法都要对没有赋值的属性进行赋值。例如name这个属性
//默认初始化方法
    init(){
        self.name = ""
        print("默认初始化方法")
    }

方法的重载：OC中没有这个概念，主要借鉴java和C++的概念
重载：方法名一样，参数不一样（参数名和参数个数）
//自定义构造函数（初始化方法）,swift中是不需要写return
    init(name:String,age:Int){
        self.name = name
        self.age = age
    }
便利构造器（实质上还是调用正常的构造函数），就是在正常的构造函数前面加上关键字convenience

    convenience init(Name:String, Age:Int){
        self.init(name:Name,age:Age)
    }
析构函数，类似于OC里面的dealloc
    deinit{
        print("大清亡辣")
    }

    func sleep(){
        print("碎觉") 
    }

}
文件类
class File{
    init(){
        print("大文件")
    }
}

//创建Person类对象

var p = Person()
p.chinese = 80
p.math = 60
p.english = 90
print(p.sum)
print(p.cVar)

//便利构造器的使用
var p = Person.init(Name:"XiaoA",Age:27)
print(p.name)

//析构函数
func test(){
    _ = Person()
}
test()

五、面向对象特性

1、继承
class Man:Person {

override是重写父类方法的关键字
子类的初始化方法会先调用super指针为其创建一个父类对象

override init(){
    super.init() //继承的核心是super指针
    print("Man 初始化")
}

子类重写父类的方法会优先调用子类的方法
override sleep(){
    print("Man 碎觉")
}

func eat(){
    print("Man eat")
}
}
var m:Man = Man()
m.sleep()

六、多态

多态：父类指针指向子类对象

通俗的解释就是：因为子类里面可以添加自己的方法和属性，相对于父类而言，子类里面的方法和属性会更多，因此相对来说父类的指针能指向的范围比较小，而子类的指针能指向的范围比较大，一个小范围的指针指向大范围的区域是不会溢出的，只是有些范围访问不到而已。但是如果把一个大范围的指针指向一个小范围，就有可能指向父类这个小区域以外，从而访问不到想要访问的东西，引起程序崩溃。所以子类指针指向父类对象，在OC中语法没错(报不匹配的警告)，但是会有上述隐患，所以一般来说我们只把多态看作是父类指针指向子类对象。
在Swift中子类指针指向父类对象会直接报错

class Woman:Person {
    override func sleep(){
        print("Woman sleep")
    }

    func eat(){
        print("Woman eat")
    }
}

创建Woman对象

var woman:Woman = Woman()
woman.sleep()

//父类指针指向子类对象

var p:Person = Woman()
p.sleep() //多态：并不取决于这是谁的指针，而是取决于这是谁开辟的内存空间

子类指针指向父类对象

var w:Woman = Person()

七、延展

OC中在延展里面可以向一个类添加实例变量、属性和方法
但是在Swift中只能添加方法
//延展关键字 extension

extension Woman{
    func wash(){
        print("Woman wash")
    }
}
woman.wash()