//: Playground - noun: a place where people can play

import UIKit

/*
 类的定义
 class myClass : superClass{
     //定义类的属性和函数
 }
 //注意：
 //1、定义类 可以没有父类， 那么该类是rootClass

 class Person{

 var age = 0

 }

 let p = Person()
 p.age = 27

 class Person2 : NSObject{

 var age = 0

 override func setValue(_ value: Any?,forUndefinedKey key: String) {

 }

 }

 //通过kev给类的属性赋值

 let p2 = Person2()
 p2.setValuesForKeys(["age":18])
 print(p2.age)

 //如果通过KVC给勒种一个没有定义的属性赋值 那么程序默认会报错， 此时需要在父类中重写方法：setValue(_ value: Any?,forUndefinedKey key: String) 就不会报错了
 p2.setValue("kenshin",forKey: "xiwang")

 定义类的属性
 Swift中类的属性有多重
 存储属性：存储实例的常量和变量【最常用】
 计算属性：通过某种方式计算出来的属性
 类属性：与整个类自身相关的属性

 class Student : NSObject{

 //定义属性
 //定义存储属性
 var age = 0
 //var name : String? = nil 可选类型的默认值就是nil 所以下面可以简化写法
 var name:String?

 //定义成绩
 var chinesescore = 0.0
 var mathscore    = 0.0

 //定义一个方法 获取平均成绩[一般不建议通过方法来获取这样的值，可以通过定义一个计算属性来获取]
 func average() -> Double {
 return(chinesescore + mathscore) * 0.5;
 }

 //定义计算属性:通过别的方式 计算出结果的属性，称之为 计算属性
 var averageSocre:Double {
 return(chinesescore + mathscore) * 0.5;
 }

 //定义类属性：类属性是和整个类相关的属性，而且是通过类名进行访问
 static var courseCount = 0//有多少门课程

 }

 //给类属性进行赋值 设置课程数为2
 Student.courseCount = 2

 //创建对象
 let stu = Student()
 //给对象属性进行赋值
 stu.age = 10
 stu.name = "fxw"
 stu.chinesescore = 85.5
 stu.mathscore    = 90;

 print(stu.age)

 //通过可选绑定 校验可选类型是否为nil
 if let name = stu.name{
 print(name)
 print("\(name)的平均成绩是:\(stu.average())")
 print("我们有 \(Student.courseCount)门课程")
 }

 //通过计算属性 获取学生的平均成绩
 stu.averageSocre

 类的构造函数
 1.类的构造函数类似于OC的初始化方法，init方法
 2.默认情况下，创建一个类对象必然会调用构造函数
 3.就算没有编写任何构造函数，编译器也会提供一个默认的构造函数
 4.如果是继承自NSObject 可以对父类的构造函数进行重写

 class Person : NSObject{

 var name : String?
 var age : Int = 0

 //重写父类的构造函数
 override init() {
 // 在构造函数中 如果没有明确调用super.init() 系统也会默认调用 所以可以省略 仅仅是在构造函数中
 // super.init()

 print("老铁 你调用了构造函数")

 }

 //自定义构造函数
 init(name : String,age : Int){
 self.name = name
 self.age = age

 print("大家好 我叫\(name) 今年\(age)岁了")
 }

 //自定义构造函数2 通过字典来初始化对象[比较麻烦 通常利用KVC来实现]
 // init(dic : [String : AnyObject]){
 //
 // let tmpName = dic["name"]
 // // as? 最终转成的类型是一个可选类型
 // // as! 最终转成的类型是一个确定类型
 // name = tmpName as! String
 //
 // let tmpAge = dic["age"]
 // age = tmpAge as! Int
 //
 // }

 init(dic : [String : AnyObject]){
 super.init()//这行很关键 如果不调用的话 下面的对象方法无法调用 下面省略了 self.
 setValuesForKeys(dic)
 }

 }

 let p = Person()

 let p2 = Person(name: "小强",age: 100)
 p2.age

 //可选绑定
 if let name = p2.name{
 print(name)
 }

swift中 闭包的循环引用问题

         解决循环引用的第一种方法：使用 弱引用的self
         通过 weak var weakSelf = self 定义
         weakSelf? 的意思是
         如果前面的可选类型没有值，后面所有的代码都不会执行
         如果前面的可选类型有值，系统会自动将weakSelf进行解包，并且使用weakSelf

         方式一：
         weak var weakSelf = self
         tool.loadInfo { (str) in
         weakSelf?.view.backgroundColor = UIColor.yellow
         print(str)
         }

         方式二:使用前 必须保证当前 self不为空 不然会崩溃
         这里使用的 unowned 它相当于OC里面的 unsafe_unretained

         OC中
         __weak：修饰的弱引用，如果指向的对象销毁，那么指针会立即指向nil(0x0)
         unsafe_unretained：修饰的弱引用，如果指针指向的对象销毁，指针已然指向之前的内存地址->所以一单改指向的对象销毁后
         就会产生“野指针”/“僵尸对象”

         综上：unowned 同 unsafe_unretained
         //这样的写法 self如果为空 那就下面代码会崩溃
         tool.loadInfo {[unowned self] (str) in
         self.view.backgroundColor = UIColor.yellow
         print(str)

         方式三[推荐使用]：其实方式二是方式一的简化写法 意思是一样的
         就是直接[weak self] 并且后面使用的self是一个可选类型 self? 意思和方式一相同

         tool.loadInfo {[weak self] (str) in
         self?.view.backgroundColor = UIColor.yellow
         print(str)
         }

         }

        tool.loadInfo {[weak self] (str) in
            self?.view.backgroundColor = UIColor.yellow
            print(str)
        }