var optionalStr: String? = "swift语言可选类型"//声明可选类型字符串，并赋初值
var opStu:Student? //声明可选opStu对象，值为nil
var  c：Int！//声明为可自动解包的可选类型，值为nil，即没有值

var a :Int//这是错误的定义方式，在Swift中是无法通过的

int a = 0;//定义一个int型变量，并赋值为0
int a;//定义了一个int型变量，虽然没有显示的指定其值，但是默认的设置了一个0

//定义一个可选类型的变量
var e :Int?//处于没有值的状态
e = 3//当前的a，是有值的状态
print(e)
e = nil//当前的e，又变成了一个没有值的状态

var myStr:String? = nil
myStr="强制解析，一定有值"
if myStr != nil {
    print(myStr!)//使用！进行强制解析
}else{
    print("字符串为nil")
}

//执行结果
强制解析，一定有值

1.3 自动解析

var myStr:String! //使用！修饰
myStr="自动解析"
if myStr != nil {
    print(myStr)
}else{
    print("字符串为nil")
}

//执行结果
自动解析

1.4 可选绑定

var myStr:String?
myStr="可选绑定"
if let tempStr = myStr {
    print(tempStr)
}else{
    print("字符串为nil")
}

//运行结果
可选绑定

1.5 guard let

let name: String? = "张三"
let age: Int? = 10

guard let nameNew = name,
      let ageNew = age
else {
        print("姓名 或 年龄 为nil")
        return
}

print("姓名 或 年龄 为\(name),\(age)")//运行到这里是一定有值的

1.6 双问号取值

//如果e有值，则获取e中的值
//没有值，则赋值为5
let a = b??5

//所以a的值要么是b的值，要么就是5
print(a)//所以运行到这里，a也是一定有值的

1.7 as！与as？的类型转换

1.7.1 as

• 向上转型upcasts，从派生类转换为基类

// 定义人员基类 class Person {
    var name : String init(_ name: String){
        self.name = name
    }
} // 定义学生类 class Student : Person {
} // 定义教师类 class Teacher : Person {
} // 处理人员对象的函数(或工厂模式处理操作等)
func showPersonName(_ people : Person){
    let name = people.name print("这个人的名字是: \(name)")
}
 // 定义一个学生对象 tom
var tom = Student("Tom"); 
// 定义一个教师对象 kevin
var kevin = Teacher("Kevin Jakson"); // 先把学生对象向上转型为一般的人员对象
let person1 = tom as Person
let person2 = kevin as Person // 再调用通用的处理人员对象的showPersonName函数
showPersonName(person1)
showPersonName(person2)</pre>

//运行结果
这个人的名字是：Tom
这个人的名字是：Kevin Jakson

• 消除二义性，数值类型转换

let age = 28 as Int
let money = 20 as CGFloat
let cost = (50 / 2) as Double

• 在switch语句中进行模式匹配

switch person1 { 
  case let person1 as Student: 
    print("是Student类型，打印学生成绩单...") 
  case let person1 as Teacher: 
    print("是Teacher类型，打印老师工资单...") 
  default: break
}

//运行结果
是Student类型，打印学生成绩单

1.7.2 as!

let person : Person = Teacher("Jimmy Lee")
let jimmy = person as! Teacher

1.7.3 as?

let person : Person = Teacher("Jimmy Lee") if let someone = person as? Teacher{  print("这个人是教师, 名字是 \(someone.name)")  } else {  print("这个人不是教师, 'tom'的值是 nil") }

2、使用场景

func returnOptionValue(value: Bool) -> String? { // 返回类型为可选String类型
    if value {
        return "返回类型是可选类型值" 
    } else {
        return nil //返回nil
    }
}

let optionValue = returnOptionValue(value: true) // 要用可选绑定判断再使用，因为returnOptionValue为String？可选类型
if let value = optionValue {
    print(value)
} else {
    print("none value")
}

//执行结果
返回类型是可选类型值

func returnOptionalFunc(value: Bool) -> (() -> (Void))? { // 返回类型为可选类型的闭包
    if value {
        return { () in
            print("返回类型是可选类型闭包")
        }
    } else {
        return nil
    }
}

let possibleFunc = returnOptionalFunc(value: true) // 要用可选绑定判断再使用，因为possibleFunc 为可选类型的闭包，类型为() -> (Void)
if let aFunc = possibleFunc {
    print(aFunc())  // 注意增加()调用闭包，因为没有参数则是空括号
} else {
    print("none func")
}

//执行结果 返回类型是可选类型闭包 

2.2  可选类型在类或结构体中的运用

class PossibleClass {
    var someValue: Int
    var possibleValue: String? // 可选存储属性，默认值为nil
    init(someValue: Int) { // 构造方法中可以不对possibleValue属性初始化
        self.someValue = someValue //但是someValue是非可选类型变量，所以在构造方法中，一定要对其进行初始化
    }
}

let someClass = PossibleClass(someValue: 4)

struct PossibleStruct {
    var someValue: Int
    var possibleValue: String? // 可选存储属性，默认值为nil
    // 结构体中可以自定义一个init构造器对属性初始化，也可以不自定义
}

let someStruct = PossibleStruct(someValue: 4, possibleValue: nil)

2.3 可选类型在构造器中使用

class PossibleStructInit {
    let someValue: String
    init?(someValue: String) { // 可失败构造器
        if someValue.isEmpty { return nil } // 如果实例化为空串，则返回nil(即实例化失败)
        self.someValue = someValue
    }
}

let oneStruct = PossibleStructInit(someValue: "构造器中使用") // abc不是空串，oneStruct为PossibleStructInit？可选类型
if let one = oneStruct { // 使用if let可选绑定判断
    print(one.someValue)
} else {
    print("none value")
}
//输入结果为：构造器中使用

let twoStruct = PossibleStructInit(someValue: "") // 传参为空串
if let two = twoStruct {
    print(two.someValue)
} else {
    print("none value")
}
//输入结果为：none value

2.4 可选类型在错误处理中使用（try！与try？）