Swift 与Object C 的比较

1.swift 没有.h文件，也就是头文件
2.swift对于类的声明是使用class关键字而不是interface
3.swift使用var定义变量，默认是不会自动给变量赋初始值的
4.swift中的问号，如，表示该变量的值是可选的，也就是说这个变量值可能为nil，也可能是一个具体的值。

var typeName:String?

5.那么对于这种声明时候带有问号（即声明为可选）的变量如何使用呢？
比如调用方法、属性、下标索引等前面需要加上一个?，问号的意思是询问是否响应后面这个方法，和原来的isResponsetoSelector有些类似”

var strValue : String? 
let hashValue = strValue?.hashValue

6.连接字符串和字符

字符串插值

pirntln()函数代替oc的NSLog函数， 可以 字符串和 变量或常量 直接输出
其中 输出的变量表示方式\(变量名) \()变量的占位符，括号里面放变量

var c = 10
println("c=\(c)")// \() 是占位符 c是变量名
//打印结果：
c=10

let mutiplier = 3
let message = "\(mutiplier) times 2.5 is \(Double(mutiplier) * 2.5)"
///message is "3 times 2.5 is 7.5"

字符连接

let string1 = "hello"
let character1: Charater = "!"
let stringPlusCharacter = string1 + character1  //输出"hello!"

7.构造器中
构造函数中如果有init函数，则会调用init函数进行初始化,没有则调用默认的init函数. 和oc比较已经不用[ [SurveyQuestion alloc] init]这种写法了
反而和c的写法相似了，只是在调用构造器的时候，参数要带上名字。

classSurveyQuestion {
    let text: String
    var response: String?init(text: String) {
        self.text = text
     }
     func ask() {
         println(text)
     }
 }
let beetsQuestion = SurveyQuestion(text:"How about beets?")
beetsQuestion.ask()
//输出"How about beets?"

8.默认构造器
这个默认的构造器将简单的创建一个所有属性值都设置为默认值的实例

classS hoppi ngLis tIte m {
    var name: String? 
    var quantity = 1 
    var purchased =false
} 
var item = ShoppingListItem()

9.分号
swift并不强制要求你在每条语句结尾处加上分号(;),但是有一种情况下必须用分号，即你打算在一行内写多条独立语句：

let cat = "hello"; println(cat)

10.类型转换(优先级 132)

is //类型检查(type check)
as //类型转换(type cast)

11.Optional类型的值

参考：Swift 可选值(Optional Values)介绍

12.声明特性

assignment

该特性用于修饰重载了复合赋值运算符的函数。重载了复合赋值运算符的函数必须将他们的初始输入参数标记为inout,因为这个参数会在运算符函数内直接修改它的值。什么是复合赋值运算符？首先赋值运算符是指=，那么把其他运算符和赋值运算符=组合在一起的叫做复合赋值运算符

var a = 1
a += 2

@assignment func += (inout left: Vector2D,right: Vector2D) { 
    left = left + right
}

lazy

该特性用于修饰类或者结构体中的存储型变量属性，标示属性的初始值最多只被计算和存储一次，且发生在第一次访问它时。如：

lazy var menuItems: NSArray = {
    let path = NSBundle.mainBundle().pathForResource("MenuItems",ofType: "plist")
    return NSArray(contentsOfFile: path!)!
    }()

final

该特性用来修饰一个类或者类中的属性、方法、下标成员。如果用它修饰一个类，那么这个类不能被继承。如果它修饰类中的属性、方法或者下标，则标示在子类中，他们不能被重写。也就是说被修饰意味着它是最终的版本。

NSManaged

该特性用于修饰 NSManagedobject 子类中的存储型变量属性,表明属性的存储和实现由 Core Data 在运行时基于相关实体描述动态提供。

required

用该特性修饰一个类的指定或便利初始化器，表示该类的所有子类都必须实现该初始化器。

required override init(frame: CGRect) {
        super.init(frame: frame)
        configure()
    }

注：其他特性暂时不记录，因为还没有深入理解..

13.属性
存储属性

简单来说,一个存储属性就是存储在特定类或结构体的实例里的一个常量或变量,存储属性
可以是变量存储属性(用关键字 var 定义),也可以是常量存储属性(用关键字 let 定义)。

例如：FixedLengthRange 的实例包含一个名为 firstValue 的变量存储属性和一个名为 length 的常 量存储属性

struct FixedLengthRange {
    var firstValue: Int
    let length: Int
}
var rangeOfThreeItems = FixedLengthRange(firstValue: 0,length: 3)
// 该区间表示整数0,1,2
rangeOfThreeItems.firstValue = 6
// 该区间现在表示整数6,7,8

计算属性

除存储属性外，类、结构体和枚举可以定义计算属性，计算属性不直接存储值，而是提供一个getter来获取值，一个可选的setter来间接设置其他属性或者变量的值

struct Point{
    var x=0.0,y=0.0
}
struct Size{
    var width = 0.0,height = 0.0
}
struct Rect{
    var orign = Point()
    var size = Size()
    var center:Point{
        get{
            let centerX = origin.x +(size.width/2)
            let centerY = origin.y + (size.height/2)
            return Point(x:x.centerX,y:centerY)
        }
        set(newCenter){
            orgin.x = newCenter.x - (size.width/2)
            orgin.y = newCenter.y - (size.width/2)

        }
    }
    var square = Rect(orign:Point(x:0.0,y:0.0),size:Size(width:10.0,height:10.0))
    let initialSquareCenter = square.center
    square.center = Point(x:15.0,y:15.0)
    println("square.origin is Now at (\(square.origin.x),\(square.origin.y))")
    // 输出 "square.origin is Now at (10.0,10.0)”
}

上面的例子Rect 提供了一个计算性的属性center

14.属性监视器

属性监视器监控和响应属性值的变化,每次属性被设置值的时候都会调用属性监视器,甚至 新的值和现在的值相同的时候也不例外。
可以为除了延迟存储属性之外的其他存储属性添加属性监视器,也可以通过重载属性的方式 为继承的属性(包括存储属性和计算属性)添加属性监视器

可以为属性添加如下的一个或全部监视器:
willSet 在设置新的值之前调用
didSet 在新的值被设置之后立即调用
willSet 监视器会将新的属性值作为固定参数传入,在 willSet 的实现代码中可以为这个参数
指定一个名称,如果不指定则参数仍然可用,这时使用默认名称 newValue 表示。
类似地,didSet 监视器会将旧的属性值作为参数传入,可以为该参数命名或者使用默认参数 名 oldValue。

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {
            println("About to set totalSteps to \(newTotalSteps)")
        }
    }
    didSet {
        if totalSteps > oldValue {
            println("Added \(totalSteps - oldValue) steps")
        }
    }
}

let stepCounter = StepCounter() stepCounter.totalSteps = 200
// About to set totalSteps to 200 16.// Added 200 steps
stepCounter.totalSteps = 360 18.// About to set totalSteps to 360 19.// Added 160 steps stepCounter.totalSteps = 896
// About to set totalSteps to 896 22.// Added 536 steps

注意:willSet 和 didSet 监视器在属性初始化过程中不会被调用,他们只会当属性的值在初始化之外的地方被设置时被调用。

14.扩展

扩展就是向一个已有的类、结构体或者枚举类型添加新功能。扩展和Object-C中的分类(categories)类似。(不过与objective-C不同的是，Swift的扩展没有名字。)

extension UIColor {
  convenience init(colorArray array: NSArray) {
    let r = array[0] as! CGFloat
    let g = array[1] as! CGFloat
    let b = array[2] as! CGFloat
    self.init(red: r/255.0,green: g/255.0,blue: b/255.0,alpha:1.0)
  }
}

15.便利构造器

class Food {
    var name: String
    //指定构造器
    init(name: String) {
        self.name = name
    }
    //便利构造器
    convenience init() {
        self.init(name: "[Unnamed]")
    } 
}

官方文档看了很久，没看出来便利构造器有什么作用。官方文档指出区别如下：

跟 Objective-C 中的子类不同,Swift 中的子类不会默认继承父类的构造器。Swift 的这 种机制可以防止一个父类的简单构造器被一个更专业的子类继承,并被错误的用来创建子类的实例。

如果你重载的构造器是一个指定构造器,你可以在子类里重载它的实现,并在自定义版本的构造器中调用父类版本的构造器。

如果你重载的构造器是一个便利构造器,你的重载过程必须通过调用同一类中提供的其他指定构造器来实现。