Swift学习笔记

此笔记为学习Sundy老师<秒学Swift开发语言>时随堂做出的

最近不算太忙, 抽空学习一下新的知识, 看到了这个教程, 感觉灰常不错

坐标系语言学习法:

一种学习编程语言的方法,sundy老师的专利, 感觉可以很好的总结知识点,大家喜欢可以查看相关视频

程序 = 数据结构 + 算法

坐标系的横轴(纵轴也无所谓...): 数据结构, 算法

纵轴: 面向过程, 面向对象

把一门编程语言的内容放在这四部分中

具体到Swift, 自我总结的见下图:(强迫症,喜欢原点在中间)

IOS8有啥新东西？

输入法支持第三方(原装输入法实在是太渣了...)

IOS对第三方开放的第一步!

iCloud更加强大

HealthKit，HomeKit（健康相关API和智能家居API）

软件 + 硬件 + 网络

新的Swift语言

 

Playground ?!

一种 不需要编译、不需要点击执行，编写代码后直接看效果的工具, 更好的实现所见即所得
playground本质上是一个压缩包,修改后缀为rar,解压后可以发现三个文件:
contents.xcplayground
section-1.swift
timeline.xctimeline

在普通ios程序时,也可以临时建立一个playground文件

playground的具体使用

在playground的每一行,右侧的窗口都有两个按钮可选:

快速浏览,变量历史

快速浏览可以快速查看一些UI效果等

通过变量历史可以看到变量的变化,可以部分替代断点跟踪等, 如下图, 还是非常炫酷的

用起来感觉结果出的比较慢,可能是我的MacBook Air配置不够吧. 个人感觉不太实用...等待playground的发展吧

swift的变量和常量

定义方法:

常量: let name = "XXX"

变量: var newName = "YYY"

指定变量类型

var age:Double = 30

变量转义:

var age = 30

println(age is \(age));

结果: age is 30

注释和分号

注释方式:

单行注释: //

多行注释: /* ... */ (Swift支持多行注释的嵌套, /**/里面可以有/**/)

分号:

Swift不强制使用分号,但是,当一行中要书写多条语句,需要使用分号

基本数据类型

整型,可选类型,浮点型,数制,别名,布尔类型

整形:

var age: Int32 = 1

var age: Int16 = 1

var age: Int = 1//这种定义方法将根据操作系统的类型来决定

可选类型:

var stringVal1 ="23"

var stringVal2 ="abc"

var age1:Int? = stringVal1.toInt()//23

age1 =stringVal2.toInt()//nil

可选类型可以得到nil的值

浮点型

var pi: Float = 3.14

var pii: Double = 3.14159265

println(pi + pii)//出错, Float和Double不能直接运算

println(Double(pi) + pii)//使用强制类型转换即可正确执行

数制的表达

let a = 0b0010//二进制

let b = 0o1234//八进制

let c = 0xABC123F//十六进制

别名

typealias MyString = String//定义String的别名(有点类似typedef...)

let s : MyString = "HelloWorld"

println(s);

布尔类型

var b: Bool = true

b = false

元组

一组数据, 并且类型可以不同

var tus = ("hello",100, 12.345,"World")

println(tus.2)//12.345

println(tus.0)//"hello"

可以用于函数返回多个值

func getNameAge()->(String,Int) {

    return ("XXX",34)

}

var tus2 =getNameAge()

println(tus2)

字符串

字符串在Swift中是值类型,并不是引用类型!

var string1:String ="a"

var string2:String =string1

string2 ="b"

println(string1)//a

运算符

赋值运算符: =

数值运算符: + - * / %

%表示取余运算, 支持小数

let age = 5 % 0.7//0.1

比较运算符: > < >= <= == != 

条件运算符: ? :

let c = (a>b) ?1 : 2//?之前必须有个空格...否则报错

逻辑运算: ! || && 

集合类型

数组

定义数组

var myStringList = ["Hello","World", "My","God"]

var myIntList:[Int] = [1,2,3]

访问数组

基本方法:

myStringList[1] ="Swift"

println(myStringList[1])

其他:

myStringList.insert("On", atIndex:2) //Hello Swift On My God

append等方法类似

遍历数组

for valuein myStringList {

println(value)

}

字典

字典在Swift中是一个Hash结构, 要求Key值必须唯一

定义

var myHash:Dictionary<String,String> = ["Key1":"Value1","Key2":"Value2","Key3":"Value3"]

println(myHash["Key2"])

访问

myHash.updateValue("Value22", forKey:"Key2")

println(myHash["Key2"])

myHash.removeValueForKey("Key2")

println(myHash)

遍历

for valuein myHash.values {

println(value)

}

控制流

循环

var friends = ["C","C++", "Java","Swift"]

for friend infriends {

    println(friend)

}

for var i =0; i < friends.count; i++ {

    println(friends[i])

}

var j = 0

while (j <friends.count) {

println(friends[j])

j++

}

j = 0

do {

println(friends[j])

j++

} while(j <friends.count)

后两种while和do while在playground下会死掉, 但在正式的工程里没事, 哪位大神能告诉我为啥???

分支

if分支:

var j = 1, k =5

if k >j {//if后面可以不加括号,但是加上也可以

    println("k > j")

} else {

    println("k <=j")

}

switch分支

switch中每一个case必须有一条可运行的语句,自动break

k = 3

switch k {

case 1:

println("1")

fallthrough

case 2:

println("2")

case 3...4:

println("3 or 4")

case 5:

break

default:

println("nothing")

}

控制传递

break 跳出

contine 终止本次循环,开始下一次循环

fallthrough 贯穿,如上面switch中例子,如果k为1,则会输出1和2,既消灭了case 1:后面带的break

label 相当于goto,不推荐使用

函数

定义

func thisIsAFunction(first:Int, second:String)->(Int,String) {//无返回值可以不加->和后面的东西

    return (first, second)

}

调用

var result = thisIsAFunction(1,"Hello")

println(result)

多返回值时取返回值中一个的方法:

func thisIsAFunction(first:Int, second:String)->(first:Int, second:String) {

    return (first, second)

}

var result = thisIsAFunction(1,"Hello")

println(result)

println(thisIsAFunction(2,"World").first)//2

函数的参数

普通参数

外部参数 func myFunction(name userName:String, age:Int)

默认参数 func myFunction(#userName:String)

可变参数

func countPerson(users:String...) {

for userin users {

println(user)

}

}

countPerson("Bob","Mike", "Robin");

输入输出参数

在参数前加入inout,相当于传递了一个引用类型的参数

func changeName(inout name:String) {

name = "Robin"

}

var myName = "Bob"

changeName(&myName)

println(myName)//Robin

函数的类型

比如:

定义和使用一个函数变量

func addMoney(a:Int, b:Int)->Int {

    return a + b

}

var getMoney:(Int,Int)->Int =addMoney

println(getMoney(1,2))

函数类型用作函数的参数

func onMoneyAdded(function:(Int,Int)->Int)->Int {

return function(1,2)

}

onMoneyAdded(addMoney)

闭包(Closure)

可以理解为一种代码块

var myList = ["bbb","aaa", "ccc"]

sort(&myList, {(s1:String, s2:String)->Boolin return s1 < s2})

println(myList)

如上例,将比较函数作为一个代码块放到了sort里

枚举(Enumeration)

enum Sex {

case Male

case Female

}

var peopleSex = Sex.Male

peopleSex = .Female

//实例值

enum E {

case E1(Int, Int)

case E2(String)

}

var e = E.E1(1,2)

enum Country:Int {

    case China =1

    case Japan =2

}

var country = Country.China

类(Class)

定义

class TV {

    var keyCount =12

    var keyName ="Power"

    func openTV()->String {

        return"Success"

    }

}

var myTV = TV()

println(myTV.keyCount)

println(myTV.openTV())

var otherTV = myTV

myTV.keyName ="HHH"

println(otherTV.keyName)//HHH

println(myTV ===otherTV)//true, 判定是否恒等

故,对象是一个引用类型

构造函数和析构函数

A类继承B类, 在定义时用:

重写父类方法,使用override关键字

如果不想被子类重写,使用final(新版好像不是课程里的@final了,而是直接使用final)

例如:

class TV {

var name:String = "Toshiba"

init(name:String) {

self.name = name

}

deinit {

name =""

}   

}

var myTV = TV(name:"MyTV")

println(myTV.name)

继承(Inheritance)

class TV {

var name:String = "TV"

init(name:String) {

self.name = name

}

deinit {

name =""

}

func showName() {

println(self.name);

}

}

class TOSHIBA_TV :TV {

overrideinit(name:String) {

super.init(name: name)

super.name ="hello, \(name)"

}

    

overridefunc showName() {

super.showName()

}

    

//变量名的set和get函数

overridevar name:String {

get {

            returnself.name

        }

        set {

            self.name ="001"

        }

    }

}

var myTV = TOSHIBA_TV(name:"Toshiba")

myTV.showName()

结构体(Struct)

基本和class相同

区别如下:

struct有一个默认的构造函数,参数为struct中变量依次排列

类可以多重引用

类有析构函数

协议(Protocol)

协议可以定义属性和方法,但不能实现

在Swift中协议是可以继承的

协议的基本使用

protocol Action {

var myName:String {

getset

}

var myAge:Int {

get

}

func getMyName()->String

}

class InvokeAction:Action {

var m_name:String =""

var myName:String {

get {

return"CXY"

}

set {

m_name = newValue

}

}

    

var myAge:Int {

get {

return30

}

}

    

func getMyName() ->String {

return"CXY's name"

}

}

协议作为变量使用

var myProtocol:Action =InvokeAction()

协议的继承

protocol ChildAction:Action {

func getMyAge()->Int

}

协议合并

传入一个实现了Action和ChildAction的参数

func hello(s:protocol<Action,ChildAction>) {

/* do something */

}

泛型

函数泛型

func swapValue<T>(inout a:T,inout b:T) {

let temp = a

a = b

b = temp

}

var a = "Hello"

var b = "World"

swapValue(&a, &b)

类泛型

class MyClass<T> {

func printValue(s:T) {

println(s)

}

}

var myClass = MyClass<Int>()

myClass.printValue(12)

最后

这只是Swift最最基础的东西了,简单做下笔记备忘