Swift和OC的不同

1.類型推斷,不需要指定變量的類型,swift相比OC最強(qiáng)大的地方在于編譯器,Swift編譯器是全類型編譯器,在編譯的時(shí)候就知道了所有的對(duì)象的類型,這是OC的動(dòng)態(tài)編譯所做不到的,這樣做有一個(gè)好處,就是類型安全
2.Swift當(dāng)中不能向nil發(fā)送消息
3.泛型 允許向Java那樣將數(shù)據(jù)類型參數(shù)化.
4.字符串做了一些增強(qiáng)
5.switch語法做了精簡,提供了范圍限制

引入的時(shí)候沒有雙引號(hào),也沒有尖括號(hào),直接寫框架名
import Foundation
//輸出函數(shù)
//字符串取消前面的@標(biāo)記
//沒有分號(hào),分號(hào)是可選寫入的
print("Hello, World!")

1.變量和常量的聲明

let myGender = "男"http://常量
var carName = "BMW"http://變量
carName = "Audio"```
Swift中允許使用任何Unicode字符作為變量和常量的名字,包括哪些不在ACSII編碼的字符(不過貌似然并卵)

let 李帥 = "呆萌2b"
let ?? = "呵呵"
let ?? = "狗"
print(??)
var a = 10
var b = "A"
var c = 100.1
var d = 200.2
var e = c+d
var char = "A"http://這樣的創(chuàng)建的是字符變量

####2.類型判斷
swift中定義變量和常量的時(shí)候,不需要標(biāo)識(shí)出變量和常量的類型,系統(tǒng)會(huì)自動(dòng)進(jìn)行匹配補(bǔ)全,但是也可以進(jìn)行手動(dòng)指定

let name = "小超"http://這里就會(huì)自動(dòng)推斷為String類型,是由后面的字符串推斷出來的
let name1 : String = "西門慶"http://這個(gè)常量就不會(huì)進(jìn)行類型推斷,因?yàn)橐呀?jīng)顯示的指定了常量的類型
//swift中(系統(tǒng)原生的)所有的類型都是首字母大寫,剩下的小寫
var age :Int = 20
var weight : Float = 130
var money : Double = 100000000

不論是變量還是常量,要么賦初值,要么指定類型,要么指定為可選類型,要么指定類型并且賦初值,否則報(bào)錯(cuò)

####3.可選類型
在Swift當(dāng)中對(duì)象沒有賦初值就沒有起始值,沒有值的量是不能使用的,會(huì)報(bào)錯(cuò)和警告,這個(gè)時(shí)候就需要可選類型,可選類型簡單來說就可以理解為,允許為空
將一個(gè)變量聲明為可選類型?很簡單,在最后面加一個(gè)?就可以了

//聲明一個(gè)可選類型的字符串變量
var sex : String?
print(sex)
sex = "女"
print(sex)
print(sex!)//顯示拆包,用!可以將可選類型中的數(shù)據(jù)拆解出來

//下面的代碼因?yàn)椴荒転榭沼譀]有進(jìn)行初始化,所以會(huì)報(bào)錯(cuò)
//var sex2 : String
//print(sex2)

####4.字符串

//(1).創(chuàng)建空的字符串
var str_empty :String = ""
var str_empty2 :String = String()
//(2).判斷字符串是否為空
if str_empty.isEmpty{
print("字符串是空")
}
//(3).字符串拼接
var str1 = "aaa"
var str2 = "bbb"
var str3 = "!!!"
var str4 = str1 + str2 + str3
print(str4)
//(4).字符串中間插入數(shù)值
//swift中占位符更改了,使用()來進(jìn)行變量和常量的取值
print("字符:(str4)\n")
//(5).獲取字符串長度
print(str4.characters.count)
//(6).字符串等值判斷
if str1 != str2{
print("兩個(gè)字符串不相等")
}

####5.(隱式類型轉(zhuǎn)換)
swift里面沒有隱式類型轉(zhuǎn)換,只有顯示類型轉(zhuǎn)換

//強(qiáng)制類型轉(zhuǎn)換語法: Float()
let aa:Int = 3
let bb:Float = 2.3
var cc = Float(aa)+bb

####6.數(shù)組的使用
swift中的特點(diǎn)?:1 存儲(chǔ)的所有的數(shù)據(jù)類型必須是同一類型 2 不必非得是對(duì)象類型,基本數(shù)據(jù)類型也可以存儲(chǔ)

//數(shù)組的創(chuàng)建方式
var nameArray = ["呵呵","阿斯頓","金坷垃"];//首先推斷為數(shù)組,數(shù)組里面元素的類型為字符串
//這種事直接顯示指定數(shù)組和其元素類型
var nameArray1:Array<String> = ["小明","老王","星池"];
//創(chuàng)建一個(gè)空的數(shù)組
var array = Array<String>()//推薦用這種
var array1 = Int//創(chuàng)建一個(gè)整型的數(shù)組

//訪問數(shù)組
print("數(shù)組第一個(gè)元素是(nameArray[0])")
//添加元素
nameArray.append("金條")
nameArray.insert("小祥", atIndex: 0)
print(nameArray)
//刪除
nameArray.removeAtIndex(0)
print(nameArray)
//修改
nameArray[0] = "小翔子"
print(nameArray)

####7.字典
```
//定義字典
var score:Dictionary<String,Int> = ["小賤":99,"小杰":82,"小隨":56]
//定義空的字典
var dic1:Dictionary<String,Int> = [:]
var dic2 = Dictionary<String,Int>()//推薦
//添加鍵值對(duì)
score["小歐"] = 95
//修改某個(gè)鍵值對(duì)
score["小賤"] = 59
print(score)
//刪除
score.removeValueForKey("小杰")
print(score)
```
####8.元組
元組是將任意類型的任意個(gè)數(shù)的元素組成一個(gè)新的數(shù)據(jù)類型
```
var status = ("大神32",["18","19","20"],32)
var status1:(className:String,ages:Array,count:Int) = ("大神32",["18","19","20"],32)
//元組數(shù)據(jù)的訪問
//方式1
print(status.0)
//方式2
print(status1.className)
```
元組的建議:元組中的元素過多,用標(biāo)記名稱,元組中的元素較少,種類能夠分開,直接使用下標(biāo)

####9.分支語句
在swift當(dāng)中,bool類型只有true個(gè)false 沒有YES和NO

```
let flag = true
if flag == true{
    print("開心")
}else{
    print("不開心")
}
```
switch
```
1.不需要使用break,不會(huì)有貫穿現(xiàn)象
let ageOfCat = 10
switch ageOfCat{
case 0:
    print("小包")
case 1:
    print("阿包")
default:
    print("包包")
}
2.支持區(qū)間選項(xiàng)
switch ageOfCat{
case 0..<10://半閉區(qū)間
    print("哈寶")
case 10...100://閉區(qū)間
    print("呢寶")
default:
    print("腰包")
}
3.支持where子句
switch ageOfCat{
case var value where ageOfCat < 10 && ageOfCat > 0:
    value++
    print("baobao")
case var value2 where ageOfCat >= 10 && ageOfCat < 100:
    print("大寶")
default:
    print("hehe")
}
```
####10.循環(huán)
```
for循環(huán)
for var i = 0; i < 10 ; i++ {
    print("我是第\(i)遍")
}
 let arr = ["??","??","??","??","??","??"]
//遍歷數(shù)組
for a in arr{
    print(a)
}
//遍歷字典
let dict = ["?":18,"西施":16,"杜十娘":21]
for (key,value) in dict{
    print("\(key)->\(value)")
}
//while
var number = 5;
while number > 0{
    number--
    print(number)
}

repeat {
    print("dasd")
    number--
}while number > -6
```
####11.函數(shù)
```
//無參無返回值的函數(shù)
func function1() ->Void{
    print("啦啦啦")
}
//無參有返回值的函數(shù)
func function2() ->Int{
    return 10
}
//有參無返回值的函數(shù). 參數(shù)列表是先寫參數(shù)名,再寫參數(shù)類型
func function3(a:Int,b:Double) ->Void{
    
}
//有參有返回值的函數(shù)
func function4(a:Int,b:Double) ->Int{
    return a + Int(b)
}
//函數(shù)調(diào)用的時(shí)候需要顯示的標(biāo)明參數(shù)名字,但是,一般第一個(gè)參數(shù)不寫,剩下的參數(shù)都要標(biāo)明參數(shù)的名字
function4(5, b: 2.0)
//inout參數(shù)
//參數(shù)默認(rèn)的是let類型的,但是swift提供了另外一種方式,可以將參數(shù)和傳入的值進(jìn)行關(guān)聯(lián),就是inout
func change(inout value : Int){
    value = 10
}
var number1 = 20
change(&number1)
print(number1)
```
####12枚舉
```
enum Season : Int{
    case spring = 10
    case summer
    case autumn
    case winter
}
print(Season.summer.rawValue)
```
####13 結(jié)構(gòu)體
```
struct Rect {
    //聲明結(jié)構(gòu)體的變量屬性,(存儲(chǔ)屬性)
    var x : Float
    var y : Float
    var width : Float
    var height :Float
    //聲明結(jié)構(gòu)體屬性
    static var desription:String?
    //聲明結(jié)構(gòu)體的變量屬性,(計(jì)算屬性)
    //計(jì)算屬性:這個(gè)屬性專門計(jì)算其他屬性的值,但其本身并不存儲(chǔ)值,一般提供setter,getter方法,在setter,getter方法中實(shí)現(xiàn)對(duì)其他屬性的計(jì)算
    var centerX :(Float){
        //setter方法
        set{
            //這里的newValue是系統(tǒng)傳遞過來的數(shù)值,代指就是調(diào)用set方法的時(shí)候賦予的值
            //如果這個(gè)修改的屬性是let類型的,那么不能進(jìn)行修改,會(huì)報(bào)錯(cuò)
            x = newValue
        }
        //getter方法,這個(gè)方法必須要有,否則報(bào)錯(cuò)
        get{
            return x+width/2
        }
    }
    var centerY :(Float){
        //get方法是必須的,但是set方法可以省略
        get{
            return y + height/2
        }
    }
    var totalLength:(Float){
        set{
            //計(jì)算屬性可以對(duì)多個(gè)屬性進(jìn)行操作
            width = newValue / 4
            height = newValue / 4 
        }
        get{
            //也可以同時(shí)返回多個(gè)屬性計(jì)算的結(jié)果
            return (width + height) * 2
        }
    }
    //swift里面結(jié)構(gòu)體可以聲明方法
    //聲明方法,結(jié)構(gòu)體方法不設(shè)置返回值
    func frameInfo(){
        print("frame的寬為\(width),高為\(height),周長為\(width*2 + height*2)")
        //屬性值的改變只能在計(jì)算屬性里去寫
//        description = "2016年4月8日創(chuàng)建"
//        print(desription)
    }
    //聲明結(jié)構(gòu)體方法
    static func info(){
        print("這是一個(gè)結(jié)構(gòu)體方法")
        //結(jié)構(gòu)體變量只能在結(jié)構(gòu)體方法里面使用,正常方法不能使用
        desription = "2016年4月8日創(chuàng)建"
    }
}
//初始化結(jié)構(gòu)體
var frame = Rect(x: 100, y: 100, width: 200, height: 200)
//打印frame的數(shù)值
print(frame)
frame.x = 300
print(frame)
//計(jì)算屬性的使用
frame.centerX = 200//這一句代碼相當(dāng)于調(diào)用了centerX屬性的set方法
print(frame)
print(frame.centerX)//這一句代碼相當(dāng)于調(diào)用了CenterX屬性的get方法
print(frame.totalLength)
//方法的調(diào)用
frame.frameInfo()

Rect.info()
```
####14 類
```
/*
class Person{
    //屬性
    var name : String?
    var age : Int?
    //初始化方法,這里的參數(shù)列表要和上面的保持一致
    init(name :String, age : Int){
        self.name = name
        self.age = age
    }
}
//1.類的使用
var person = Person(name: "鐵錘", age: 18)
//2.屬性的使用
print(person.name!)
*/
class Person {
    //1.屬性
    //聲明對(duì)象方法
    var name : String?
    var age :Int?
    //聲明類屬性
    static var introduce : String?
    //計(jì)算屬性
    var value : Int{
        //類中計(jì)算屬性實(shí)現(xiàn)的不同
        set(a){
            age = a//set get方法中不能出現(xiàn)self,會(huì)造成死循環(huán)
        }
        get{
            return age!//這里不要忘記了拆包(去掉括號(hào))
        }
    }
    //方法
    //聲明類方法
    //在類中,如果方法使用static修飾,那么表示兩個(gè)事,1 他是類方法 2.他不能被子類重寫
    static func sayHi(){
        print(introduce!)//類屬性只能在類方法中使用,正常方法中不能使用
    }
    //在類中,如果方法使用class修飾,那么表示兩個(gè)事,1 他是類方法 2.他能被子類重寫
    class func sayHi1() {
        print(introduce!)
    }
    //聲明實(shí)例方法
    func sayHi2(){
        print("我是實(shí)例方法~~~")
    }
    //自定義初始化方法(構(gòu)造函數(shù))
    init(name : String ,age : Int){
        self.name = name
        self.age = age
    }
    init(name : String){
        self.name = name
    }
}
//怎么讓類繼承另一個(gè)類
class Student : Person{
    //重寫父類的方法
    //子類  重寫父類的方法,必須添加override關(guān)鍵字
    override class func sayHi1() {
        print("我是Student類,重寫了父類的類方法")
    }
    //重寫父類的實(shí)例方法
    override func sayHi2() {
        print("我是Student類,重寫了父類的實(shí)例方法")
    }
}
//類的創(chuàng)建和使用
var person = Person(name: "小海", age: 18)
//調(diào)用類的類屬性
Person.introduce = "我是Person類"
//調(diào)用類方法
Person.sayHi()
Person.sayHi1()
//調(diào)用實(shí)例方法
person.sayHi2()
//調(diào)用實(shí)例變量
print(person.name!)
person.name = "小通"
print(person.name!)
//調(diào)用計(jì)算屬性
person.value = 30
print(person.age!)
//關(guān)于Student
var student = Student(name: "小2B", age: 23)
//調(diào)用實(shí)例方法
student.sayHi2()
//調(diào)用類方法
Student.sayHi()
Student.sayHi1()

```
####15 值類型和值引用
```
*/
//struct Animal {
//    var name : String
//    var age : Int
//    init(name : String,age : Int){
//        self.name = name
//        self.age = age
//    }
//}
////使用這個(gè)方法
////1.創(chuàng)建一個(gè)dog變量
//var dog = Animal(name: "旺財(cái)", age: 8)
////2.創(chuàng)建另一個(gè)dog變量,等于原先的dog變量
//var dog1 = dog//此時(shí)dog1的值是從dog變量中拷貝一份出來的,是新的值
////3.改變?cè)鹊膁og變量
//dog.name = "阿黃"
////4.打印兩個(gè)變量的值
//print("\(dog.name)--\(dog1.name)")


class Animal {
    var name : String?
    var age : Int?
    init(name : String,age : Int){
        self.name = name
        self.age = age
    }
}
//創(chuàng)建類的對(duì)象
var cat = Animal(name: "(>^ω^<)喵", age: 8)
var cat1 = cat
cat.name = "喵喵"
print("\(cat.name!)--\(cat1.name!)")

/**
*  協(xié)議(protocol)
*/
//如果協(xié)議里面包含可選實(shí)現(xiàn)的方法,那么需要添加一個(gè)@objc關(guān)鍵字作為標(biāo)記
@objc protocol marryDelegate{
    //協(xié)議里面寫的方法都是必須實(shí)現(xiàn)的
    func cook()
    func washCloth()
    //協(xié)議里面如果方法可選,需要加關(guān)鍵字optional
    optional func HitDouDou()
}

protocol husbandDelegate{
    //掙錢
    func makeMoney()
}
//class man : Person<marryDelegate,husbandDelegate>
//swift規(guī)定 類名后面第一個(gè)是父類,剩下的都是接受的協(xié)議名字
class Man : Person,marryDelegate,husbandDelegate {
    @objc func cook() {
        print("河南燴面")
    }
    @objc func washCloth() {
        print("洗衣機(jī)洗去")
    }
    func makeMoney() {
        print("$66666")
    }
}

//看看協(xié)議是否好用
var man = Man(name: "小小",age:18)
man.makeMoney()

//類的擴(kuò)展(Extension)
//1.擴(kuò)展類遵循的協(xié)議中的方法的實(shí)現(xiàn)
extension Man{
    @objc func HitDouDou() {
        print("打豆豆")
    }
}
//2.擴(kuò)展一個(gè)類的方法,給某一個(gè)類添加一個(gè)方法,類似于OC里面的Category
extension Man{
    //添加一個(gè)方法
    func joke(){
        print("講笑話")
    }
}
man.HitDouDou()
man.joke()

```
####16 閉包(Block)
```
*/
//Block 匿名函數(shù)
//int(^myBlock)(int a, int b)= ^int (int a, int b) {
//  return a>b?a:b
// }
var MyBlock : ((a : Int,b : Int)->Int)
//功能:求兩個(gè)數(shù)的最大值
//第一種方式
MyBlock = {
    (a : Int, b : Int)->Int in //in 是閉包語法結(jié)構(gòu)的一部分,必不可少,前面指定的是參數(shù)列表和返回值等信息
    return a > b ? a : b
}
//第二種方式
MyBlock = {
    a,b in
    return a > b ? a : b
}
//第三種
MyBlock = {
    (a,b)->Int in
    return a > b ? a : b
}
//第四種
MyBlock = {
    a,b in
    a > b ? a : b
}
//第五種 裝逼神器
MyBlock = {
    $0 > $1 ? $0 : $1
}

//調(diào)用
let max = MyBlock(a: 3, b: 5)
print(max)

```