一、lazy关键字的用法：
1.类和结构体中,不能在枚举中使用
2.不能被子类重写,但可以在子类中给它添加监测功能
3.Lazy关键字使用(只能用于存储属性)
1.只能用于存储属性
2.修饰的属性必须有初始化
3.在结构体中使用Lazy修饰的属性,在访问的方法前必须加mutating修饰
4.不能用于全局属性或者静态变量
5.存储属性被lazy修饰,只被初始化一次,在多线程访问时,不需要使用lazy标记
structRange1 {
//结构体定义存储属性
letfirst:Int
varlength:Int
}
classStudent1 {
//类定义存储属性
varname:String!
varscore:String!
}
/**------计算属性------*/
//1.结构体使用
structRange2 {
//结构体定义存储属性
varfirst:Int
varlength:Int
//有setter和getter的计算属性
varmyFirst:Int{
set{
first= newValue
}
get{
returnfirst
}
}
//只有get方法计算属性
varmyLength:Int{
get{
returnlength
}
}
}
//2.枚举中使用
enumPerson:String{
caseMan ="男"
caseWomen ="女"
//有setter和getter的计算属性
varrename:String{
set(newName) {
self=Person.init(rawValue: newName)!
}
get{
returnself.rawValue
}
}
//只有get方法计算属性,如果计算属性只有getter方法,那么这个get可以被省略
varname:String{
returnself.rawValue
}
}
varperson =Person.Man
//print(person.name)
person.rename="女"
//print(person.rawValue)
/**------监测属性------*/
//监测属性,其实是给存储属性上添加的一种监测功能,willSet监测新值,didSet监测旧值
classCircle {
vararea:Double=0.0
varr:Double=0.0{
willSet{
//print("有新值")
area=Double.pi* newValue * newValue
}
}
}
letcircle =Circle.init()
circle.r=10.0
//print(circle.area)
funccalcalate(r:inoutDouble) {
//print("函数执行开始")
r =2.0
//print("函数执行结束")
}
calcalate(r: &circle.r)
structAnimal {
lazyvarname ="动物"
mutatingfunccalculate() {
//let name = self.name
}
varmyName:String{//只有get方法计算属性
mutatingget{
returnname
}
}
}
二、static和class关键字的用法：
1.可以修饰方法,static修饰的方法叫做静态方法,class修饰的叫做类方法
2.都可以修饰计算属性
class不能修饰存储属性
class修饰的计算属性可以被重写,static修饰的不能被重写
static可以修饰存储属性,static修饰的存储属性称为静态变量(常量)
static修饰的静态方法不能被重写,class修饰的类方法可以被重写
class修饰的类方法被重写时,可以使用static让方法变为静态方法
class修饰的计算属性被重写时,可以使用static让其变为静态属性,但它的子类就不能被重写了
class只能在类中使用,但是static可以在类,结构体,或者枚举中使用
classPeople {
staticvardesc:String="一个人"
classvarscore:Int{
return0
}
// class修饰的类方法可以被子类重写,static修饰的静态方法不能被重写
classfuncgetScore() ->Int{
returnscore
}
}
classMan:People{
//重写计算属性可以使用static来重写哦,但是static重写后,就不能被它的子类再次重写了
classoverridevarscore:Int{
return1
}
//重写类方法时可以使用static让其变成静态方法
staticoverridefuncgetScore() ->Int{
returnscore
}
}
//1.参数是闭包执行的结果
classPerson1 {
varname:String
varscore:Int
init(name:String, score:Int) {
self.name= name
self.score= score
}
//属性=号后面的函数不能定义在类内,因为初始化未完成之前是不能调用对象方法的
letdesc:String= {
//print("闭包已经执行")
return"我在\(getTime())被创建了"
}()
}
//获取时间
funcgetTime()->Date{
returnDate()
}
letp =Person1(name:"12345", score:3)
//2.参数是闭包
classPerson2 {
varname:String
varscore:Int
init(name:String, score:Int) {
self.name= name
self.score= score
}
//注意看和上面的区别
letdesc: () ->String= {
//print("闭包被执行了")
return"我在\(getTime())被创建了"
}
}
//获取时间
funcgetTime2()->Date{
returnDate()
}
funcmyDescribe2()->String{
return"我在\(getTime())被创建了"
}
letp2 =Person2(name:"56789", score:3)
letpd =p2.desc()
//有个自定义类,类中有一个数组,数组中包含20位斐波那契数列
classCalculate {
varfibo:[Int] = {
//定义一个数组
varnums:[Int] = []
funcFunction(n:Int) ->Int{
ifn <2{
returnn
}else{
returnFunction(n: n-1) +Function(n: n-2)
}
}
foriin0..<20{
nums.append(Function(n: i))
}
returnnums
}()
}
letc =Calculate.init()
print(c.fibo)
网友评论