Swift中static 和 class 关键字的用法:

2017-07-12  本文已影响842人  野比大雄001

一、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)

上一篇下一篇

猜你喜欢

热点阅读