swift中的类和结构

//类的声明
//类是一个引用类型，也就是说其实例分配到堆中

属性，方法，构造函数，析构函数，，索引器(subscript)
 stored properties 存储属性 computed properties 计算属性

class Person {
   var p1 = 20
        //属性观察器 property observer
var name = "cj" {
willSet{       //在赋值前会调用willSet里面的内容
     // print("before")
    print(newValue)    //新值
    // print(name)

}
didSet(old){
     print("after")
    print(old)
   print(name);
}
}
var p = Person()
p.name="";

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

let p1 = Person()
let p2 = p
p === p1
p === p2
var p2 = 30

 var p = Person()
 p.p1 = 200
//p.p2 = 300 //报错
 p = Person()
 let p = Person() //常量指针
//p.p1 = 200
//p.p2 = 300 // 报错
//p = Person() //报错

不能只有set，只有get的时候，表示只读计算属性，可以简写
计算属性是没有属性观察者

计算属性 ，get set

var age:Int {
get{
return 100
}
set{

}
}

 只可以读的属性

var readOnlyAge:Int {
get{
return 100
}

}

 总结： 1.每次属性设置了一个值后都会被调用，不管这个值是否与原来的值一样。
2.可以给继承过来的属性添加属性观察期，不管这个继承过来的属性是否是
存储属性。
3.willSet参数默认是newValue，
didSet参数默认是oldValue

//构造函数,可以有多个

init(){
print("init")
}

 //反构造函数

deinit {
print("deinit")
}

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

class B {
lazy var p = A()  //lazy代表在实列化的时后不会做init方法
}

let b = B()
b.p
修饰为静态，可以用class和static
存储属性，只能用static，计算属性两个关键字都可以
方法也是两个关键字都可以
区别：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(){

}
}

********下标***********

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]