swift基础二

 import Foundation

 // MARK: - ?和！的区别
 // ?代表可选类型，实质上是枚举类型，里面有None和Some两种类型，其实nil相当于OPtional.None，如果非nil相当于OPtional.Some
 // !强制解包
 //var number : Int?  // 此时解包会崩溃
 var number : Int? =   // 此时解包不会崩溃

 // 如果对没值（nil）的变量进行强制解包的情况下会造成崩溃
 var number1 = number!
 print(number1)

 // 可选绑定，不用强制解包
 if var number2 = number {
     print(number2)
 }

 // !隐式解析可选类型：有值，没值（nil）
 // 如果！强行解析没值的变量，也会造成崩溃
 //var intNumber : Int!   // 此时解包会崩溃
 var intNumber : Int! =    // 此时解包不会崩溃
 var intNumber1 = intNumber
 print(intNumber1)

 // 可选绑定
 if var intNumber2 = intNumber {
     print(intNumber2)
 }

 // MARK: - 结构体
 // 1.声明一个结构体
 struct Rect {
     // 声明结构体变量的属性(存储属性)
     var x : Float
     var y : Float
     var width : Float
     var height : Float

     // 声明结构体属性， 要使用static
     static var description : String?

     // 声明一个计算属性（是用来专门计算结构体变量属性的setter和getter方法的，本身并没有存储功能）
     var centerX : Float {
         // set方法
         set {
             x = newValue
         }
         // get方法（必须要写）
         get {
            return x /
         }
     }

     var centerY : Float {
         // 可以不写set方法，只写get方法
         get {
             return y /
         }
     }

     // 声明方法
     // 声明一个结构体变量方法(相当于OC中的实例方法)
     func frameInfor() {
         print("x : \(x), y : \(y), width : \(width), height : \(height)")
     }

     // 声明一个结构体方法(相当于OC中的类方法)，使用static修饰
     static func inFor() {
         print("这是结构体方法")
     }
 }

 // 2.根据结构体去定义一个结构体变量
 var frame = Rect(x: , y: , width: , height: )

 // 3.访问结构体变量中的属性
 // 注意：结构体变量的属性类型可以使用let去修饰，只不过访问的时候不能进行修改
 frame.x =
 print(frame.x)

 // 4.访问结构体属性
 Rect.description = "我是结构体属性"
 print(Rect.description)

 // 5.访问计算属性
 frame.centerX =    // 这句话相当于在调用centerX的set方法
 let value = frame.centerX   // 这句话就相当于在调用centerX的get方法
 print(value)

 // 6.调用结构体变量方法
 frame.frameInfor()

 // 7.调用结构体方法
 Rect.inFor()

 // MARK: - 类（class）
 class Person {
     var name : String?
     var age : Int?

     // 构造初始化方法
     init (name : String, age : Int) {
         self.name = name
         self.age = age
     }

     // 自定义初始化方式（可以只初始化一部分属性）
     init (name : String) {
         self.name = name
     }

     // 声明类属性
     static var introduce : String?

     // 计算属性
     var value : Int {
         set(a) {
             age = a  // 在写计算属性的时候，一定不能出现self.,否则会造成死循环
         }
         get {
             return age!
         }
     }

     // 声明一个类方法
     // 1.在类方法前边加上static修饰【虽然是一个类方法，但是该方法在子类中不能进行重写】
     static func sayHi() {
         print(introduce)  // 注意：在类方法中只能使用类属性，不能使用对象属性
     }
     // 2.在类方法前边加上class修饰【它是一个类方法，可以被子类重写】
     class func sayHi1() {
         print(introduce)
     }

     // 声明一个实例（对象）方法
     func sayHi2() {
         print("hello, 我是实例方法")
     }
 }

 // 1.创建对象(此时应该和OC区分开来，实例对象，：后边跟的是类，要初始化对象一定要写初始化构造的方法)
 var person1 : Person = Person(name : "卫庄", age : )

 // 2.访问类中的属性(对象属性)
 print(person1.name!)

 // 3.访问类属性
 Person.introduce = "我是盖聂"
 print(Person.introduce)

 // 4.访问计算属性
 person1.value =
 print(person1.value)

 // 5.访问类方法
 Person.sayHi()
 Person.sayHi1()

 // 6.访问实例方法
 person1.sayHi2()

 // MARK: - 定义一个子类Student，继承Person
 // 在swift中不支持多继承
 class Student : Person {
     // 重写父类的方法
     // 重写父类中的类方法（class修饰的可以重写，static修饰的不可以重写）
     override class func sayHi1() {
         print("我是子类Student类，重写了父类的类方法")
     }

     // 重写父类中的实例方法
     override func sayHi2() {
         print("我是子类Student类，重写了父类的对象方法")
     }
 }

 // 初始化student对象
 var student : Student = Student(name: "天明", age: )

 // 调用类方法
 Student.sayHi1()

 // 调用使用方法
 student.sayHi2()

 // MARK: - 值类型和引用值类型的区别
 /*
 // 值类型
 struct animal {
     var name : String?
     var age : Int?

     init(name : String, age : Int) {
         self.name = name
         self.age = age
     }
 }
 var dog = animal(name: "贝贝", age: 3)
 var dog1 = dog   // 此时将dog的数据拷贝给dog1
 dog.name = "欢欢"
 print("dog.name : \(dog.name!), dog1.name : \(dog1.name!)")
 */

 // 引用值类型
 class animal {
     var name : String?
     var age : Int?

     init(name : String, age : Int) {
         self.name = name
         self.age = age
     }
 }
 var dog = animal(name: "贝贝", age: )
 var dog1 = dog
 dog.name = "欢欢"
 print("dog.name : \(dog.name!), dog1.name : \(dog1.name!)")

 // MARK: - 协议（protocol）
 // 当swift中声明协议的时候，协议里有可选方法需要使用@objc关键字修饰
 @objc protocol MarrayDelegate {
     func cook()   // 做饭
     func wash()   // 洗衣服
     optional func hitDoudou()  // 打豆豆
 }

 protocol DivorceDelegate {
     func diviseMoney()  // 分割财产
 }

 // 如果一个类要遵循协议的时候，如果这个类有父类要在：后先写父类，然后用,隔开，后面跟着协议
 class Man: Person, MarrayDelegate, DivorceDelegate {
     @objc func cook() {
         print("我要做饭了")
     }

     @objc func wash() {
         print("我要洗衣服了")
     }

     func diviseMoney() {
         print("分财产")
     }
 }

 // 创建一个男人
 let man = Man(name: "韦小宝", age: )
 man.cook()
 man.wash()
 man.diviseMoney()

 // MARK: - 扩展(Extension)
 // 1.扩展协议中的相关方法
 extension Man {
     @objc func hitDoudou() {
         print("嘿嘿嘿")
     }
 }
 man.hitDoudou()

 // 2.扩展还可以扩展类方法（类似于OC中的Category）以及对象方法
 extension Man {
     // 扩展一个对象方法
     func sing() {
         print("唱一首歌")
     }

     // 扩展一个类方法
     class func sleep() {
         print("多喝水")
     }
 }

 man.sing()
 Man.sleep()

 // MARK: - 闭包
 // 求两个数的最大值
 /*
 在OC中使用Block实现
 int (^myBlock)(int num1, int num2) = ^int (int num1, int num2) {
     return num1 > num2 ? num1 : num2
 }
 */

 // 使用闭包
 var myBlock : ((num1 : Int, num2 : Int) ->Int)

 // 第一种使用方式
 myBlock = {
     (num1 : Int, num2 : Int) ->Int in   // 切记不能忘记in
     return num1 > num2 ? num1 : num2
 }

 // 第二种方式
 myBlock = {
     num1, num2 in
     return num1 > num2 ? num1 : num2
 }

 // 第三种方式
 myBlock = {
     num1, num2 in
     num1 > num2 ? num1 : num2
 }

 // 第四种方式
 myBlock = {
     $ > $ ? $ : $
 }

 // 第五种方式
 myBlock = {
     (num1, num2) ->Int in
     return num1 > num2 ? num1 : num2
 }

 var max = myBlock(num1: , num2: )
 print(max)