swift基础介绍-3

1、函数

func 函数名(参数列表) -> 返回值类型 { 
      代码块
      return 返回值
}

// 1-1没参数，没返回值
func about()->Void{
    print("liyang")
}
about()
// 没有返回值，Void可以写成()，后面的内容也可以不写
func about2(){
    
}

// 1-2,有参数，没返回值
func about3(_ name : String){
    print(name)
}
about3("liyang")

// 1-3，有参数，有返回值
func about4 (_ name : String, age year : Int) -> (String,Int){
    return (name,year)
}
about4("liyang", age: 18)

使用注意:
1-1、外部参数和内部参数
内参：在函数内部能看到的参数
外采：在函数外部能看到的参数

func online (外参  内参 : 参数类型){
}

1-2、在某些情况下，没有传入具体的参数，可以使用默认参数

func makecoffee(type : String = "卡布奇若"){
    print(type)
}
makecoffee(type: "coffee") // coffee
makecoffee() // 卡布奇若

1-3、可变参数
swift中函数的参数个数可以变化，它可以接受不确定数量的输入类型参数；
它们必须具有相同的类型；
我们可以通过在参数类型名后面加入（...）的方式来指示这是可变参数；

func sum(nums : Int...) -> Int {
    var result = 0
    for num in nums {
        result += num
    }
    return result
}
sum(nums: 1,2,3,4,5)//15

2、枚举类型

enum Year {
   case Monkey
   case pig
   case cow
}

3、结构体
结构体(struct)是由一系列具有相同类型或不同类型的数据构成的数据集合
结构体(struct)指的是一种数据结构
结构体是值类型,在方法中传递时是值传递

// 初始化结构体
struct Location {
   var x : Double 
   var y : Double
}

// 扩充

struct Location {
    var x : Double
    var y : Double
    
    init(x : Double, y : Double) {
        self.x = x
        self.y = y
    }
    
    init(xyString : String) {
        let strs = xyString.components(separatedBy: ",")
        x = Double(strs.first!)!
        y = Double(strs.last!)!
    }
    
}
extension Location {
    mutating func moveH(x : Double) {
        self.x += x
    }
    mutating func moveV(y : Double) {
        self.y += y
    }
}

4、类
在swift中，有值类型，还有对象类型。
在初始化值类型的时候，我们一直设置它的初始化值是0
在初始化对象类型的时候，我们一般设置它的初始化值是nil（0x0）
在swift中，类不一定非要继承自NSObject

4-1、创建一个类属性

// 类
class Student : NSObject {
    // 定义属性
    // 存储属性
    var age : Int = 0
    var name : String?
    
    var chineseScore : Double = 0.0
    var mathScore : Double = 0.0
}

// 创建学生对象
let stu = Student()

// 给存储属性赋值
stu.age = 10
stu.name = "liyang"

stu.chineseScore = 89.0
stu.mathScore = 98.0

4-2、监听属性的改变
在OC中我们可以重写set方法来监听属性的改变
Swift中可以通过属性观察者来监听和响应属性值的变化
通常是监听存储属性和类属性的改变.(对于计算属性，我们不需要定义属性观察者，因为我们可以在计算属性的setter中直接观察并响应这种值的变化)
我们通过设置以下观察方法来定义观察者

• willSet：在属性值被存储之前设置。此时新属性值作为一个常量参数被传入。该参数名默认为newValue，我们可以自己定义该参数名
• didSet：在新属性值被存储后立即调用。与willSet相同，此时传入的是属性的旧值，默认参数名为oldValue
• willSet与didSet只有在属性第一次被设置时才会调用，在初始化时，不会去调用这些监听方法
  监听的方式如下:
  监听age和name的变化

class Person : NSObject {
    var name : String? {
        // 可以给newValue自定义名称
        willSet (new){ // 属性即将改变,还未改变时会调用的方法
            // 在该方法中有一个默认的系统属性newValue,用于存储新值
            if let temp = name {
                print(temp)
            }
            if new != nil {
                print(new!)
            }
        }
        // 可以给oldValue自定义名称
        didSet (old) { // 属性值已经改变了,会调用的方法
            // 在该方法中有一个默认的系统属性oldValue,用于存储旧值
            if let temp = name {
                print(temp)
            }
            if old != nil {
                print(old!)
            }
        }
    }
    var age : Int = 0
    var height : Double = 0.0
}

let p : Person = Person()

// 在赋值时,监听该属性的改变
// 在OC中是通过重写set方法
// 在swift中,可以给属性添加监听器
p.name = "liyang"

4-3、类的构造函数
我们从写类的构造函数，默认会覆盖点系统的init方法，所以当我们初始化这个类的时候就没有的init方法，若想有init方法，需要重写父类的init方法

class Person2: NSObject {
    var name : String
    var age : Int
    
    // 重写了NSObject(父类)的构造方法
    override init() {
        
    }
    
    // 自定义构造函数,会覆盖init()函数
    init(name : String, age : Int) {
        self.name = name
        self.age = age
    }
}

4-4、类的析构函数

deinit{
// 类似于OC中的dealloc方法
}

5、协议
定义

protocol SomeProtocol : class {
    // 协议方法，默认是必须实现的，如果不实现,则编译器会报错
    func playBasketball()
}

6、闭包
基本写法

闭包的写法:
    类型:(形参列表)->(返回值)
    技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值

    值:
    {
        (形参) -> 返回值类型 in
        // 执行代码
    }

• 技巧：如果闭包没有参数,没有返回值.in和in之前的内容可以省略

httpTool.loadRequest({
 print("回到主线程", NSThread.currentThread())
})

7、懒加载
基本格式

lazy var 变量: 类型 = { 创建变量代码 }()

基本使用

// 懒加载的本质是,在第一次使用的时候执行闭包,将闭包的返回值赋值给属性 
// lazy的作用是只会赋值一次
 lazy var array : [String] = { () -> [String] in 
return ["why", "lmj", "lnj"] 
}()