Swift 常识篇二

一 可选类型

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

如果一个对象用（问号）？修饰就表示这是一个可选类型，其值是可以为空的，但是如果我们想使用他真正的值的时候，就需要在该对象的后面加上一个！表示解包取出真实值使用

虽然可选类型可以为nil，但是如果为nil的时候你去使用，仍然会崩溃

var a:Int? = 8var b = a!print(b)

二 闭包

闭包：封闭的代码块，类似于block
1.语法格式
{
（参数列表） 返回值类型 in
闭包代码块
}

2.函数类型 ：参数个数，参数类型，返回值类型

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

三结构体

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

protocol proMethodDelegate{    //默认是必须执行的    func proMethod()->String    //可选方法   // optional func proOptionalMethod()->String}//定义一个点的结构体struct Point {    var x = 0    var y = 0}//定义一个size的结构体struct Size {    var width = 0    var height = 0}struct Rect :proMethodDelegate{    //1.属性    var origin = Point()    var size = Size()

2.构造函数（就是OC里面的初始化方法）

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

3.在Rect结构体里面定义一个静态方法和（OC中的类方法一样），要用static修饰

static func classMathed(){        print("这是一个结构体的类方法")    }

4.结构体可以实现协议方法

 func proMethod() -> String {        return "这是一个结构体实现的协议方法"    }

结构体调用结构体的类方法（类方法用方法名调用）

Rect.classMathed()

结构体的使用
var r:Rect = Rect(x: 10, y: 10, w: 100, h: 100)
print(r)

结构体调用协议方法

print(r.proMethod())

四 类和对象

1.Swift中也是单继承，但并不是所有的类都要必须要继承于NSObject
没有继承的类，表示是基类

    /*    在Swift中属性有三种    1.储存属性：就是用来保存某个值使用的，很类似于OC的实例变量    2.计算属性：专门用来处理属性数据的运算    3.类属性：用类直接调用的属性    */    //1.储存属性    var name:String    var age = 20    var chinese = 0    var math = 0    var english = 0    //延迟储存属性（懒加载）   lazy var f:file = file()    //2.计算属性    //计算属性一定是变量，一定还会重写set或者get方法    var sum:Int{        get{           return chinese + math + english        }        set(newValue){           print("newValue的值为\(newValue)")        }    }//    3.类属性    //类属性只能是计算属性    class var cVar:String{        get{            return "这是一个人的类属性"           }    }

2.方法
Swift中所有的属性都必须赋初始值，如果在类里面声明属性的时候没有初始值，那么在构造函数中必须初始化，如果有多个初始化方法，那么每个初始化方法都要对没有赋值的属性进行赋值，例如：name这个属性

默认的构造函数（初始化方法）

 init()    {        self.name = ""        print("这是人类默认是的初始化方法")    }

方法的重载：OC中没有这个概念，借鉴的Java和C++里面的概念
方法名一样，只是参数不一样（参数名和参数个数）

自定义构造函数

init(name:String,age:Int)    {        //在swift中不用写return        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 = 80p.math = 90p.english = 40print(p.sum)p.sum = 100  //走的set方法print(Person.cVar)//便利构造器的使用var per = Person.init(Name: "a", Age: 22)print(per.name)func test(){    _  = Person() //走了析构函数}print("****************函数调用前******************")test()print("****************函数调用后******************")

五面向对象特性

1.继承

class Man: Person {    //override：重写父类方法的关键字，子类的初始化方法会先调用super指针为其创建一个父类对象    override init() {        super.init() //核心指针        print("这是一个男人的初始化方法")    }    //子类重写父类方法，优先调用子类里面的方法    override func sleep() {        print("是不是傻")    }    func eat(){        print("吃饭")    }}var m = Man()m.sleep()m.eat()

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

为什么说OC是一门动态运行时语言

因为子类里面可以添加自己的方法，相比于父类来说，子类里面的方法和属性会更丰富，所以父类的指针能指向的范围比较小，而子类指针的范围比较大，一个小范围的指针指向大范围的，肯定不会溢出范围，只是有些范围指不到而已，但是如果大范围的指针指向小的区域，就有可能，指向小区域以外的东西，从而找不到想要的内容，引起程序崩溃，所以子类指针指向父类对象，在语法上没有错误(Swift中直接报错，OC不会)，但是有以上隐患，所以我们只把多态看作是父类指针指向子类对象

class Woman:Person {    override func sleep() {        print("女的在睡觉")    }    func eat(){        print("女的在吃")    }}//woman对象(正常)var w = Woman()w.sleep()print("****************************************")//父类指针指向子类对象var p4:Person = Woman()p4.sleep()

子类指针指向父类对象
var w1:Woman = Person() 会报错

3.延展
在OC中延展里面可以像一个类里面添加，实例变量，属性和方法
在Swift中只能添加方法

extension Woman{    func wash(){        print("就不洗衣服")    }}w.wash()