Swift基本语法及与OC比较之二

 //MARK:-----------------控制流-----------------
 //MARK: 1.for - in 循环 ,不用声明Value类型

 //for value in 1...6 {
 //print(value)
 //
 //}

 //不需要具体的值，只是为了得到循环次数

 //for _ in 1...6 {
 //print("123")
 //}

 //MARK: 2.for循环，和C一样，只是没有 括号

 //for var i = 0 ; i < 26 ; i++ {
 //print("i = \(i)")
 //}

 //MARK: 3.while 循环,和C一致

 //var whileValue = 0
 //while whileValue < 10 {
 //    whileValue++
 //
 //    print("while ++ -- \(whileValue)")
 //}

 //MARK: 4. do-while 循环

 //var number = 0

 //repeat {
 //print("number -- \(number)")
 //number++
 //}while false

 //repeat {
 //    print("number -- \(number)")
 //    number++
 //}while number < 10

 //MARK: 5. if-else 语句，分支语句
 //var applePrice = 8.5 // double
 //
 //if applePrice < 5 {
 //
 //    print("applePrice -- \(applePrice)")
 //}else{
 //    print("applePrice -- \(applePrice)")
 //}

 //MARK: if-else语句 的值绑定 可以保护程序

 //var optionValue :Int?
 //var optionValue :Int? = 5
 //if var tempOptionValue = optionValue {
 //    //如果可选类型有值，就走条件成立的语句
 //print("value = \(tempOptionValue)")
 //}else{
 //    //如果没有值，就走条件不成立的语句
 //    print("可选类型为nil")
 //}

 //MARK: 6.witch - case
 //（1）Swift中没有自动贯穿，即使把break删掉，也不会贯穿达下个case语句
 //（2）有需要贯穿需求的时候，需要加贯穿语句  fallthrough
 //（3）如果case中，没有任何语句，就必须加break ，没有语句就不必加break
 //（4）如果不写default，case语句必须包含所有情况。否则必须写。
 //var switchValue = 11
 //switch switchValue {
 //case 10:
 //    print("10")
 ////    break
 //case 11:
 //    print("11")
 ////    break
 //
 //    fallthrough
 //case 12:
 //    print("12")
 ////    break
 //default:
 //    print("other")
 //
 //}

 //MARK: switch -case 的值绑定
 //当case条件满足时，进入case语句，把值赋给我们设的局部变量（常量）
 //var (x,y) = (0,10)
 //switch (x,y){
 //case (let localX,0):
 //    print("localX = \(localX)")
 //case (0,let localY):
 //    print("localY = \(localY)")
 //default:
 //    print("other")
 //}

 //MARK: switch-case的区间匹配

 //var money : Float = 10.5
 //switch money {
 //case 0...10:
 //    print("穷屌丝")
 //case 10...100 :
 //    print("普通人")
 //default:
 //    print("高富帅")
 //}

 /* 词语辨析
 fallthrough ：贯穿
 continue :结束本次循环，进入下次循环
 break：跳出循环
 */

 //MARK: 7.标签语
 //sign:  主要用于循环嵌套：可以给循环加标签，这样可以给指定循环做一些操作.作用：更易于操作循环
 //sign:while true {
 //
 //    for var i = 0 ; i < 10 ; i++ {
 ////      指定break是那个控制流
 //        if i == 5 {
 //        break sign
 //        }
 //    print("i -- \(i)")
 //    }
 //}

 //MARK: ----------------函数---------------------
 //MARK: ----函数调用 --

 /*
 func 函数名(参数列表) ->返回值 {
 //实现动作部分
 }

 */

 //func 函数名()->返回值
 //MARK: 1.无参无返回值 , 没有返回值可以不写 ->\

 //func printFunc(){
 //
 //}

 //func printFunc()->Void {
 //    print("123")
 //}

 ////diaoyong hanshu
 //printFunc()

 //MARK: 2.有参无返回值
 //func printCity(cityName:String){
 //print("城市--\(cityName)")
 //}
 //
 ////调用函数
 //printCity("郑州")

 //MARK: 3.无参有返回值
 //func returnString()->String{
 //return "北京"
 //}
 //
 //let string = returnString()
 //
 //print(string)
 //
 //print(returnString())

 //MARK: 4.有参有返回值 :可以支持多个返回值

 func matchFun(number1:Int,number2:Int)->(Int,Int){

     // number1++
     return (number1 + number2,number2 * number1)
 }

 //print(matchFun(2, number2: 3))

 /*注意事项：
 1.函数的形参是let类型（常量），而不是变量（变量）；用var修饰形参可改变
 2.交换两个数

 */

 //1.
 func changeCity(var loveCityName:String){

     loveCityName = "北京"
     //    print(loveCityName)
 }

 changeCity("上海")

 //2.交换两个数
 //函数中任意改变形参，实参不会变
 //MARK: 注意：要改变实参，需要传进入地址（&）,需要inout关键字---
 func changeTwoNumber(inout number1 :Int,inout number2 :Int)->(Int,Int){//（1）

     //func changeTwoNumber(var number1 :Int,var number2 :Int)->(Int,Int){//（2）

     let tempNumber = number1;
     number1 = number2;

     number2 = tempNumber;

     return (number1,number2)
 }

 var a = ,b = 

 let (x,y) = changeTwoNumber(&a, number2: &b)//（1）
 //let (x,y) = changeTwoNumber(a, number2: b)//（2）

 //print((x,y))
 //print("a- \(a),b - \(b)")

 //MARK: 给函数添加一个外部形参名，作用：在函数调用时，可以看到

 //func travelCity( cityName1:String,CityName:String, cityName3:String){//(1)

 func travelCity(firstCity cityName1:String,sencondCity CityName:String,thirdCity cityName3:String){//(2)

     //print("我的旅行路线\(cityName1)-->\(CityName)-->\(cityName3)")
 }

 //调用

 //travelCity("北京", CityName:"马尔代夫", cityName3: "巴黎")//(1)
 travelCity(firstCity: "北京", sencondCity: "马尔代夫", thirdCity: "巴黎")//(2)

 // 简化的外部参数名：( 只需要在第一个参数名前加外部参数)
 func travelCity1(cityName1 cityName1:String, CityName:String, cityName3:String){//(2)

     //    print("我的旅行路线\(cityName1)-->\(CityName)-->\(cityName3)")
 }

 //调用
 //travelCity1(cityName1: <#T##String#>, CityName: <#T##String#>, cityName3: <#T##String#>)

 //MARK:-----------------函数类型-----------------
 //MARK:1.函数类型是由，函数的参数和返回值组成

 func addFunc(number1 number1:Int,number2:Int) -> Int{
     return number1 + number2
 }//这个函数的类型就是  （Int,Int） ->Int

 //MARK:2.定义函数类型的变量：类似typeDef
 //var tongVar :String = "string"

 var tongVar :(Int,Int)->Int = addFunc

 //print(tongVar(3,4))

 //MARK:3.将函数作为参数
 //把addFunc2作为另一个函数的参数
 func addFunc2(number1 number1:Int,number2:Int) -> Int{
     return number1 + number2
 }

 //参数1- 参数名：match 参数类型：(Int,Int)->Int
 //参数2- 参数名：number1 参数类型：Int
 //参数3- 参数名：number2 参数类型：Int

 //func ParaFunc(match match:(Int,Int)->Int,number1:Int,number2:Int){
 // let resultNumber1 =  match(number1,number2);
 //    print(resultNumber1)
 //}//(1)

 func ParaFunc(addFunc2 addFunc2:(Int,Int)->Int,number1:Int,number2:Int){

     //    print(addFunc2(number1,number2))
 }//(2)

 //调用

 //ParaFunc(match: addFunc2, number1: 2, number2: 4)//(1)

 ParaFunc(addFunc2: addFunc2, number1: , number2: )//(2)

 //MARK:4函数作为返回值，返回值是一个函数类型

 func mutiFun2(number1 number1:Int,number2:Int)->Int{
     return number1 * number2
 }

 //定义一个函数，返回值类型是（Int，Int）->Int
 //参数名：add  类型：Bool 返回值类型：(Int,Int)->Int
 func selectFunc(isSelectAddFun add:Bool)-> ((Int,Int)->Int){

     return add ? addFunc2 :mutiFun2;
 }

 let result = selectFunc(isSelectAddFun: false)//result 就是函数类型，即(Int,Int)->Int

 //print(result(1,2))
 //
 //print(selectFunc(isSelectAddFun: true)(1,2))

 //MARK：函数的嵌套
 //func emedFun(judge judge:Bool,number:Int){
 //    //自增函数
 //    func addNumber(var number1:Int){
 //        print(++number1)
 //    }
 //    //自减函数
 //    func jianNumber(var number2:Int){
 //        print(--number2)
 //    }
 //    //    利用bool值去判断，调用自增还是自减
 //    let funcName = judge ? addNumber :jianNumber
 //    //    利用参数number去调用自增或者自减
 //    funcName(number)
 //}

 //调用

 //emedFun(judge: false, number: 1)//在函数外层调用，对应只能调用函数外层

 //MARK: 重点------闭包------
 //类似OC中的block
 //定义一个闭包
 var block = { (str:String)-> Void in
     //    block块
     //    print(str)

 }

 //调用闭包
 block("我爱北京*")

 //MARK:-----------------枚举-----------------
 /*
 //1.枚举名首字母大写，枚举值首字母也大写
 //2.swift的枚举和C的区别
 2.1有case关键字
 2.2枚举值有哈希值
 */

 /*
 enum City{
 case beijing
 case Paris
 case NewYork
 }
 print(City.NewYork.hashValue)

 //3.原始值和rawValue

 enum PoneType :String{
 case Apple = "IPhone"
 case MI = "Mi4"
 //    case HUAWEI = "荣耀"
 case HUAWEI
 }

 print(PoneType.HUAWEI.rawValue)//如果有rawValue就会打印，否则打印case后枚举值

 //通过rawValue找到对应的枚举值
 var ii = PoneType(rawValue: "荣耀")

 /*
 //print(ii!.rawValue)//强制解析
 print(ii?.rawValue)//可选解析
 print(ii)//默认为可选解析
 */

 */

 //MARK:相关值
 //利用枚举的相关值结合switch-case进行值的绑定

 enum Girl{
     case Id(Int)
     case Info(String,Int,Double)//姓名，年龄，身高
 }

 //进行值的绑定
 /*
 var girl = Girl.Info("貂蝉", 21, 165)

 switch girl {
 case Girl.Info(var girlName,var age,var height) :
 print("name --\(girlName)")
 case Girl.Id(var girlID):
 print("ID -- \(girlID)")
 }
 */
 //MARK:-----------------类-----------------

 /*和OC区别：

 1.运用class关键字
 2.没有.h .m
 3.在同一个括号内声明属性，书写方法

 */

 //定义一个类,关键字是Class，类名首字母大写
 class Student {
     //类的属性（实例变量）,属性名studentAge，类型Int
     var studentAge :Int
     var studentName:String
     //    给属性添加init方法，目的为给属性一个默认值
     init(studentAge:Int,studentName:String){//一个类只能有一个init方法
         //    给属性赋默认值
         self.studentAge = studentAge
           self.studentName = studentName
     }

     //MARK:注意--类方法 （函数）
     func printStu(){
         print(self.studentAge,self.studentName)
     }

 //    有参数有返回值
     func  change(stuName:String)->String{
     self.studentName = stuName
     return self.studentName
     }
 }

 //调用该类
 //实例化一个类对象
 let studentItem = Student(studentAge: , studentName:"我饿了")
 //属性的设置和访问

 studentItem.studentAge = ;

 //print(studentItem.studentAge)

 //studentItem.printStu()

 //print(studentItem.change("嗯哼"))

 //MARK:   ---结构体---
 //定义一个结构体，关键字struct
 //结构体不需要写init方法，因为它已经为我们写好了
  struct GirlSTR {
 //属性
     var girlName:String
     var girlHeight:Double

 //    方法
     func printFourBeautifulGirls(girlName1:String ,girlName2:String, girlNmae3:String){//注意‘,’不可少
     print("四大美女---\(self.girlName) \(girlName1)  \(girlName2)  \(girlNmae3)")

     }

     func printHeith(){

     print(self.girlHeight)
     }
 }

 //实例化一个结构体

 var girl = GirlSTR(girlName: "小笼包", girlHeight: )

 //访问结构体的属性，设置结构体属性
 //print(girl.girlName)
 girl.girlHeight = 1.60
 //girl.printHeith()
 //girl.printFourBeautifulGirls("1", girlName2: "2", girlNmae3: "3")

 //MARK:类和结构体的区别

 //1.类是引用类型，结构体是值类型
 var studentItem2 = studentItem;
 studentItem.studentAge = 

 print(studentItem.studentAge,studentItem2.studentAge)

 var girl2 = girl
 girl.girlHeight = 1.20
 print(girl.girlHeight,girl2.girlHeight)

 //2.类可以继承，结构体不能继承（最本质）

 //3.结构体对象如果是let类型即使属性是var类型也是不可修改的。类对象即使是let类型，属性如果是var类型也是可以修改的

 //MARK:恒等运算 ===
 //用来对两个类实例（对象）进行判断，到底是否完全一致

 if studentItem2 === studentItem {
 print("两个实例相等")

 }else{
 print("两个实例不相等")
 }