Swift 结构体和类

//*---------------------结构体-------------*/

//swift结构体也具有封装的概念

//swift结构体比OC C语言里面的结构体更加进了一步,里面可以有方法,更接近我们的类

//结构体的定义格式 struct结构体名{成员变量}

struct rect {

var width:Double //按构造方法赋初值

var height:Double

//方法

func getHeightWidth() -> (x:Double,y:Double)//->返回类型位元组

{

return(width,height)

}

func sumHeightWidth() -> (Double)

{

return(width+height)

}

}

//声明结构体对象 var 变量名:结构体类型=结构体类型(参数)

//swift要求当定义一个结构体对象的时候,必须要对里面的变量赋一个固定的值

//结构体的构造方法(就是创建了一个结构体对象,首先他要分配内存空间(这一步由系统自行帮我们完成),分配完内存就会立即调用我们的初始化方法(构造方法)来对变量赋初值)

//swift的结构体初始化方法有两种 一种是成员逐一构造器var rect1:rect=rect(width: 100, height: 100) 一种是系统默认的不带任何参数的初始化方法struct rect {

//var width:Double=0.0 //按构造方法赋初值

//var height:Double=0.0

//}

//var rect1:rect=rect()

var rect1:rect=rect(width: 100, height: 100)

println("\(rect1.width),\(rect1.height)")

//调用

var c_n=rect1.getHeightWidth()

println(c_n)

var w_h=rect1.sumHeightWidth()

println(w_h)

//结构体的整体赋值

var rect3 = rect1

//整体赋值后的可能性有两种(1)rect3与rect1指向同一个内存空间(2)rect3与rect1内容一样,内存空间不一样

//验证方法有两种可以直接打印内存地址还有一种是改变值如果指向统一内存空间则赋值后的也应该改变成一样

rect1.width = 20

println(rect1.width)

println(rect3.width)

//值未变可以知道是第二种 即赋值后内容一样,内存空间不一样

/*----------------------类-----------------*/

//类与结构体在定义的格式上没有太大的区别,类在创建的时候必须要给里面的变量附一个初始值,因为类与结构体不一样,它没有成员逐一构造器

class rectww {

var width:Double=0.0

var height:Double=0.0

}

var re:rectww=rectww()

println("\(re.width),\(re.height)")

//类的整体赋值

//指向同一内存空空间

var ss = re

re.width = 200

println(re.width)

println(ss.width)

//===恒等 !==不等 只能用类

if ss===re{

println("同一个类")

}

else

{

println("不同")

}

//存储属性

//常量存储属性 :只能在构造对象的时候改变值之后不被允许改变

//延迟存储属性

//结构体常量和类常量与存储属性的关系

//结构体常量常量对象,本身是一个常量,对应的属性不可以通过修改它改变

struct person{

let name:NSString = "张三"//常量

var age:Int = 10//变量

}

let per:person=person(name: "李四", age: 20)//在构造对象的时候可以改变值之后不被允许改变 例如会报错//per.name = "王五" //per.age = 39

println(per.name)

//类本身是一个常量,属性可以通过修改它改变

class person1{

let name1:NSString = "张三"//常量

var age1:Int = 10//变量

}

let per1:person1=person1()//在构造对象的时候可以改变值之后不被允许改变 例如会报错

//per1.name1 = "王五"

per1.age1 = 39

println(per1.name1)

//延迟存储属性

/*

swift语言中所有的存储属性都必须要有初始值,也就是当调用完构造方法后对象中的所有变量都应该有一个初始值,但是延迟存储属性很例外,它的赋值并不都在调用构造方法的时候被初始化,而是在第一次被调用的时候初始化

*/

struct student {

var name:String

var chinese:Double

var math:Double

func showMyStudent(){

println("姓名:\(name),语文成绩:\(chinese),数学成绩:\(math)")

}

}

class myClass {

var array:[student]=[]

lazy var score :Double = self.getScore()//延迟

func getScore()->Double{

println("888888")

var t:Double = 0

for i in array

{

t+=i.chinese

t+=i.math

}

if array.count == 0

{

return 0

}

else

{

//swif里面只有隐式类型推断,没有隐式类型转换

return t/Double (array.count)

}

}

func show(){

for i in array

{

i.showMyStudent()//直接调用方法

}

}

}

let stu1 = student(name: "张三", chinese: 100, math: 100)

let stu2 = student(name: "李四", chinese: 100, math: 100)

//创建类的对象

let c0 = myClass()

c0.array.append(stu1)//加到数组

c0.array.append(stu2)

c0.show()

println(c0.getScore())

println("********")

//计算属性

/*

1.swift中的计算属性不能直接存储数据,与我们的存储属性不同,没有任何的"后端存储与之对应",简单来说就是在对对象中各种不占用存储空间

2.计算属性用于计算,可以实现setter和getter两种方法

*/

struct myRect {

var origin:(x:Double,y:Double)=(0,0)//坐标

var size:(w:Double,h:Double)=(10,10)

var center:(x:Double,y:Double)//中心点

{

//getter方法 当只有getter方法为只读 可以简写为一句return (origin.x+size.w/2,origin.y+size.h/2)

get{

return (origin.x+size.w/2,origin.y+size.h/2)

}

//setter方法

set(n){

//当sette没有传递参数时用newValue来代替n

origin.x=n.x-size.w/2

origin.y=n.y-size.h/2

}

}

}

var rect4 = myRect()

rect4.size=(100,100)

rect4.origin=(10,10)

//rect4.center=(rect4.origin.x+rect4.size.w/2,rect4.origin.y+rect4.size.h/2)

println(rect4.center)

//属性观察器

//用于观察属性变化,是指属性的值被修改时可以调用我们事先写好的一些代码段 类似oc中的kvo

//swift存在两种属性观察器

//1.willset 在设置新值的时候被调用的

//2.didset 在新值设置之后被调用

//不可以给延迟属性添加观察器 其他的都可以

class rr {

var a:String="nihao"{

willSet{

println("willSet,改变之前的值:\(a)")

println(newValue)

}

didSet{

println("didSet,改变之后的值:\(a)")

println(oldValue)

}

}

}

//改变值 先创建类的对象

var ass=rr()

ass.a="hehe"

//总结 结构体为值传递 类为引用