常量和變量

在Swift中規定:在定義一個標識符時必須明確說明該標識符是一個常量還是變量
使用let來定義常量,定義之後不可以修改
使用var來定義變量,定義之後可以修改

//定義標示符表明是變量還是常量!
//let  常量
let age : Int = 24
//var  變量
var name = "qiuxuewei"
var PI:Double = 3.1415

注意事項:
常量:是指向的對象不可以再進行修改.但是可以通過指針獲得對象後,修改對象內部的屬性
在真實使用過程中,建議先定義常量,如果需要修改再修改為變量(更加安全)

//定義常量View 和 btn 可以利用指針指向的不可修改的對象,對對象內屬性進行更改,推薦使用let定義常量
let view = UIView(frame: CGRect(x: 16, y: 64, width: 100, height: 100))
view.backgroundColor = UIColor.red

let btn = UIButton(type: UIButtonType.custom)
btn.frame = CGRect(x: 8, y: 8, width: 64, height: 64)
btn.setTitle("確定", for: UIControlState.normal)
btn.backgroundColor = UIColor.green
view.addSubview(btn)

Swift中數據類型

Swift中的數據類型也有:整型/浮點型/對象類型/結構體類型等等
整型

有符號

常用:Int : 和平台相關(默認,相當於OC的NSInteger)
Int8 : 有符號8位整型
Int16 : 有符號16位整型
Int32 : 有符號32位整型
Int64 : 有符號64位整型

無符號

UInt : 和平台相關(常用,相當於OC的NSUInteger)(默認)
UInt8 : 無符號8位整型
UInt16 : 無符號16位整型
UInt32 : 無符號32位整型
UInt64 : 無符號64位整型

浮點型

Float : 32位浮點型
Double : 64浮點型(默認)

// 定義一個Int類型的變量m,並且賦值為10
var m : Int = 10
// 定義一個Double類型的常量n,並且賦值為3.14
let n : Double = 3.14

Swift是強類型的語言
Swift中任何一個標識符都有明確的類型
即如果將一變量定義為整型,就不可對他進行浮點型的賦值

// 定義變量時沒有指定明確的類型,但是因為賦值給i一個20.20為整型.因此i為整型
var i = 20
// 錯誤寫法:如果之後賦值給i一個浮點型數值,則會報錯
// i = 30.5

// 正確寫法
var j = 3.33
j = 6.66

Swift中在進行基本運算時必須保證類型一致

//對不同類型的變量/常量進行運算需要將其轉化為相同類型的
let a = 20
let b = 13.14
let c = Double(a) + b
print(c)

邏輯分支

分支即if/switch/三目運算符等判斷語句,通過分支語句可以控制程序的執行流程

if語句

在Swift的判斷句中必須有明確的真假
不再有非0即真
必須有明確的Bool值
Bool有兩個取值:false/true

//判斷句必須有真假值
var d:Int = 2;
if d != 0 {

}else{

}

var score = 99
if score < 60 {
    print("不及格")
}else if score < 80{
    print("及格")
}else if score < 100{
    print("優秀")
}else{
    print("畢業")
}

//可選類型,因為只有聲明成可選類型後,才可以判斷是否為空
let ifView :UIView? = UIView();

if ifView != nil{
    print("有")
}else{
    print("沒有")
}

三目運算符

跟OC格式保持一致

//三目運算符
a == score ? a : score

guard

guard是Swift2.0新增的語法
它與if語句非常類似，它設計的目的是提高程序的可讀性
guard語句必須帶有else語句，它的語法如下：
當條件表達式為true時候跳過else語句中的內容，執行語句組內容
條件表達式為false時候執行else語句中的內容，跳轉語句一般是return、break、continue和throw

guard 條件表達式 else {
    // 條換語句
    break
}
語句組

//guard
var Age = 18
func online(age:Int) -> Void{
    guard age >= 18 else {
        print("回家去")
        return
    }
    print("可以上網")
}
online(age: Age)

switch

//switch 用法
//sex:0 -> 男  sex:1 -> 女
let sex = 0
//普通用法 - case後可以不跟break(默認會有break)
switch sex{
case 0:
    print("男")
case 1:
    print("女")
default:
    print("未知")
}

//可判斷多個值
switch sex{
case 0,1:
    print("正常人")
    //如果case穿透需要加此關鍵字
//    fallthrough
default: break
//    print("不正常")
}

//如果希望出現之前的case穿透,則可以使用關鍵字fallthrough
let Sex = 0

switch Sex {
case 0:
    fallthrough
case 1:
    print("正常人")
default:
    print("其他")
}

//浮點型的switch判斷
let f = 3.14
switch f {
case 3.14:
    print("π")
default:
    print("not π")
}

//可判斷字符串
let sexStr = "人妖"
switch sexStr {
case "男":
    print("男")
case "女":
    print("女")
default:
    print("人妖")
}

//區間判斷
//swift中的區間常見有兩種
//開區間:0..<10 表示:0~9,不包括10
//閉區間:0...10 表示:0~10
score = 59
switch score{
case 0..<60:
    print("不及格")
case 60..<80:
    print("及格")
case 80...100:
    print("優秀")
default: break
}

循環

for循環

在swift3以後摒棄了C語言常用的 var i = 0; i < 6; i++ 格式

//for 循環
//0-4循環
for i in 0 ..< 5  {
    print(i)
}
//0-5循環
for i in 0 ... 5  {
    print(i)
}
//2次循環不需要變量
for _ in 0 ..< 3{
    print("Hello world!")
}

while循環

while的判斷句必須有正確的真假,沒有非0即真

var aa = 0
while aa < 10 {
    //在swift3以後摒棄了 a++ 操作 改為 a+=1
    aa += 1
}
print(aa)

repeat while循環

swift中將 do-while 改為 repeat-while

var bb = 0
repeat {
    print(bb)
    bb += 1
} while bb < 10

字符串

OC和Swift中字符串的區別
在OC中字符串類型時NSString,在Swift中字符串類型是String
OC中字符串@”“,Swift中字符串””
使用 String 的原因
String 是一個結構體，性能更高
NSString 是一個 OC 對象，性能略差
String 支持直接遍歷
Swift 提供了 String 和 NSString 之間的無縫轉換

//字符串
let str = "I am qiuxuewei"

//遍歷字符串
for cc in str.characters{
    print(cc)
}

//字符串截取 將String轉化為NSSring 操作 (xxx as NSString)
let MyName = (str as NSString).substring(from: 5)


//字符串與其他類型數據拼接
let tempHeight : Double = 1.83
let tempHeight1 = "身高 \(tempHeight) cm"
let tempHeight2 = "身高" + "\(tempHeight)" + "cm"

//字符串格式化 - 用於保留n位小數或格式化時間格式
let min : Int = 9;
let doc : Int = 8;

//let time : String = String(format: <#T##String#>, arguments: <#T##[CVarArg]#>)
let time: String = String(format: "%02d分 : %02d秒", arguments: [min, doc])

數組

數組（Array）是一串有序的由相同類型元素構成的集合
數組中的集合元素是有序的，可以重復出現
Swift中的數組
swift字典類型是Array，是一個泛型集合

數組分成:可變數組和不可變數組
使用let修飾的數組是不可變數組
使用var修飾的數組是可變數組

//數組
//b不可變數組
let arr1 : [String] = ["邱學偉","王珂惠","媽媽"]
let arr2 = ["邱學偉","王珂惠"]
let arr3 = ["邱學偉","煙台大學","不羁閣","瘋火科技"]

//可變數組
var arrM1 = arr3;
var arrM2 : [Any] = ["身高",1.83 ]


//添加元素
arrM1.append("10000000")

//刪除元素
//刪除最後一個元素並且會把最後一個元素返回
arrM1.removeLast()
//移除指定下標元素
arrM1.remove(at: 0)


/遍歷數組
//通過下標遍歷
for i in 0..

字典

字典允許按照某個鍵來訪問元素 字典是由兩部分集合構成的，一個是鍵（key）集合，一個是值（value）集合 鍵集合是不能有重復元素的，而值集合是可以重復的，鍵和值是成對出現的 Swift中的字典 Swift字典類型是Dictionary，也是一個泛型集合

Swift中的可變和不可變字典 使用let修飾的數組是不可變數組 使用var修飾的數組是可變數組

//字典
//不可變字典
let dict1 : Dictionary = ["name":"邱學偉" as AnyObject,"age":24 as AnyObject]
let dict2 : [String : AnyObject] = ["name" : "邱學偉" as AnyObject, "height" : 1.83 as AnyObject]
let dict3 : [String : Any] = ["name" : "邱學偉", "age" : 24]

//可變字典
var dictM1 : Dictionary
var dictM2 : [String : Any]
var dictM3 = ["name" : "邱學偉", "age" : 24] as [String : Any]

//操作字典
//增
dictM3["height"] = 1.83

//刪
dictM3.removeValue(forKey: "age")

//改
dictM3["老婆"] = "王珂惠"

//遍歷字典
//key
for key in dictM3.keys{
//    print(key)
}

//value
for value in dictM3.values {
//    print(value)
}

//key和value
for (key,value) in dictM3 {
    print(key , value)
}

//字典合並
var dictM4 = ["學歷" : "本科","電話" : "110"] as [String : Any]
for (key,value) in dictM3 {
    dictM4[key] = value
}

元祖

swift新增數據類型 類似於數組或者字典 可以用於定義一組數據

//定義元組 常用作函數的返回值
let tuple2 = (crazyfire1 : "ZAR",crazyfire2 : "擴散",person : 6) //常用的定義方法 
let tuple1 = ("ZAR","擴散","Wish",6);
let (crazyfire1,crazyfire2,person1,personNumber) = ("ZAR","擴散","Wish",6)

//用法
tuple2.crazyfire1

let error = (errorCode : 404, errorInfo : "Not Found")
print(error.errorCode)
print(error.errorInfo)

可選類型

在OC開發中,如果一個變量暫停不使用,可以賦值為0(基本屬性類型)或者賦值為空(對象類型) 在swift開發中,nil也是一個特殊的類型.因為和真實的類型不匹配是不能賦值的(swift是強語言) 但是開發中賦值nil,在所難免.因此推出了可選類型

可選取值: 有值/空值

//可選類型
//錯誤寫法!//var optionalNameError : String = nil
//正確定義寫法
//定義方法1:
var optionalNameRight : String? = nil
//定義方法2:
var optionalName : Optional
class person{
    var optionalName : Optional
}

//可選類型拆包
optionalName = "xiaoming"

//一般在拆包時需要對可選類型進行判斷,是否為空
//此種寫法容易產出崩潰點
let xxxName = "呵呵哒的" + optionalName!

//定義
var phoneNum : String?


phoneNum = "+86 110"

//swift中如果進行強制解包操作會崩潰,所以在解包的時候需要進行判斷
if phoneNum != nil{
    var changePhoneNum = "new" + phoneNum!
}

//可選綁定,判斷phoneNum是否有值,1如果沒有值直接跳過,2如果有值拆包後將值賦值給tempPhoneNum
if let tempPhoneNum = phoneNum {
    print("解包後有值")
}

//可選類型應用場景
let URLString = "www.qiuxuewei.com"
let URL : NSURL? = NSURL(string: URLString)

//創建NSRequest對象
//需要先判斷可選類型數據是否有值
if URL != nil{
    let request = NSURLRequest(url: URL! as URL)
}

if let tempURL = URL {
    let request = NSURLRequest(url: tempURL as URL)
}

函數

即為OC中的方法 定義格式:

func 函數名(參數列表) -> 返回值類型 {
    代碼塊
    return 返回值
}

函數的四種類型:

//函數
//1.沒有參數,沒有返回值
func run() -> Void{
    print("跑跑跑...")
}
run()

//其中如果函數木有返回值, " -> Void "可以省略!
func run2() {
    print("省略後,跑跑跑...")
}
run2()


//2.有參數,沒有返回值
func callPhone(PHONE : String) -> Void{
    print("打電話給 \(PHONE)")
}
callPhone(PHONE: "110")

func callPhone2(PHONE : String){
    print("打電話給 \(PHONE)")
}
callPhone2(PHONE: "119")

//3.沒有參數,有返回值
func readMsg() -> String{
    return "今天早起學習了麼?"
}
print(readMsg())

//4.有參數,有返回值
func add(number1 : Double, number2 : Double) -> Double{
    return number1 + number2
}
print(add(number1: 100, number2: 9.99))

默認參數 某些情況,如果沒有傳入具體的參數,可以使用默認參數

//默認參數
func makeSport(type : String = "籃球") -> Void{
    print("打\(type)")
}
makeSport()
makeSport(type:"排球")

可變參數 swift中函數的參數個數可以變化，它可以接受不確定數量的輸入類型參數 它們必須具有相同的類型 我們可以通過在參數類型名後面加入（…）的方式來指示這是可變參數

//可變參數
func sum(numbers : Double...) -> Double{
    var total : Double = 0.00
    for number in numbers {
        total += number
    }
    return total
}
print(sum(numbers: 1,2,3))

引用類型(指針的傳遞) 默認情況下,函數的參數是值傳遞.如果想改變外面的變量,則需要在函數內部將傳遞值設置為變量 因為需要在內部改變其值

//交換兩個值
//值傳遞
func swap1( a:Double, b:Double){
    var b = b
    var a = a

    let temp = a
    a = b
    b = temp

    print("交換後: a\(a) ,b\(b)")
}
swap1(a: 1, b: 9)

類

//類
class Person : NSObject{

    //存儲屬性
    //1>如果類型是結構體或類,定義為可選類型
    //2>如果是基本數據類型,定義時直接初始化0 / 0.0
    var name : NSString?
    var age = 0
    var height = 0.00

}

class student : Person {

    //存儲屬性
    var chineseScore = 0.0
    var mathScore = 0.0

    //計算屬性,由其他屬性值計算而來
    var totalScore : Double{
        //可省略get
//        get{
            return chineseScore + mathScore
//        }
    }

    var avgScore : Double{
        return ( chineseScore + mathScore ) * 0.5
    }

    //類屬性,設置或者獲取屬性值必須通過類名進行獲取
    static var scoreCount : Int = 2;
}

let stu = student();
stu.name = "邱學偉"
stu.age = 18
stu.chineseScore = 119
stu.mathScore = 120
stu.totalScore
stu.avgScore
student.scoreCount

自定義構造函數

class Animal : NSObject{
    var type : String?
    var name : String?

    //自定義構造函數
    init(type : String, name : String) {
        self.type = type;
        self.name = name;
    }
}

let cat = Animal(type: "貓", name: "咪咪")
cat.type
cat.name

字典轉模型式自定義構造函數

//字典轉模型 構造方法
class Dog : NSObject{
    var master : String = ""
    var age : Int = 0

    init(dict : [String : Any]) {
        self.master = dict["master"] as! String
        self.age = dict["age"] as! Int
    }
}
let 哈士奇 = Dog(dict: ["master" : "邱學偉", "age" : 10])
哈士奇.master
哈士奇.age

swift支持類的繼承,此寫法是繼承自其他類本類的構造方法

//字典轉模型 構造方法
class Dog : Animal{
    var master : String = ""
    var age : Int = 0

    init(dict : [String : Any]) {
        super.init(type: "貓科", name: "二哈")
        self.master = dict["master"] as! String
        self.age = dict["age"] as! Int
    }
}
let 哈士奇 = Dog(dict: ["master" : "邱學偉", "age" : 10])
哈士奇.type
哈士奇.name
哈士奇.master
哈士奇.age

類的運算符重載

在Java中熟悉的語法,大多數人都不會陌生 注意在自定義的類中不可以繼承自NSObject, NSObject是用OC封裝的,有大量OC語法特性.

class Person: AnyObject {
    //運算符重載:
    func sum(num1 : Int,num2 : Int) -> Int {
        return num1 + num2
    }
    //參數類型不同
    func sum(num1 : Double,num2 : Double) -> Double {
        return num1 + num2
    }
    //參數個數不同
    func sum(num1 : Int,num2 : Int,num3 : Int) -> Int {
        return num1 + num2 + num3
    }
}