初学swift笔记 结构体（八）

 

import Foundation
/*
和类很相似

结构体 －> 封装
属性、方法
结构体是值类型
*/

//定义一个LSQ类型的结构体 关键字struct
struct LSQ {
    var Name: String = ""
    var Age: Int = 1
}
struct LSQ1 {
    var Name: String
    var Age: Int
}
struct LSQ2 {
    var Name: String
    var Age: Int=1
}

//结构体实例和属性访问
//声明一个变量
var liu : LSQ = LSQ()
var liu1 : LSQ1 = LSQ1(Name: "liuq", Age: 18)
liu.Age=19
liu.Name="zhong"

liu1.Name="ha"
liu1.Age=20

println(liu1.Name)
println(liu.Name)
var liu2 : LSQ2 = LSQ2(Name:"AA",Age:1)
println("\(liu2.Age):\(liu2.Name)")

//定义带有函数的结构体
struct m_lsq_1 {
    
    var Name : String = ""
    var Age : Int = 1
    func getName() -> String {
        return Name
    }
}

var temp1 = m_lsq_1(Name: "王建国", Age:30)
println(temp1.getName())


//结构体是值类型 不是引用类型
var temp2=temp1
println(temp2.getName())
temp2.Name="TempName"
println(temp2.getName())



/*
类
属性、方法
类是引用类型

class 类名 ｛
    成员变量
    成员方法
｝
*/
//定义一个类
class m_class_1 {
    func m_class_1() {
        Name="m_Name"
        Age=1
    }
    var Name : String = ""
    var Age : Int = 0
}
//引用类型
var class_1 = m_class_1()

println(class_1)

var class_2 = class_1

println(class_2)

//当需要判断多个常量或变量是否是同一个实例时 用 === 恒等于  !== 不等于 判断
if class_1 === class_2 {
    println("相同")
}

/*
常量 结构体、枚举 是值类型， 常量不可修改，其属性不可修改
常量 类类型，是引用类型，常量不可修改，其属性可以修改
*/
//存储属性
//结构体存储属性
struct person {
    var name : String //变量存储属性
    let sex : String = "男" //常量存储属性
}

var m_p = person(name: "lsq", sex: "男")
//常量属性不可修改
println(m_p.sex)
let m_p_1 = person(name: "t", sex: "n")
//m_p_1.name="lsq" // m_p_1是一个常量，其属性不可修改

//类存储属性
class c_person {
    var name : String = "" //变量存储属性
    let sex : String = "男" //常量存储属性
}
let c_p = c_person() //c_p 是一个常量，其属性可修改
c_p.name="lsq"
println(c_p.name)

let c_p1 = c_person()
// c_p = c_p1  //类常量不可修改

//延迟存储属性
//swift中所有的存储属性必须有初始值，也就是当构造完一个类或结构体对象后，对象中所有的存储属性必须有初始值，但有例外，其中延迟存储属性可以将属性的初始化向后推迟到该属性第一次使用时赋值 关键字lazy
//使用延迟属性：1.属性不适合一开始就初始化，取决于外部对很多因素 2.属性有可能从来都不用，但是它对初始化会需要很长时间
//学生结构体
struct student {
    var name : String
    var age : Int
    func get_name() {
        println("我的姓名是:\(name)")
    }
}
//班级类
class my_class {
    var members : [student] = []
    lazy var score : Double = self.getScore()  //延迟属性  lazy关键字 score的值是 getScore（）结果  当访问score时才去调用方法
    //计算平均值
    func getScore() -> Double {
        var t: Double = 0
        for i in members {
            t += Double(i.age)
        }
        if members.count > 0 {
            return t / Double(members.count)
        }
        return 0
    }
    //显示所有name
    func show () {
        for i in members {
            println(i.name)
        }
    }
    func show_1() {
        for i in members {
            i.get_name()
        }
    }
    
}
//常规用法
var s1 = student(name: "小明", age: 8)
var s2 = student(name: "小红", age: 10)
var c1 = my_class()
c1.members.append(s1)
c1.members.append(s2)
c1.show()
c1.show_1()
println(c1.getScore())

//使用延迟属性
var c2 = my_class()
c2.members.append(s1)
c2.members.append(s2)
println(c2.score)


/*
计算属性 
1.计算属性不直接存储其值，与存储属性不同，没有任何后端存储与之对应
2.计算属性用于计算，可以实现setter和getter 两种计算方法
3.枚举不可以有存储属性，但是允许有计算属性
对象.属性 ＝ 某值 setter
let value = 对象.属性 getter
个人理解：与c#中的get set 相似，对象存放结果，每次获取结果需要计算
swift中的计算属性，不可以直接存储任何的值。

只读属性  如果计算属性只提供了get 没有提供set那么该属性是只读属性
*/

struct m_rect {
    var origion: (x: Double,y: Double) = (0,0)
    var size: (w: Double,h: Double) = (0,0)
    //size是计算属性，不能直接赋值，
    var center : (x: Double,y: Double) {
        get {
            //获取的值是重新计算的
            return (origion.x + size.w/2 , origion.y + size.h/2)
        }
        set(n) {
            //赋值的时候直接给 origion赋值
            origion.x = n.x - size.w/2
            origion.y = n.y - size.h/2
            //origion.x = n.0 - size.w/2
            //origion.y = n.1 - size.h/2
        }
        /*
        当不指定n的时候，默认写法是 newValue 表示要赋的值
        set {
            //赋值的时候直接给 origion赋值
            origion.x = newValue.x - size.w/2
            origion.y = newValue.y - size.h/2
        }
        */
    }
}

var rect = m_rect()
rect.size = (100,100)
println(rect.origion)
rect.center = (12 ,23)
println(rect.origion)


/*
计算只读属性
如果计算属性只提供了get 没有提供set那么该属性是只读属性

*/
//学生结构体
struct student_1 {
    var name : String
    var age : Int
    func get_name() {
        println("我的姓名是:\(name)")
    }
}
//班级类
class my_class_1 {
    var members : [student_1] = []
    lazy var score : Double = self.getsum()  //延迟属性
    //计算属性  只读属性  只提供了get方法
    var allage : Double {
        
        get{
            return getsum()
        }
    }
    //只读计算属性的简写 省略 get关键字
    var allages : Double {
            return getsum()
      }
    func getsum() -> Double {
        var t: Double = 0
        for i in members {
            t += Double(i.age)
        }
        return t
    }
    
}
var c3 = my_class_1()
c3.members.append(student_1(name: "小明", age: 8))
c3.members.append(student_1(name: "小红", age: 10))
println(c3.allage)


/*
    属性观察器
当类中的属性或方法的某个值发生了变化，则调用指定的方法  在OC中称之为KVO 
willSet 修改前被调用
didSet 属性被修改之后调用
相当于注册了两个事件

*/
class my_class_3 {
    var t_value : Double = 0{
        willSet {
            println("WillSet调用:\(newValue)")
        }
        didSet {
             println("didSet调用:\(oldValue)")
        }
    }
    
}
 var m_3 = my_class_3()
m_3.t_value = 1

//类型属性 可以理解为静态变量
//在结构体中用static关键字修饰 在class类中用class关键字修饰
struct type_property {
    var property : Int = 0
    //类型属性， 该变量属于当前类的 ，与其他语言中的静态变量相似 不同的是访问该变量时 只能通过类名.出该变量 所有实例化该类的对象共用此变量
    static var static_property : Int = 0
}
var obj = type_property()
obj.property = 10
type_property.static_property = 10