Swift的学习总结

一，概要

     Swift由于苹果的极力推广最近两年很火，大家都在争相空后的研究学习，经过简单学习我发现Swift是一个很轻量级的面向对象的语言，比ObjectC更加面向对象，很像JavaScript但是又比它强大的了好多，而且跟C和ObjectC有很好的兼容性，这就是它得天独厚的好处，闲话少说下面开始解析

1.语法

每个面向对象的语言都有自己的语法，如何定义变量，如何定义类，数据类型，关键字，运算符等，Swift定义变量用关键字var和let 其中var是用来定义普通变量和类型，let是定义常量和类型；也有好多其它的关键字，比如struct定义结构体，enum定义枚举，class定义对象 func定义函数 另外还有闭包等。

2.元素介绍

//方法

//一般的方法

class CommenMothed{

    func funcOne(name:String="Jack",age:Int=18)->String{

    print("name=\(name),age==\(age)")

        return"OK"

    }

    

    func funcTwo(funcP:(Int)->Int,num:Int)->((Int)->Int){

        func funcNei(m:Int)->Int{

            return m;

        }

        

        returnfuncNei;

    }

}

//类型方法一般的方法是被实例调用的类型方法是class直接调用的，struct和enum定义类型方法是用static，class类型的类型方法是用class关键字定义

class StaticMotheds{

    staticvar age:Int=18

    //可以让子类继承

    classfunc abs(n1:Int,n2:Int)->Int{

        return n1+n2

    }

    //不可以继承

    staticfunc qwr(){

        

    }

}

struct StructStaticMothed{

    staticvar age:Int=18

    staticfunc qwr(){

    

    }

}

//属性

class TestVar{

    var _name="Jack"

    var name:String?{

        get{

        return_name

        }

        set(newValue){

            if(newValue==_name){

            

            }else{

             _name=newValue!

            }

        }

    }

    var ageOne:Int=18{

        willSet{

        print("变量willSet即将更改")

        }

        didSet{

        print("new-ageOne=\(ageOne),old-ageOne=\(oldValue)")

        }

       

    }

}

//类class

class OneObj{

    var oneVar:String?

    var twoVar=2

    var three:Int

    init(three:Int){

        self.three=three

    }

    

}

//class对象和对象判断是否相等swift用===和!==恒等符号

func twoClass(one:OneObj,two:OneObj)->Bool{

return one===two||one.three==one.three

}

//结构体初始化方法使用init

struct StructOne{

    var mark1:Int

    var mark2:String

    init(mark1:Int,mark2:String){

        self.mark1=mark1

        self.mark2=mark2

    }

}

var structVar = StructOne(mark1:2, mark2:"sss")

structVar.mark1=13

structVar.mark2="right"

struct structTwo{

    var var1:String

    var var2=2

}

//枚举 enum Name{ case , , ,}

enum OneEnum{

    case ONE,TWO,THREE

}

print(OneEnum.TWO.hashValue)

//原始值模式

enum TwoEnum:Int{

  case ONE=1,TWO,THREE

}

print(TwoEnum.ONE.rawValue)

//相关值模式

enum ThreeEnum{

case ONE(String)

case TWO(Int,String)

}

print(ThreeEnum.ONE("22"))

var oneNum=ThreeEnum.ONE("33")

var twoNum=ThreeEnum.TWO(2,"wr")

func swithEnum(enumPara:ThreeEnum){

    switch enumPara{

    case .ONE(let name):

        print(name)

         break

    case .TWO(let f,let s):

        print(s)

        break

        

    default:

        break

    }

}

swithEnum(twoNum)

func funcReturn(name:String)->((Int)->String){

   

    func funcnei(age:Int)->String{

    return"name=\(name),age=\(age)"

    }

    

    returnfuncnei;

}

func funcParamsDefault(name:String="jack",age:Int=18){

   print("name=\(name),age=\(age)")

}

funcParamsDefault()

funcParamsDefault(age: 20)

//闭包

typealias QxClosure=(String)->Void//定义了一个闭包类型就相当于定义了一个类的类型

var oneClosure:QxClosure?

func setBackClose(closure:QxClosure){

    oneClosure=closure;

    oneClosure!("bibao block能实现同样的功能")

}

var array=[1,4,2,8,3,0]

array.sort()

typealias QxClousure=(String,Int)->String?

var myClosure:QxClousure?

myClosure={(name:String,age:Int)->Stringin

    return name;

}

myClosure!("str",8)

//swift继承用：跟Object—C一样，不是extends

class SuperClass{

    var name:String="Jack"

    finalvar age:Int=18//加了final类就不能重写更改了

    

    init(name:String,age:Int){//初始化方法（构造器不需要func关键字）

        self.name=name

        self.age=age

    }

    func methodOne(){

    print("我是 SuperClass的")

    }

}

class SonClass: SuperClass {

    

    overrideinit(name:String, age:Int) {

        super.init(name: name, age: age)

        self.age=age

    }

    

    overridevar name:String{

        set(newValue){

        name=newValue

        }

        get{

        return"我是重写的+\(name)"

        

        }

    }

    overridefunc methodOne() {

        print("我是重写后的method方法")

    }

}

//可失败的构造器class struct enum都可以定义，规则：在init？或者init!

class CanFailClass{

    var name:String="2"

    init?(name:String){

        if(name.isEmpty){returnnil}

        self.name=name

    }

}

if var canOne=CanFailClass(name:""){

   print("有数据：\(canOne.name)")

}else{

   print("无数据")

}

//析构过程其实就是init的反过程一个是初始化资源init，一个是清理资源 deinit

//可失败的构造器class struct enum都可以定义，规则：在init？或者init!

class CanFailClass{

    var name:String="2"

    init?(name:String){

        if(name.isEmpty){returnnil}

        self.name=name

        print("初始化实例成功")

    }

    deinit{

      print("实例被销毁了")

    }

}

//可选链？可以用在方法，属性和下角标等，可选链可能返回两个值：要么是你需要的值，要么就是nil，

//多次.请求或者调用可以被链接成一个链任何一个节点为nil结果都是nil

class LianTest{

    var stu:Student?

}

class Student{

    var age:Int=1

}

var lian=LianTest()

var nm=lian.stu!.age//这样写将会报错，因为！会要求强制解析获得stu的age属性，但是stu是nil所以会报错

var nm2=lian.stu?.age//这样就不会报错了，因为可选链上任何节点是nil，结果都是返回nil

if(nm2==nil){

print("没有初始化不能查看年龄")

}else{

print("已经初始化，年龄是:\(nm2)")

}

//swift类型转换两个关键字is as(as?和as!)，两个全类型AnyObject代表任何class类型，Any代表任何类型，包括方法类型等

class Parent{

    var name:String

    init(name:String){

    self.name=name

    }

}

class Some{}

class SonOne:Parent{

    var lastName:String

    init(name:String,lastName:String){

    self.lastName=lastName

    super.init(name: name)

     

    }

}

class SonTwo:Parent{

    var age:Int

    init(name:String,age:Int){

    self.age=20

        super.init(name: name)

    }

}

var obj1=Parent(name:"parent")

var obj2=SonOne(name:"son1", lastName:"son1-last")

var obj3=SonTwo(name:"son2", age:20)

var obj4=Some()

if obj1isParent{

    print("obj1")

}

if obj2isParent{

    print("obj2")

}

if obj4isParent{

  print("obj4")

}else{

print("obj4-no")

    

}

var array1=[Parent]()

array1.append(obj3)

array1.append(obj2)

array1.append(obj1)

for item inarray1{

    iflet re=itemas?Parent{

    print("item is parent")

    }

    ifvar re2=itemas?SonOne{

    print("re2")

    }

    if itemisParent{

    print("is")

    }

}

var array2=[AnyObject]()

array2.append(obj3)

array2.append(obj4)

array2.append("String")

array2.append(35)

var methodName:((Int,String)->String)?

var array3=[Any]()

array3.append(obj4)

array3.append(obj3)

array3.append(methodName)

array3.append("String")

//Swift的扩展关键字:extension class struct和enum以及数据类型都可以扩展，扩展属性扩展方法扩展构造器,实现某个协议和类等等

extension String{

    func StringWithString(str:String)->String{

    

        returnself+str;

    }

}

extension Int{

    var add:Int{returnself+100}

    

}

//协议可以被class struct enum实现，实现方式跟继承类一样，在:后面书写就可以，多个用,隔开，如果有继承的父类，父类放在第一个位置，并与接口用,隔开就好；接口可以声明变量但是必须指定是可读写的还是只可读的，var name:String{ get set}可读写,你也可在接口中声明构造器init，但是实现的类必须实现，并且要在init前加required修饰符

protocol FirstProtocol{

    var name:String{getset}

    var age:Int{get}

    init(name:String)

    func sum(num1:Int,num2:Int)->Int

}

extension String{

    func StringWithString(str:String)->String{

    

        returnself+str;

    }

}

extension Int{

    var add:Int{returnself+100}

    

}

//swift类型转换两个关键字is as(as?和as!)，两个全类型AnyObject代表任何class类型，Any代表任何类型，包括方法类型等

class Parent{

    var name:String

    init(name:String){

    self.name=name

    }

}

class Some{}

class SonOne : Parent,FirstProtocol{

    var name:String="Jack"

    var age:Int=18

    

    var lastName:String

    init(name:String,lastName:String){

    self.lastName=lastName

    super.init(name: name)

        func sum(num1:Int,num2:Int)->Int{

            return num1+num2

        }

     

    }

}

//Swift泛型跟java的泛型很像而且他的约束条件还可以用where

protocol FirstProtocol{

    var name:String{getset}

    var age:Int{get}

    init(name:String)

    func sum(num1:Int,num2:Int)->Int

}

class FanXingTwo<TypeValu>{

    var items=[TypeValu]()

    func pop()->TypeValu{

    returnitems.removeLast()

    }

    func push(item:TypeValu){

    items.append(item)

    }

    subscript(index:Int)->TypeValu?{

        get{

            returnitems.isEmpty ?nil:items[index]

        }

        set(newValue){

        self.items[index]=newValue!

        

        }

    }

}

class FanXing{

    func transformVars<T:FirstProtocol>(var1: inoutT,var2: inoutT)->Void{

        let tep=var1

        var1 = var2

        var2 = tep

    }

}