SwiftotherSSwift开发技术收录

Swift 2.2 - 介绍与基础语法

2016-05-14  本文已影响1000人  大L君

Swift 介绍

简介

历史

特点

重要性

资源网站

Swift初体验

常量&变量

什么是常量和变量

变量的基本使用

import UIKit

let a : Int = 10
// 错误写法,当一个字段定义为常量时是不可以修改的
// a = 20

var b : Int = 20
// 因为b定义为变量,因此是可以修改的
b = 30

常量和变量的使用注意:

Swift中数据类型

Swift类型的介绍

Swift中的类型推导

Swift中基本运算

逻辑分支

一. 分支的介绍

二. if分支语句

三. 三目运算符

四.guard的使用

四.switch分支

switch的介绍
switch的简单使用
Switch支持多种数据类型
switch支持区间判断

循环的介绍

for循环的写法

while和do while循环

字符串的介绍

字符的定义

字符串的使用

获取字符串的长度
遍历字符串
    // 字符串遍历
    var str = "Hello, Swift"
    for c in str.characters {
        print(c)
    }
字符串拼接
字符串的截取

数组

数组的介绍

数组的初始化

对数组的基本操作

    // 添加数据
    array.append("yz")
    
    // 删除元素
    array.removeFirst()
    
    // 修改元素
    array[0] = "why"
    
    // 取值
    array[1]

数组的遍历

    // 遍历数组
    for i in 0..<array.count {
        print(array[i])
    }
    
    // forin方式
    for item in array {
        print(item)
    }
    
    // 设置遍历的区间
    for item in array[0..<2] {
        print(item)
    }
    
    // 遍历数组的同时获取下标值
    let names = ["why", "yz", "lnj", "lmj"]
    for (index, name) in names.enumerate() {
        print(index)
        print(name)
    }

数组的合并

    // 数组合并
    // 注意:只有相同类型的数组才能合并
    var array = ["why", "lmj","lnj"]
    var array1 = ["yz", "wsz"]
    var array2 = array + array1;
    
    // 不建议一个数组中存放多种类型的数据
    var array3 = [2, 3, "why"]
    var array4 = ["yz", 23]
    array3 + array4

字典

字典的介绍

字典的初始化

// swift中任意对象,通常不使用NSObject,使用AnyObject
var dict : Dictionary<String, AnyObject>
dict = ["name" : "why", "age" : 18]
​```

字典的基本操作

    // 添加数据
    dict["height"] = 1.88
    dict["weight"] = 70.0
    dict
    
    // 删除字段
    dict.removeValueForKey("height")
    dict
    
    // 修改字典
    dict["name"] = "lmj"
    dict.updateValue("lmj", forKey: "name")
    dict
    
    // 查询字典
    dict["name"]

字典的遍历

    // 遍历字典中所有的值
    for value in dict.values {
        print(value)
    }
    // 遍历字典中所有的键
    for key in dict.keys {
        print(key)
    }
    
    // 遍历所有的键值对
    for (key, value) in dict {
        print(key)
        print(value)
    }

字典的合并

    // 字典的合并
    var dict1 = ["name" : "yz", "age" : 20]
    var dict2 = ["height" : 1.87, "phoneNum" : "+86 110"]
    // 字典不可以相加合并
    for (key, value) in dict1 {
        dict2[key] = value
    }

元组

元组的介绍

元组的定义

元组的简单使用

可选类型

可选类型的介绍

定义可选类型

可选类型的使用

    // 演练一:给可选类型赋值
    // 定义可选类型
    var string : Optional<String> = nil
    
    // 给可选类型赋值
    // 错误写法:因此该可选类型中只能存放字符串
    string = 123
    // 正确写法:
    string = "Hello world"
    
    // 打印结果
    print(string)
    // 结果:Optional("Hello world")\n
    // 因为打印出来的是可选类型,所有会带Optional


    // 演练二:取出可选类型的值
    // 取出可选类型的真实值(解包)
    print(string!)
    // 结果:Hello world\n
    
    // 注意:如果可选类型为nil,强制取出其中的值(解包),会出错
    string = nil
    print(string!) // 报错
    
    // 正确写法:
    if string != nil {
        print(string!)
    }
    
    // 简单写法:为了让在if语句中可以方便使用string
    // 可选绑定
    if let str = string {
        print(str)
    }

真实应用场景

类型转化

常见的类型转化符号

例子

    // 1.定义数组
    let array : [AnyObject] = [12, "why", 1.88]
    
    // 2.取出数组中的第一个元素
    let objc = array.first!
    
    // 3.判断第一个元素是否是一个Int类型
    if objc is Int {
        print("是Int类型")
    } else {
        print("非Int类型")
    }
    
    // 4.将objc转成真正的类型来使用
    // 4.1.as? 将AnyObject转成可选类型,通过判断可选类型是否有值,来决定是否转化成功了
    let age = objc as? Int
    print(age) // 结果:Optional(12)
    
    // 4.2.as! 将AnyObject转成具体的类型,但是注意:如果不是该类型,那么程序会崩溃
    let age1 = objc as! Int
    print(age1) // 结果:12

函数

函数的介绍

常见的函数类型

    // 1.没有参数,没用返回值
    func about() -> Void {
        print("iphone6s plus")
    }
    // 调用函数
    about()
    
    // 简单写法
    // 如果没用返回值,Void可以写成()
    func about1() -> () {
        print("iphone6s plus")
    }
    // 如果没有返回值,后面的内容可以都不写
    func about2() {
        print("iphone6s plus")
    }
    
    about2()
    
    // 2.有参数,没用返回值
    func callPhone(phoneNum : String) {
        print("打电话给\(phoneNum)")
    }
    callPhone("+86 110")
    
    // 3.没用参数,有返回值
    func readMessage() -> String {
        return "吃饭了吗?"
    }
    var str = readMessage()
    print(str)
    
    // 4.有参数,有返回值
    func sum(num1 : Int, num2 : Int) -> Int {
        return num1 + num2
    }
    var result = sum(20, num2: 30)
    print(result)
    
    // 5.有多个返回值的函数
    let nums = [1, 3, 4, 8, 22, 23]
    func getNumCount(nums : [Int]) -> (oddCount : Int, evenCount : Int) {
        var oddCount = 0
        var evenCount = 0
        for num in nums {
            if num % 2 == 0 {
                oddCount++
            } else {
                evenCount++
            }
        }
        return (oddCount, evenCount)
    }
    
    let result = getNumCount(nums)
    result.oddCount
    result.evenCount

函数的使用注意

函数的类型

枚举类型

枚举类型的介绍

枚举类型的定义

给枚举类型赋值

结构体

结构体的介绍

为什么需要结构体?

      let centerX : Double = 100
      let centerY : Double = 100

      func inRange(x : Double, y : Double) -> Bool {
          let disX = x - centerX
          let disY = y - centerX
          
          let dis = sqrt(pow(disX, 2) + pow(disY, 2))
          
          return dis < 200
      }

      let x : Double = 100
      let y : Double = 1000

      inRange(x, y: y)

结构体的增强

Swift中类的使用

主要内容

一. 类的介绍和定义

二. 如何定义类的属性

类的属性介绍
存储属性
计算属性
类属性
监听属性的改变

类的构造函数

构造函数的介绍

构造函数的基本使用

构造函数的基本使用
初始化时给属性赋值
字典转模型(初始化时传入字典)
字典转模型(利用KVC转化)

类的析构函数

析构函数

示例练习

    class Person {
        var name : String
        var age : Int
    
        init(name : String, age : Int) {
            self.name = name
            self.age = age
        }
    
        deinit {
            print("Person-deinit")
        }
    }
    
    var p : Person? = Person(name: "why", age: 18)
    p = nil

自动引用计数

工作机制

循环引用

可选链

可选连的概念

可选链的示例

协议

协议的格式

协议的基本使用

代理设计模式

协议中方法的可选

    // 1.定义协议
    @objc
    protocol SportProtocol {
        func playBasketball()
    
        optional func playFootball()
    }
    
    // 2.遵守协议
    class Person : SportProtocol {
        var name : String?
        var age : Int = 0
    
        // 实现协议中的方法
        @objc func playBasketball() {
            print("人在打篮球")
        }
    }

闭包

闭包的介绍

闭包的使用

block的用法回顾
使用闭包代替block
闭包的简写

闭包的循环引用

懒加载

懒加载的介绍

懒加载的使用

常见注释

单行注释

多行注释

文档注释

分组注释

访问权限

swift中的访问权限

异常处理

异常的介绍

异常的示例

Swift和OC相互调⽤用

Swift调⽤用OC

  1. 创建桥接⽂文件—> .h
  2. 在桥接⽂文件中导⼊入头⽂文件
  3. 配置桥接⽂文件: 项目->buildSettings —> bridging —> 配置

OC调⽤用Swift

上一篇下一篇

猜你喜欢

热点阅读