swift学习笔记->类

swift中类的定义方式

class 类名{

　　属性。。。

　　方法。。。

}

类是一个引用类型，其实例是分配到堆中 来看看类里面的属性方法有何不同之处

类中的属性分为存储属性，计算属性

存储属性可以有属性观察器 但计算属性没有 （计算属性在类被继承之后可以添加观察者）

计算属性拥有get set 方法

class Person {
//属性，方法，构造函数，析构函数，，索引器(subscript)
//stored properties   computed properties
var p1 = 20
//属性观察器 property observer
var name = "swift" {
willSet{  //在赋值前会调用willSet里面的内容
//            print("before")
print(newValue) //新值
//            print(name)

}
didSet(old){
print("after")
print(old)
print(name);
}
}
var p2 = 30
//计算属性 ，get set
//不能只有set，只有get的时候，表示只读计算属性，可以简写
//计算属性是没有属性观察者
var age:Int {
get{
return 100
}
set{

}
}

var readOnlyAge:Int {
get{
return 100
}
//当只有get属性时推断为只读属性，get可以省去  如下
}

var readOnlyAge2:Int {

//code.
//code。
return 100

}

//    func m() {
//
//    }
//构造函数,可以有多个
init(){
print("init")
}
//
//    deinit {
//        print("deinit")
//    }
//
}

代码上已经能看到两种属性的写法，方法函数与函数篇写的一样 没有什么区别

值得注意的是 在类的实例化（初始化）时，所有属性都必须有值 否则会出错

恒等于 ：三个等号是判断两个变量是否指向同一个对象

class test{
let a:Int=4
}
var aa=test()
var bb=test()
aa==bb//报错
aa===bb//false
aa=bb
aa===bb//true

修饰

1修饰为静态，可以用class和static

2存储属性，只能用static，计算属性两个关键字都可以

3方法也是两个关键字都可以

4区别：class修饰的表示子类是可以重写这些静态成员

class Image{
static var name = "my"
//class var name2 = "aaa"//存储属性不能用class修饰
static var Age:Int {
get{
return 100
}set{

}
}
static func someMethod() {

// 静态方法中得self不是指的类的实例，而是指类本身
//self
//self.Age  =
}
class func someMethod2(){

}
}

下标subscript

class XiangCe {
var images = [1,2,3,4]

//下标  subscript,可以有多个参数
subscript(index: Int) ->Int {
get{
return images[index]
}
set{
images[index] =  newValue
}
}

func getImage(index: Int)->Int {
return images[index]
}
}

let xc = XiangCe()
xc.getImage(0)
xc[0]
xc[0] =  100
xc[0]

lazy 延迟加载

当属性加上lazy修饰时 在实例化对象时该属性不会初始化，直到调用该属性时才会进行初始化

下面这个例子能看出lazy的作用

class A{
init(){
print("a init")
}
}

class B {
lazy var p = A()
}

let b = B()
//b.p

实例化B类时没有输出 a init 而访问B类中的P属性时输出了 说明它在访问的时候才进行初始化工作