Swift学习：属性

struct Square{
    //存储属性
    var width:Double
    
    //计算属性：通过一定计算方法得到的属性
    var area:Double{
        get{
            return width * width
        }
    }
}
let square = Square(width: 10.0)
print("正方形边长：\(square.width)")     //正方形边长：10.0
print("正方形面积：\(square.area)")      //正方形面积：100.0

let square1 = Square(width: 10.0)
//square1.width = 11.0      //报错
var square2 = Square(width:20.0)
square2.width = 21.0      //可以修改

//注：如果Squre是一个类，那么以上两种情况都可以通过

class Number{
    //存储属性
    var startNum: Int!
    var endNum:Int!
    //计算属性
    var length :Int{
        return endNum - startNum + 1
    }
    
    //延迟属性：使用闭包计算出了延迟属性的值，此过程只执行一次
    lazy var sum: Int = {
        print("计算延迟属性。。。。")
        var tempNum = 0;
        for i in self.startNum...self.endNum{
            tempNum += i;
        }
        return tempNum
    }()
    
    //可失败的构造方法
    init?(startNum: Int , endNum:Int){
        if(startNum > endNum){
            return nil
        }
        self.startNum = startNum
        self.endNum = endNum
    }
}

let number = Number(startNum: 1, endNum: 100)
number?.length  //100
number?.sum    //5050
number?.sum    //5050

struct Point {
    var x = 0.0
    var y = 0.0
}
struct Size {
    var width = 0.0
    var height = 0.0
}
class Rectangle{
    //存储型数据
    var originPoint  = Point()
    var size = Size()
    
    //计算型属性
    var center:Point{
        //get方法：获取计算属性值
        get{
            let center_x = originPoint.x + size.width/2
            let center_y = originPoint.y + size.height/2
            return Point(x: center_x, y: center_y)
        }
        
        //如果没有set方法，是只读，
        /*
         set(newCenter){
            originPoint.x = newCenter.x - size.width/2
            originPoint.y = newCenter.y - size.height/2
         }
         */
        
        //set方法：设置计算属性新值
        //这里也可以省略括号和newCenter.使用newValue
        set{
            originPoint.x = newValue.x - size.width/2
            originPoint.y = newValue.y - size.height/2
        }
    }
    
    //计算属性：area属性只有get,可以不显式的声明出get；此属性为只读属性
    var area:Double{
        return size.width * size.height
    }
    
    init(origin: Point, size: Size){
        self.originPoint  = origin
        self.size  = size
    }
}
//创建一个长方形
var rect = Rectangle(origin: Point(x: 0, y: 0), size: Size(width: 100, height: 100))
rect.center
rect.area  //10000

class lightBlub {
    //最大电压和当前电压
    static let maxDianYa = 30
    
    //属性监听
    //注意：willSet和didSet括号中的值可以省略，直接使用系统自带的newVlaue和oldValue
    var currentDianYa = 0 {
        //可以使用系统默认的属性newValue和oldValue
        willSet(newCurrentDianya){
            print("当前电压值将要改变:  \(currentDianYa) -> \(newCurrentDianya)")
        }
        
        //当调用此方法时，已经设置了值的时候,
        didSet(oldCurentDianYa){
            if(currentDianYa == lightBlub.maxDianYa){
                print("请注意 ,当前电压达到了最大电压值")
            }else if(self.currentDianYa > lightBlub.maxDianYa){
                print("当前电压过高，不能设置新的电压值")
                currentDianYa = oldCurentDianYa
            }
        }
    }
}
let light = lightBlub()
light.currentDianYa = 10
light.currentDianYa = 30
light.currentDianYa = 40
/*
 打印结果：
 当前电压值将要改变:  0 -> 10
 当前电压值将要改变:  10 -> 30
 请注意 ,当前电压达到了最大电压值
 当前电压值将要改变:  30 -> 40
 当前电压过高，不能设置新的电压值
*/

//测试Int的类型属性
Int.min 
Int.max

class Player {
    var name: String = ""
    //对象属性：本人的得分
    var score: Int = 0
    //类型属性：本游戏的最高得分,使用类名来访问，使用关键字static声明
    static var heighestScore:Int = 0;
    
    //构造方法
    init(name: String){
        self.name = name
    }
    //玩一句游戏得分
    func playGame(){
        let tempNum = Int(arc4random()%100)+1
        self.score += tempNum
        print("\(name) 的游戏得分是：\(score)")
        
        if(self.score > Player.heighestScore){
            Player.heighestScore = self.score
        }
        print("当前本游戏的最高分是:\(Player.heighestScore)")
    }
}
let player1 = Player(name: "zs")
player1.playGame()
player1.playGame()
let player2 = Player(name: "cf")
player2.playGame()
/*
 打印结果
 zs 的游戏得分是：11
 当前本游戏的最高分是:11
 zs 的游戏得分是：87
 当前本游戏的最高分是:87
 
 cf 的游戏得分是：88
 当前本游戏的最高分是:88
*/