ios开发-Swift快速入门

普通变量

var i = 100
var i:Int = 100
var i:String = "hello"
let c=i+i //c不能改变

可选类型

//可选类型 任何已知类型后面紧跟？ 即可代表 可选类型 如 Int？
var str = “Hello”
var num:Int? = str.toInt()  //nil 表示 值缺失

//强制解析：在变量或者常量后面添加 ！  注意：必须可选类型的变量和常量缺失油脂的时候才解析成功
var num1: Int? = 10
var num2: Int? = 20
if num1 != nil && num2 != nil{
let sum = num1! + num2!
}else{
print(“num1 或者 num2 为 nil ，不能强制解析")
}

//可选绑定：可以用在 if 和 while 语句中来对可选类型的值进行判断并把值赋给一个常量或者变量
var str3: String! = “SWIFT”
if var tmp = str3{

}else{
//str3的值为nil 不能解析
}

//隐式解析可选类型 ： 在已有类型后添加! 如 Int！ 适用于被赋值之后不会重新变为nil的变量
var possibleStr: String! = “aaa”
print(possibleStr)

字符串链接

var a = "sat"
var b = "we"
var c = a+b
c="\(a)\(b)"

数组定义

var arr = [12,34,"hello",str]
var arr = String[]()
var arr:[Any] = [“sw”,12,[“ios”:23],Fruit(name:”aaa”)]
var arr:[Any] = [Fruit(name:”bbb"),Fruit(name:”aaa")]

dictionary 字典

var dict = ["name":”lalal","age":"16"]
dict["sex"]="Female"
print(dict)
print(dict["name"])

for&while循环

var arr = String[]()

for index in 0..100{
arr.append("Item\(index)")
}
print(arr) //0-99

for value in arr{
print(value)
}

for (key,value) in dict{
print("\(key),\(value)")
}

var i = 0
while i<arr.count{
print(arr[i])
i++
}

条件流程

var arr = String[]()

for index in 0..100{
arr.append("Item\(index)")
}
print(arr) //0-99

for value in arr{
print(value)
}

for (key,value) in dict{
print("\(key),\(value)")
}

var i = 0
while i<arr.count{
print(arr[i])
i++
}

函数

func sayHello(name:String){
print(name)
}

sayHello("play")

var fun = sayHello
fun("Zzz")

//->()设置返回值
func getNums()->(Int,Int){
return (2,3)
}
let(a,b ) = getNums()

//可变参数：在参数类型后面添加 … 表示该参数可以接受多个参数值
func sum(numbers: Int…) -> Int{
var total: Int = 0
for num in numbers{
total += num
}
print(total)
return total
}

//In-Out 形参
func swap(inout a: Int , inout b: Int){
let tmp = a
a = b
b = tmp
}
var a:Int = 1
var b:Int = 3
swap(&a,&b)

////函数作为参数形式
func multiplyTwoIns(a: Int, b: Int) -> Int{
return a*b
}
//var math: (Int, Int) -> Int = multiplyTwoIns
func printRES(math: (Int,Int) -> Int, a:Int,b:Int){
print(math(a,b))
}
printRES(multiplyTwoIns,3,5)

////函数作为返回值类型
func squre(num: Int)-> Int{
return num*num
}
func cube(num: Int)-> Int{
return num
}
func getMathFunc(#type: String) -> (Int) -> Int{
switch(type){
case "squre":
return squre
default:
return cube
}
}

var mathFunc = getMatrhFunc(type:"other")
print(mathFunc(5))

嵌套与闭包

//嵌套
func getMathFunc(#type: String) -> (Int) -> Int{
func squre(num: Int)-> Int{
return num*num
}
func cube(num: Int)-> Int{
return num
}
switch(type){
case "squre":
return squre
default:
return cube
}
}

var mathFunc = getMatrhFunc(type:"other")
print(mathFunc(5))

//闭包  { (形参列表) -> 返回值类型 in 可执行表达式 }
func getMathFunc(#type: String) -> (Int) -> Int{
switch(type){
case "squre":
return {(num: Int) -> Int in
return num*num
}
default:
return {(num: Int) -> Int in
return num*num*num
}
}
}

var mathFunc = getMatrhFunc(type:"other")
print(mathFunc(5))

//////利用上下文推断
var squre: (Int) -> Int = {(num) in return num*num}
var squre: (Int) -> Int = {num in return num*num}

//省略形参名，通过$0,$1 ...来引用第一个、第二个参数
var squre: (Int) -> Int = {$0*$0}
print(squre(3))

//尾随闭包
var result: Int = {
var result = 1
for i in 1…$1{
result *= $0
}
return result
}(4,3)
print(result)

function someFunction(num: Int , fn:(Int) -> ()){

}
someFunction(20,{})
//使用尾随闭包调用函数的格式
someFunction(20){}

枚举

enum Season{
case spring = 1，Summer,Fall,Winter
}
var weather:Season
//weather = Season.Summer
weather = .Summer
print(Season.spring.rawValue)

//原始值
/*
enum 枚举名：原始值类型{
case 枚举值 = 原始值
}
*/

var play:[Pler]

//关联值
enum Planet{
case Earth(weight: Double , name: String)
case Mars(den: Double, name: String,weight:Double)
}
var p1 = Planet.Earth(weight: 1.0,name:”diqiu”)
var p2 = Planet.Mars(3.95,”jingxing”,1.0)

switch(p2){
//将关联值绑定到变量或者常量来提取
case Planet.Earth(var weight, var name):
print(weight)
case let Planet.Mars(den: d, name:b,weight:w):
print(d)
}

面对对象

class Hi{
func say(){
print("Hi")
}
final play(){} //不能被继承
}
var hi=Hi()
hi.say()

class Hello:Hi{
var _name:String

//构造
init(name:String){
self._name = name
}

//重写
override func say(){
print(self.name)
}
//方法内参数出第一个默认为外部参数名 需要在参数名前加 _ 来取消
func eat(参数){

}

//类方法
class func wwat(){

}
}
var h = Hello(name:"AAA")
h.say()

//结构体
struct JKReact{
//mutating func …… 为可变方法 可以更改实例化的存储属性
mutating func moveByX(){

}
}

//多态
向上转型
父类调用子类的构造方法 可调用其他方法为父类的方法、子类重写的方法

向下转型运算符
1> as： 强制将运算符前面的引用变量转换为后面的类型
2> as? 可选形式的向下转换

（向下转换只能在具有继承关系的两个类型之间进行）

计算属性

class User{
var first: String = ""
var last: String = ""

//定义计算属性
var fullName: String{
//定义计算属性的getter方法，该方法的返回值由first、last两个存储属性决定
get{
return first +”-“+ last
}
//定义计算属性的setter方法，该setter方法将负责改变该实例的first、last两个存储属性
set(newValue){
var names = newValue.componentsSeparatedByString("-“)
self.first = names[0]
self.last = names[1]
}
}
init(first: String , last: String){
self.first = first
self.last = last
}
}

let s = User(first:"geek",last:"hello")
print(s.fullName) //调用get方法
s.fullName = “geek-aa” //调用set方法

属性观察者

//willSet(newValue) 被观察的属性即将被复制之前自动调用的方法
//didSet(oldV
4000
alue) 被观察的属性被复制完成之后自动调用的方法
class Person{
//存储属性
var name: String = "" {
willSet{
if(countElements(newValue)>6) || (countElements(newValue)<2)
{
print(\(newValue))
}
else{
print(“人名不符合要求，设置成功")
}
}
didSet{
print(“人名设置符合要求，设置成功")
}
}
}
var p =Person()
p.name=“aaa"

下标

struct JK{
var x: Int
subscript(index: Int) -> Int{
get{
switch(index){
case 0:
return self.x
}
}
set{
switch(index){
case 0:
self.x = newValue
}
}
}
}

var rect = JK(x:20)
rect[0]=20

可选链
1.使用可选链访问方式：将强制解析的感叹号换成？ ， 在隐式解析的后面也添加 ？ 后缀

2.可选链会自动判断程序访问的关联实例是否为nil

类型属性

static 定义枚举的类型存储属性、计算属性、类型方法，使用可选类型，系统将其初始化为nil
static var desc : String?
static var maxArea: Int{
get{} set{}
}
static func ser(){}
class 定义类的类型计算属性、类型方法
class var desc : String{
set{} get{}
}
class func abs(){}

嵌套类型

//在类型内部嵌套类型
class User{
var holidays:[Weekday]
var location:Point
init(holidays:[Weekday],location:Point){
self.holidays = holidays
self.location = location
}
struct Point{
var latitude: Double
var longitude: Double
var position: Orirntation
enum Orientation{
case Up,Left,Bottom,Right
}
}
enum Weekday{
case Monday,Tuesday
}
}

拓展

[修饰符]extension 已有类型{
//添加新功能
}
修饰符可以省略，或者是private、internal、public其中之一，类型可以是枚举、结构体和类其中之一

extension String{
static var data:[String:Any] = [:]

var length: Int{
get{}
set{}
}

func substringFromStart(start: Int,toEnd: Int) -> String{
……
}

static func valueOf(value:Bool) -> String {
return "\(value)"
}
}
String.data["swift"] = 89
var str = "a"
str.length = 5
var subStr = str.substringFromStart(5,toEnd:10)
String.value(true)

//拓展可以增加构造器
//枚举拓展

协议 （类似接口）

语法格式：
[修饰符] protocol 协议名:父协议1，父协议2，...{
//协议内容
}
修饰符：可以省略，也可以是private/internal/public之一
协议只能继承协议 不能继承类

Struct结构体名:第一个协议,第二个协议,...{
//实现协议要求
}

Class 类名:SuperClass(父类),第一个协议,第二个协议,...{

}