今天需要掌握的内容就是：闭包、类、结构体、属性（计算属性和延迟属性）
同样里面有一些题目，有兴趣的可以做一下.
首先我们需要知道什么是闭包？所谓的闭包就是一个代码块（一般是指函数以及被它捕获的成员变量和对象等）
其次我们需要掌握如何定义类和结构体，和我们学习java有什么不同点.
类的定义
class 类名{
//需要定义的属性
}
结构体的定义
struct 结构体名{
//需要定义的属性
}
大家看它们的不同就是一个是class，一个是struts，现在先不揭秘让他们的区别，在代码中，我们将会看到它们的不同.
我们先来学习闭包：
在闭包的使用中，我们会先从一个比较齐全的闭包开始，一步一步进行简化.
var str = "Hello, playground"
func outer() -> ()->Void{
let x =
func inner() {
print(x)
}
return inner
}
let result = outer()
result()
//闭包：一个代码块（一般指的就是函数）以及被它捕获的一些
//成员（变量，对象等等）
//闭包的种类有三种
//1.就是一个普通的全局函数，这是一个有名字的闭包。
//2.内部函数，比如上面的inner，此函数可以捕获它声明的时候所用到的东西
//3.闭包表达式，类似于c#语言的lambda表达式
func outer2 (f: ()->Void) {
f()
func outer3 (f: (Int,Int) -> Int) {
let re = f(,)
print(re)
}
outer3(f: {(a: Int, b: Int) in
print("test...")
return a + b
})
//闭包的语法：闭包等价于创建了一个匿名函数
//格式：{(参数名: 类型,参数名： 类型) in }
let arr = [,,,,]
//最完整的闭包写法
//let filtered = arr.sorted(by: {(a: Int,b: Int) in
//
// return a < b
//})
//类型可以依据sorted方法的声明，推断出来，所以可以省略
//let filtered = arr.sorted(by: {(a ,b ) in
//
// return a < b
//})
//因为只有一行代码，自动把此行代码的结果返回出去，所以可以去掉return
//let filtered = arr.sorted(by: {(a ,b ) in
// // print("sfda")
// a < b
//})
//因为swift自动提供隐含的变量名，以$0开始，所以
//参数可以去掉，因为参数去掉in就没意义，所以in也可以去掉
//let filtered = arr.sorted(by: { $0 < $1})
//因为sorted方法只有一个参数，而且是函数类型的参数
//所以可以把闭包写在小括号的外面
//let filtered = arr.sorted(by:){ $0 < $1}
//因为只有一个参数
let filtered = arr.sorted{ $ < $}
filtered
//swift中的一些符号其实是函数，比如下面的>
let filtered2 = arr.sorted(by: >)
print(filtered2)
/*** escaping(跳出，逃出)和自动闭包（autoclosure)*/
//自动闭包，就是把表达式自动转换为闭包
//有前提：函数的声明不能有参数，但必须有返回值，返回值的类型，没有要求
func outer3(f: @autoclosure ()-> Int ) {
let s = f()
print(s)
}
outer3(f: )
//escaping : 函数传递进去时，没有使用，需要加escaping
var farr = [()-> Void]()
func outer4(f: @escaping () -> Void ) {
farr.append(f)
}
outer4(f: {print("escaping....")})
farr.first?()
//可以这样理解：闭包就是一个函数的替代，简化一些方法的使用
接下来就是类和结构体的讲解
/********类与结构********************/
class SomeClass {
let a = //存储属性
var b =
}
struct SomeStruct {
let a =
var b =
}
let lei = SomeClass()
//不行：lei = SomeClass()
//lei.a = 333 不能改
lei.b =
let jiegou = SomeStruct()
//jiegou.a = 5555
//jiegou.b = 6666 //a,b 都不能改变值
//a,b不能修改原因就是结构是一个值类型
var jiegou2 = SomeStruct()
//jiegou2.a = 222
jiegou2.b =
jiegou2.b
/*
类与结构：
1.类是引用类型，结构是值类型
2.类可以继承，结构不能
什么时候用结构？
1.你的类型，如果只是一些数据的封装，那么可以考虑用结构
用结构的案例：
矩形：长，宽
地址：家庭地址，办公地址
*/
最后面就是属性
/************* 属性 ****************/
//存储属性（stored property）
//class SomeClass2 {
// var p1 = 6
//}
class SomeClass2 {
var p1 = {
willSet {
print("before\(newValue)")
}
didSet {
print("after\(oldValue)")
}
}
}
let ins = SomeClass2()
ins.p1 =
//计算属性
class SomeClass2 {
var other =
var p: Int {
get {
return other
}
set {
other = newValue
}
}
//在swift中不能有只写（只有set）
//可以有只读属性，此时可以省略掉get{}
var p1: Int {
print("asdf")
return
}//p1 end
}
//属性的demo
class Person {
var name = ""
var _age =
var chengnianren = false
var age: Int {
get{
return _age
}
set {
if newValue >= {
chengnianren = true
} else {
chengnianren = false
}
_age = newValue
}
}
}
let p = Person()
p.age =
p.chengnianren
p.age =
p.chengnianren
//*********** 延迟属性 ****************
class A {
init() {
print(" a实例化")
}
}
let ains = A()
class B {
let name = "cj"
lazy var lazyp = A()
}
let bins = B()
bins.name
bins.lazyp
//静态的属性，可以用static与class修饰
//class不能修饰在存储属性上
//静态的属性里面只能访问静态的其它成员
//class修饰的成员是可以被子类所重写的而static修饰的是不能被重写的。
class C {
static var sp =
var sp2 =
class var sp3: Int {
get{
return
}
set{
sp = newValue
}
}
}
C.sp
C.sp3 =
闭包还是有点难理解的，但是细细品味就会有不一样的味道，就像红酒一般得细细品.