swift差異性標準

1.類型修飾符

?可變類型，代表該變量可能沒有值，!代表該變量一定有值。
?修飾的變量，需要使用!解包使用，否則是可選類型

//0.? !修飾符
        var str:String?
        str="hi"
        print(str)
        print(str!)

        var str2:String!
        str2="ha"
        print(str2!)
2.if條件語句

if語句不需要括號

        let num:Int=10
        if num<100
        {
            print(num)
        }
3.for循環(huán)語句
        let nums:[Int]=[10,20,30,40]
        //不需要索引
        for value in nums
        {
            print(value)
        }
        //需要索引
        for (index,value) in nums.enumerated()
        {
            print(index,"+",value)
        }
        //forEach函數(shù)
        nums.forEach {num in
            print(num)
        }
4.string
        //String可變
        var strT="ABC"
        strT+="DEF"
        print(strT)
        
        //string連接變量
        let index=6
        strT+="\(index)個字母"
        print(strT)
        
        //string比較
        let strA="A"
        let strB="A"
        if strA==strB
        {
            //string長度
            print(strA.count,terminator: "")
            print("相同")
        }
5.數(shù)組和字典
//數(shù)組和字典的基本使用
        let nums:[Int]=[5,2,3]
        for num in nums
        {
            print(num)
        }
        
        let dicts:[Int:String]=[1:"hi",2:"ha"]
        for dict in dicts
        {
            print(dict.key,dict.value)
        }
6.函數(shù)
//函數(shù)定義
    func sum(a:Int,b:Int)->Int
    {
        return a+b
    }
    
    //外部必須使用n1,n2參數(shù)名調(diào)用
    func sum2(n1 a:Int,n2 b:Int)->Int
    {
        return a+b
    }

//函數(shù)調(diào)用
        print(sum(a: 10, b: 32))
        
        print(sum2(n1: 1, n2: 1))
7.閉包

類比OC中的Block代碼塊，閉包作為變量，函數(shù)參數(shù)(尾隨閉包)，返回值的使用。
作為變量的閉包：

//閉包的定義
        let testClosure={(a:Int,b:Int) ->Int in
            return a+b
        }
        //閉包的調(diào)用
        print(testClosure(3,8))

作為函數(shù)參數(shù)的閉包：

//尾隨閉包,函數(shù)最后一個參數(shù)，使用閉包作為參數(shù)cl:(參數(shù))->返回值
    func multi(a:Int,b:Int,cl:(Int,Int)->Int)->Int
    {
        cl(a,b)
    }

//尾隨閉包的使用(){閉包體在括號后面}
        let res=multi(a: 6, b: 7) { a, b in
            return a*b
        }
        print(res)

作為返回值的閉包：

//參數(shù)是a,b，返回值是()->Double的閉包
    func divide(a:Double,b:Double)->()->Double
    {
        func res()->Double
        {
            return a/b
        }
        return res;
    }

let funcDivide=divide(a: 20.0, b: 2.0)
        print(funcDivide())
8.類

屬性和方法：

//普通屬性
    var num:Int=0
    //類屬性
    static var Flag:Bool=true
    //通過setget修改屬性的值
    var middle: Int {
        get {
            return num/2
        }
        set {
            num = newValue
        }
    }
    //通過willsetdidset監(jiān)聽屬性的變化
    var counter: Int = 0{
            willSet(newTotal){
                print("計數(shù)器: \(newTotal)")
            }
            didSet{
                if counter > oldValue {
                    print("新增數(shù) \(counter - oldValue)")
                }
            }
        }
//類方法
    static func getFlag()
    {
        print("flag",Flag)
    }

//是否同一個對象或者類
        let tc1=TestClass()
        let tc2=TestClass()
        if tc1===tc2
        {
            print("同一個對象")
        }else
        {
            print("不同對象")
        }
        
        if tc1.isKind(of: TestClass.self)
        {
            print("類型相同")
        }else
        {
            print("類型不同")
        }
        
        self.num=100
        print("middle:",self.middle)
        self.counter=100
        self.counter=800
        
        ViewController.getFlag()
        ViewController.Flag=false
        ViewController.getFlag()

下腳標語法：

//下腳標語法
    var denum:Int=0
    subscript(index: Int) -> Int {
            return denum+index
    }
    
denum=97
        print(self[0])
        print(self[1])
        print(self[2])

繼承：

import UIKit
//:表示繼承，override表示重寫方法 final表示該類不允許被繼承
final class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

    }

}
9.可選鏈

可選鏈可替代強制解析

class Person {
    var residence: Residence?
}

class Residence {
    var numberOfRooms = 1
}

let john = Person()

//將導(dǎo)致運行時錯誤
let roomCount = john.residence!.numberOfRooms

想使用感嘆號（!）強制解析獲得這個人residence屬性numberOfRooms屬性值，將會引發(fā)運行時錯誤，因為這時沒有可以供解析的residence值。

class Person {
    var residence: Residence?
}

class Residence {
    var numberOfRooms = 1
}

let john = Person()

// 鏈接可選residence?屬性，如果residence存在則取回numberOfRooms的值
if let roomCount = john.residence?.numberOfRooms {
    print("John 的房間號為 \(roomCount)。")
} else {
    print("不能查看房間號")
}
10.ARC

同OC一樣，swift使用ARC管理內(nèi)存，也存在強循環(huán)引用的情況

class Book{
    var student:Student?
    init(){
        print("Book init")
    }
    deinit{
        print("Book deinit")
    }
}

//使用weak/unowned關(guān)鍵字解決循環(huán)引用的問題
class Student{
//    unowned var book:Book?
    weak var book:Book?
    init(){
        print("Student init")
    }
    deinit{
        print("Student deinit")
    }
}

var bk:Book?
        bk=Book()
        var stu:Student?
        stu=Student()
        bk?.student=stu
        stu?.book=bk
        
        stu=nil
        bk=nil
11.類型轉(zhuǎn)換

is 用于檢測值的類型，as 用于轉(zhuǎn)換類型。
向下轉(zhuǎn)型，用類型轉(zhuǎn)換操作符(as? 或 as!)

class Book{
    var student:Student?
    init(){
        print("Book init")
    }
    deinit{
        print("Book deinit")
    }
}

class Story:Book{
}

class Dictionary:Book{
}

let sd:Story=Story()
        if sd is Book
        {
            print("sd is Book")
        }else
        {
            print("sd is not Book")
        }
        
        let dic:Dictionary=Dictionary()
        
        let bks=[sd,dic]
        for value in bks
        {
            if let res=value as? Story
            {
                print(value,"as Story")
            }else
            {
                print(value,"as Dictionray")
            }
        }

Swift為不確定類型提供了兩種特殊類型別名：
AnyObject可以代表任何class類型的實例。
Any可以表示任何類型，包括方法類型（function types）。

12.類擴展

擴展就是向一個已有的類、結(jié)構(gòu)體或枚舉類型添加新功能。
擴展可以對一個類型添加新的功能，但是不能重寫已有的功能。

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
       
        let num:Int=20
        print(num.square)
        print(num.multNum(num: 3))
    }
}


extension Int{
  //拓展屬性
    var square:Int{
        return self*self
    }
    //拓展方法
    func multNum(num:Int)->Int
    {
        return num*self
    }
}
13.類協(xié)議

協(xié)議規(guī)定了用來實現(xiàn)某一特定功能所必需的方法和屬性。

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
 
        var stu:Student=Student(reading: true)
        stu.writing()
        stu.sleeping()
        print(stu.reading)
    }
}

//類中必須要實現(xiàn)協(xié)議中的屬性和方法，在初始化方法中要對屬性賦值
class Student:Live
{
    var reading: Bool
    
    init(reading:Bool) {
        self.reading=reading
    }
    
    func writing() {
        print("writing")
    }
    
    func sleeping() {
        print("sleeping")
    }
}

//協(xié)議可以繼承
protocol Study{
    //協(xié)議中屬性生命get set
    var reading:Bool{
        get set
    }
    //協(xié)議中方法定義方法名稱
    func writing()->Void
}

protocol Live:Study{
    func sleeping()->Void
}
14.泛型
//交換2個T類型的值
    func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
        let temporaryA = a
        a = b
        b = temporaryA
    }

var num1=1
        var num2=2
        var string1="a"
        var string2="b"
        swapTwoValues(&num1,&num2)
        swapTwoValues(&string1, &string2)
        print(num1,num2)
        print(string1,string2)
15.訪問控制

public 可以訪問自己模塊中源文件里的任何實體，別人也可以通過引入該模塊來訪問源文件里的所有實體。
internal 可以訪問自己模塊中源文件里的任何實體，但是別人不能訪問該模塊中源文件里的實體。
fileprivate 文件內(nèi)私有，只能在當(dāng)前源文件中使用。
private 只能在類中訪問，離開了這個類或者結(jié)構(gòu)體的作用域外面就無法訪問。

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容