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{get
set}
    var age:Int{get}
    init(name:String)
    func sum(num1:Int,num2:Int)->Int
}

class FanXingTwo<TypeValu>{
    var items=[TypeValu]()
    func pop()->TypeValu{
    return
items.removeLast()
    }
    func push(item:TypeValu){
    items.append(item)
    }
    subscript(index:Int)->TypeValu?{
        get{
            return
items.isEmpty ?
nil:items[index]
        }
        set(newValue){
        self.items[index]=newValue!
        
        }
    }
}

class FanXing{
    func transformVars<T:
FirstProtocol>(var1: inout
T,var2: inout
T)->Void{
        let tep=var1
        var1 = var2
        var2 = tep
    }
}