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()

五、面向对象特性<
a35a
/h2>

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()