swift基础二

import Foundation

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

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

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

// !隐式解析可选类型：有值，没值（nil）
// 如果！强行解析没值的变量，也会造成崩溃
//var intNumber : Int!   // 此时解包会崩溃
var intNumber : Int! = 6   // 此时解包不会崩溃
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 / 2
        }
    }
    
    var centerY : Float {
        // 可以不写set方法，只写get方法
        get {
            return y / 2
        }
    }
    
    // 声明方法
    // 声明一个结构体变量方法(相当于OC中的实例方法)
    func frameInfor() {
        print("x : (x), y : (y), width : (width), height : (height)")
    }
    
    // 声明一个结构体方法(相当于OC中的类方法)，使用static修饰
    static func inFor() {
        print("这是结构体方法")
    }
}

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

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

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

// 5.访问计算属性
frame.centerX = 200   // 这句话相当于在调用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 : 20)

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

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

// 4.访问计算属性
person1.value = 28
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: 12)

// 调用类方法
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: 3)
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: 22)
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 = {
    $0 > $1 ? $0 : $1
}

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

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