Swift 入门 2

import Foundation

// 定义一个可选类型, 表示这个变量可以为Nil
//var intNumber : Int? = 100
//// 在使用的时候, 在变量后加一个 ! 表示拆包, 可以获得为真正的值
//print(intNumber!)
//
//if var intNewNumber = intNumber{
//print(intNumber!)
//}else{
//print("error")
//}

///%%%%%%%%%%%%%%%%%%%%%%结构体%%%%%%%%%%%%%%%%%%%%%%%%

// 使用struct定义一个结构体
// 格式: struct + 结构体名字 {结构体实现}
struct Frame {
    // 存储属性 负责存储值的属性
    var x : Float
    var y : Float
    var width : Float
    var height : Float

    // 计算属性 负责将存储属性进行运算获得值得属性
    // get方法 :在属性类型后面添加{} 使用get关键字声明和实现get方法
    // set方法 :同上
    // set方法不可以单独出现, 必须搭配get方法.但是get可以
    var centerX : Float{
        get{
        return x + width / 2
        }
    }
    var centerY : Float{
        return y + height / 2
    }
    //结构体属性
    static var myStruct = "我是一个结构体属性"
    //结构体中可以声明和实现一个函数
    func sayHI(){
    print("你好, 我是一颗大树")
    }
    // init方法
    // Swift中结构体中可以声明和实现一个init方法
    init(x newX : Float, y newY : Float, width newWidth : Float, height newHeight : Float){
        x = newX
        y = newY
        width = newWidth
        height = newHeight
    
    }
    // 结构体方法
    // 结构体方法中只能调用结构体属性
    static func sayMy() {
    print(self.myStruct)
    }
   
}
print(Frame.myStruct)

// 创建一个对象的方式
// 第一种
var frame : Frame = Frame.init(x: 10, y: 10, width: 100, height: 100)
// 第二种
var frame1 : Frame = Frame(x: 10, y: 10, width: 100, height: 100)

print(frame1.centerX)

frame1.sayHI()
// 用结构体调用的,不是用对象
Frame.sayMy()


//&&&&&&&&&&&&&&&&&&&&&&&&&&&&  类 &&&&&&&&&&&&&&&&&&&&&&&&&&&&
// calss + 累名 * {类的实现}
class Person{
    // 当在给一个类写属性的时候, 这个属性如果没有初值那就需要是可选类型:var name = String?
    
    var name = "hehehe"
    var gender = "你猜"
    var age = 108
    
    var width : Float{
        get{
        return 100
        }
        set {
        // set方法中newValue表示新值
        self.width = newValue
        }
    }
    // static修饰的是类属性
    static var hobby : String? = "三锰"
    // 普通函数里面不能调用类属性.类属性只能由类函数去调用.
    func sayHI()
    {
    print("你丫的\(self.width)")
    }
    init(name newName : String, gender newGender : String, age newAge : Int){
    name = newName
    gender = newGender
    age = newAge
}
    static func sayMy(){

    print(self.hobby!)
    }
}

var person : Person = Person(name: "老大", gender: "老二", age: 3)

print(person.name)
person.sayHI()
Person.sayMy()



//class Dog {
//    var name : String?
//    var style : String?
//    static var hobby : String? = "嘿嘿嘿"
//    func sayHH(){
//    print("汪汪汪")
//    }
//    init(name newName : String, style newStyle : String){
//    name = newName
//    style = newStyle
//    }
//    static func sayMy(){
//        
//    print(self.hobby!)
//    }
//}
//var dog : Dog = Dog(name: "wangcai", style: "bosimao")
//print(dog.name!, dog.style!)
//dog.sayHH()
//Dog.sayMy()
//
//

//class Student: Person {
//    
//    var number : Int?
//    
//  // 重写父类的方法 : 需要添加override修饰
//    override func sayHI() {
//    //super.sayHI() 加super代表完全调用父类的方法.
//    }
//    
//    // 重写父类的init函数
//    override init(name newName: String, gender newGender: String, age newAge: Int) {
//        super.init(name: newName, gender: newGender, age: newAge)
//      
//        
//    }
//    // 在重新创建一个init方法的时候  还是需要super.init
//    init(number newNumber : Int){
//    super.init(name: "张三", gender: "男", age: 1)
//        number = newNumber
//  
//    }
//   
//}


//^^^^^^^^^^^^^^^^^^^^^^  协议  ^^^^^^^^^^^^^^^^^^^^^^^\// 声明一个协议
// Protocol 声明的协议 是swift的协议 所有的方法都必须实现.
protocol myDelegate{
   // 一个协议方法
   func test()
    // 使用Mutating修饰的函数 可以在结构体里面修改结构体的属性
    // 在协议里面使用mutating修饰的函数. 在遵守协议的时候, 可以不使用mutating修饰 在类里没有影响,但是在结构体里面就不能修改属性的值了.. 没有使用mutating修饰的函数,在实现的时候 却使用了mutating修饰的结果是重新的声明了一个函数, 和协议没有关系.
   mutating func change()
}


// 使用@objc修饰的协议表示这个协议是OC的协议
// 可以声明可选实现的函数 在函数前面用optional修饰, 这个函数就是可选实现函数了
// 在实现这个函数的时候 ,在函数前面要加@objc修饰
// @objc 修饰的协议 ,不可以在结构体里面遵守

@objc protocol newDelegate{
    // 可选实现
optional func newTest()
    func newChange()
}


// 类
class Teacher : Person, myDelegate, newDelegate{
    func test() {
        print("aaa")
    }
    // 协议里使用mutating修饰之后的的函数 在类里面就是一个普通的函数
    func change() {
    }
    @objc func newText(){
    }
    @objc func newChange() {
        
    }
}
let teacher : Teacher = Teacher(name: "a", gender: "男", age: 111)


// 结构体
struct myStruct : myDelegate // @objc 修饰的协议 ,不可以在结构体里面遵守 不用写 newDeleate
{
    var name : String
    func test() {
    // 结构体里的函数不能直接更改结构体里的属性
    }
    mutating func change() {
        name = "111"
    }
}

//$$$$$$$$$$$$$$$$$$$$$  扩展  $$$$$$$$$$$$$$$$$$$$$$$$$$\// extension + 类名 表示你要对这个类做扩展.
// extension 只可以扩展函数 不能扩展属性
// extension 可以给一个类扩展代理协议
extension Person : myDelegate{
    func test() {
        
    }
    func change() {
        
    }
    func eat(){
    }
}

// extension 可以给结构体扩展新的协议
//extension Frame : myDelegate{
//    func text(){
//    }
//    func change(){
//    }
//}


//!#@@#$^%$%&^&*(&&^$%!^&^*&*)%$#$#@  闭包   @%^%*%^#@$!@#Q@!^??@??
// 声明一个 闭包 var myBlock : (闭包色格式)
var myBlock :((a : Int, b : Int) ->Int)
// 实现闭包的第一种方法
myBlock = {
    (a : Int, b : Int) -> Int in
    return a > b ? a : b
}
// 第二种实现闭包方式, 省略参数类型和返回值
myBlock = {
a, b in
    return a > b ? a :b
}

// 第三种方式实现闭包 省略参数类型 省略返回值 省略return关键字

myBlock = {
a, b in
    a > b ? a : b
}

// 第四种方式 都省略了  使用$符号表示 取第几个参数.
myBlock = {
    $0 > $1 ? $0 : $1
}

// 第五种  苹果推荐
myBlock = {
(a, b) -> Int in
    return a > b ? a : b
}