Swift 2.2 基础笔记

Switf2.2 学习

Swift 是一种新的编程语言，用于编写 iOS，OS X 和 watchOS应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制。Swift 采用安全的编程模式并添加了很多新特性，这将使编程更简单，更灵活，也更有趣。

Switf2.2 学习_01

//  MARK : 常量(let)/变量(var)
let 公司名称 = "AAA";
print(公司名称)
// 公司名称 = "腾讯" error://常量值不可修改

var age = 20
age = 21

// MARK:- 类型判断
公司名称.dynamicType   // String.Type
age.dynamicType      // Int.Type

// MARK:- 类型标注
var width: Float
width = 100.0

// MARK:- 数据基本类型
Int     整形
String  字符串
Float   单精度浮点型
Double  双精度浮点型
BOOL    布尔类型

//初始化一个布尔类型数据
var isLogin: Bool
isLogin = false
isLogin.dynamicType   //Bool.Type

//同理：
var islogin = false
islogin.dynamicType

// 1. 声明一个元组类型(名称、区域、等级、段位)
// 字面量初始化
var 学生信息 = (姓名:"AAA",年龄:20,毕业院校:"中国")
//打印：(.0 "AAA", .1 20, .2 "中国")
学生信息.dynamicType   //(String, Int, String).Type

// 2. 元组类型赋值
//var 英雄联盟信息:(String,String,Int,String)
英雄联盟信息 = ("群魔觉臭","艾欧尼亚",30,"最强王者")
//(.0 "群魔觉臭", .1 "艾欧尼亚", .2 30, .3 "最强王者")

// 3. 访问/修改元组元素
英雄联盟信息.0                 //"群魔觉臭"
英雄联盟信息.1                //"艾欧尼亚"
英雄联盟信息.2                //30
英雄联盟信息.3 = "大师你懂得"  //"大师你懂得"
英雄联盟信息                  //打印(.0 "群魔觉臭", .1 "艾欧尼亚", .2 30, .3 "大师你懂得")

学生信息.姓名
学生信息.年龄
学生信息.毕业院校

// 4. 拆分元组类型
let (角色名称,大区,等级,段位) = 英雄联盟信息
角色名称     //"群魔觉臭"
大区          //"艾欧尼亚"
等级          //30
段位          //"大师你懂得"

//可选类型的值允许为nil
var name_1: String = "Admin"............................//"Admin"
//name_1 = nil //一般数据类型不能为nil
// error: nil cannot be assigned to type 'String'

// 1. 显示可选类型 表示方法 '?': var name: Int?
var name_2: String? = "Admin"............................//"Admin"
//name_2 = nil
print(name_2)............................//"Optional("Admin")\n"
//显示可选类型解析，在选类型的变量后加上'!'
if name_2 != nil{
print(name_2!) ............................//"Admin\n"
}

//可选绑定
//如果可选类型有值，那么久将其值解析出来赋给另一个常量或变量
if let name = name_2 {
print(name)............................//"Admin\n"
}

// 2. 隐式可选类型 表示方法 '!': var name: Int!
var name_3: String! = "Admin"  ............................//"Admin\n"
//name_3 = nil
if name_3 != nil{
print(name_3)  ............................//"Admin"
}

* 总结： 显示可选类型（'?'）与隐式可选类型（'!'）的共同点在于都可将变量置为nil,不同点在于显示可选类型需要使用'!'解析数据，而隐式可选类型无需使用'!'解析数据

typealias HTInt = Int
var  a: HTInt = 10
a.dynamicType     ..............//Int.Type

// 1. 创建一个空的字符串
let str_1: String
var str_2 = ""
var str_3 = String()
======================================================

// 2. 可变/不可变字符串
str_1 = "123"
//str_1 ="789" // let 声明的常量只能被初始化一次
str_2 = "ABCD"
======================================================

// 3.字符串长度 or 是否为空
str_2.characters.count //获取长度
str_2.isEmpty
str_3.isEmpty
======================================================

// 4. 字符串的拼接
str_3 = str_2 + "F"
var str = str_2 + "F"

str.append(Character("G")
str.append(CharacterOf("HIJ")
//str.stringByAppendingString(<aString: String)
//str.stringByAppendingFormat(format: String, arguments: CVarArgType)
======================================================

// 5. 字符串索引
/*
str.characters.count
str.startIndex
str.endIndex
*/
//successor() 当前下标
str.startIndex.successor().successor()

//predecessor() 当前下标 - 1
str.endIndex.predecessor()
======================================================

// 6. 字符串的插入
str.insert("!", atIndex: str.endIndex)
str.insert("@", atIndex: str.endIndex.advancedBy(-8))
str.insertContentsOf("???".characters, at: str.endIndex)
======================================================

// 7. 字符串的截取
var tmp = str.substringToIndex(str.endIndex.advancedBy(-8))
tmp = tmp.substringFromIndex(str.startIndex.successor())

//截取范围
//a...b : [a,b]
//a..<b : [a,b)

let range = tmp.startIndex.successor()...tmp.endIndex.advancedBy(-2)
tmp.substringWithRange(range)
======================================================

//课堂练习:截取身份证的年月日

var IDCard = "510122199123456789"

let rang_1 = IDCard.endIndex.advancedBy(-12)...IDCard.endIndex.advancedBy(-5)
IDCard.substringWithRange(rang_1)

let rang_2 = IDCard.startIndex.advancedBy(6)..<IDCard.endIndex.advancedBy(-4)
IDCard.substringWithRange(rang_2)

======================================================

// 8. 字符串的删除
//tmp.removeRange(<#T##subRange: Range<Index>##Range<Index>#>)
//tmp.removeAtIndex(<#T##i: Index##Index#>)
//tmp.removeAll()
======================================================

// 9. 字符串的比较
// && || !
let account = "admin"
let password = "123"

if account == "admin" && password == "123"{
print("登陆成功！")
}else{
print("登录失败！！")
}

======================================================
// 10. 字符串查询
let net = "www.baidu.com"
//查询是否包含
net.containsString("baidu")
//查询首部
net.hasPrefix("www")
//查询尾部
net.hasSuffix("com")

//传统C语言风格的For循环在Swift 2.2 中已经被遗弃
//计算 0-100 的和

// 1. for-in
var sum = 0
for idx in 0...100{
sum += idx
}
print(sum)
======================================================
// 2. while
sum = 0
var idx = 0
while idx <= 100 {
sum += idx
//Switf 2.2 以后，不能使用'++''--',而是使用'+=''-='
idx += 1
}
sum
======================================================

// 3. repeat...whlie
// do...while 替换成 repeat...whlie

idx = 0
sum = 0
repeat {
sum += idx
idx += 1
}while idx <= 100
sum

let flag = 1
switch flag{
case 1 :
print("星期一")
case 2 :
print("星期二")
case 3 :
print("星期三")
case 4 :
print("星期四")
case 5 :
print("星期五")
case 6,7 :
print("周末")
default :
print("异常信息")
}
======================================================
let  point = (0,10)
//'_'占位符 用户忽略某些特定的内容
switch point{
case (0,0) :
print("在原点")
case (0,_) :
print("在Y轴")
case (_,0) :
print("在X轴")
default :
print("异常信息")

}
======================================================
let 描述 = "四大天王"
switch 描述{
case "四大天王" :
print ("刘德华,张学友,郭富城,黎明")
case "小虎队" :
print ("苏有朋,陈志明,吴奇隆")
case "东北F4" :
print ("小沈阳,宋小宝,赵四,刘能")
default :
print ("异常信息")
}

Switf2.2 学习_02

// func 关键字

// 1、函数形式
func 函数名称(参数) -> 返回值 {
函数体
}
======================================================
// 2、函数示例
// 2.1、无参数无返回值
func sayHello() {
print("Hello!")
}
sayHello()

// 2.2、有参数无返回值
func sayHelloWith(name: String) {
print("Hello, \(name)!")
}
sayHelloWith("Tom")

// 2.3、有参数有返回值
func sumOf(a: Int, b: Int) -> Int {
return a + b
}
sumOf(10, b: 20)
======================================================
// 3、外部参数
// func 函数名(外部参数名 内部参数名:参数类型...)
// 默认情况下，程序会为函数除第一个参数之外的所有参数设置外部参数，外部参数名字和内部参数的名字默认情况下是一致的。
// 设置默认参数只需在参数后面赋值即可，如下面的‘是否加密’参数

func isLogin(账号 account: String, 密码 password: String, 是否加密 isEncryption: Bool = true) -> Bool {
if account == "Admin" && password == "123" {
return true
}else {
return false
}
}

isLogin(账号: "Admin", 密码: "123", 是否加密: true) //.....true
isLogin(账号: "Admin", 密码: "123")     //.....true

// 可通过‘_’忽略外部参数
func maxOf(a: Int, _ b: Int) -> Int {
return a > b ? a : b
}
maxOf(10, 20)

// 4、函数返回值
// 返回元组类型的值（返回多个值）

let nums = [3, 0, 9, 4, 6, 2]

func maxAndMinWith(nums: [Int]) -> (Int, Int) {
var min = nums[0]
var max = nums[0]
for idx in 0..<nums.count {

min = nums[idx] < min ? nums[idx] : min;
max = nums[idx] > max ? nums[idx] : max
}
return (min, max)
}

let (min, max) = maxAndMinWith(nums)
min     // = 0
max     // = 9

// 5、函数类型

// sumOf: (Int, Int)->Int
// maxAndMinWith: ([Int])->(Int, Int)
// sayHello: ()->Void

// 6、函数类型作为函数参数类型

func maxInThreeNum(a: Int, b: Int, c: Int, function: (Int, Int) ->Int) -> Int {
var max = function(a, b)
max = function(max, c)
return max
}

maxInThreeNum(1, b: 7, c: 3, function: maxOf)

// 1、形式：{(参数列表)-> 返回值 in 闭包体}

var sum = {(a: Int, b: Int)->Int in
return a + b
}

sum(10, 20)

// 2、闭包简写形式
// 2.1、省略类型与返回值
sum = {a, b in
return a + b
}
sum(10, 20)

// 2.2、$+下标表示第几个参数；
sum = {
return $0 + $1
}
sum(10, 20)

// 3、案例：通过闭包实现传值
class ViewController {
func viewDidLoad() {

let detailVc = DetailViewController()

detailVc.getInfo { (account, password) in
print("\(account), \(password)")
}
}
}

class DetailViewController {
func getInfo(info: (String, String)->Void) {

info("Admin", "123")
}
}

let vc = ViewController()
vc.viewDidLoad()

// 1、数组声明
var arr_0: Array<Int>
var arr_1: [Int]
var arr_2: [AnyObject]

// 2、创建一个空的数组
var arr_3 = [Int]()
var arr_4 = Array<Int>()

// 3、字面量
var numbers = [1, 2, 3, 4, 5]

// 4、isEmpty、count
numbers.isEmpty
numbers.count

// 5、数组遍历
numbers[0]
numbers[0] = 8

for idx in 0..<numbers.count {
print(numbers[idx])
}

for value in numbers {
print(value)
}

for (idx, value) in numbers.enumerate() {
print("\(idx) = \(value)")
}

// 6、添加/插入元素
numbers.append(6)
numbers.insert(0, atIndex: 0)

// 7、统一修改元素[需要删除对象的下标]
numbers[2...4] = [7, 8, 9]
numbers

numbers[0...2] = [1, 2]
numbers

numbers[3...5] = []
numbers

// 8、数组相加
arr_0 = [1, 2]
arr_1 = [3, 4, 5]

numbers = arr_0 + arr_1
numbers

// 9、移除

//numbers.removeAll()
//numbers.removeLast()
//numbers.removeFirst()
//numbers.removeAtIndex(Int)

// 1、声明
var set_1: Set<String>

// 2、创建一个空的集合
var set_2 = Set<String>()

// 3、字面量初始化
// 在使用字面量初始化集的时候，我们需要为其制定类型（Set）。
var sets: Set = ["刘德华", "郭富城", "黎明", "张学友"]

sets.count
sets.isEmpty

// 4、遍历
for value in sets {
print(value)
}

// 5、contains
sets.contains("刘德华")

// 6、insert
sets.insert("周杰伦")

// 7、remove
sets.remove("刘德华")

===============================
let sets_01: Set = [1, 2, 3, 4]
let sets_02: Set = [2, 3, 4, 5]

// 并集
sets_01.union(sets_02).sort()            // ............[1, 2, 3, 4, 5]
// 交集
sets_01.intersect(sets_02).sort()        // ............[2, 3, 4]
// 补集
sets_01.exclusiveOr(sets_02).sort()      // ............[1, 5]

// 1、声明
var dict_1: [String:String]

// 2、创建空字典
var dict_2 = [String: AnyObject]() //.................[:]

// 3、字面量
var 学生信息 = ["姓名":"小x", "年龄":21, "单位": "XX科技"]

学生信息.count
学生信息.isEmpty

// 4、访问/修改元素
学生信息["姓名"]
学生信息["姓名"] = "卡特琳娜"

学生信息["联系方式"] = 9090980
print(学生信息)

// 5、遍历字典元素
for (key, value) in 学生信息 {
print("\(key):\(value)")
}

[String](学生信息.keys)
[NSObject](学生信息.values)

// 6、删除
学生信息.removeValueForKey("联系方式")

学生信息.updateValue(18, forKey: "年龄")

class Person {
var name: String!
var age: Int!
var IDCard: Int!
var address: String!
}

class Teacher: Person {
var 科目: String!
}

// 创建对象
let tea = Teacher(
// 赋值属性
tea.name = "AAA"
tea.age = 18
tea.科目 = "iOS/ Swift 开发"

// 访问属性
tea.name
tea.age

class Student {
// 给属性添加默认值
var name = ""
var age  = 0

// 实例化方法
func buyWater() {
print("老师，水已经买好了！")
}
// 类方法
class func buyBooks() {
print("老师，书已经买好了！")
}

// 自定义初始化方法
init(name: String, age: Int) {
self.name = name
self.age  = age
}
}

Student.buyBooks()

let stu = Student(name: "Admin", age: 23)
stu.buyWater()
stu.name

Switf2.2 学习_03

enum 方向 {
case 东方
case 南方
case 西方
case 北方
}

enum 四大天王 {
case 刘德华, 郭富城, 张学友, 黎明
}

var 逃亡的方向 = 方向.东方

逃亡的方向 = .南方

switch 逃亡的方向 {
case .南方:
print("南方！")
case .北方:
print("北方！")
case .西方:
print("西方！")
case .东方:
print("东方！")
}

switch 逃亡的方向 {
case .东方:
print("安全！")
default:
print("不安全！")
}

class Person {
var name = ""
var age: Int!

func sayHi() {
print("Hi")
}

// final 关键字可防止重写
final func buySomthing() {

}
}

struct CGPoint {
var x = 0.0
var y = 0.0
}

// 实例化对象
let person = Person()

// 结构体的逐一成员初始化方法
let point  = CGPoint(x: 100, y: 100)

// 访问类或结构体的属性
person.name
point.x

// 结构体是值类型，类是引用类型
// 值类型主要是值的拷贝；
// 引用类型主要是指针的复制；

// 值类型示例
var p1 = point

p1.x
p1.y

p1.x += 10
p1.x

point.x

// 引用类型示例
person.name = "Tom"
person.age  = 22

let per_1 = person

per_1.name
per_1.age

per_1.age = 28

person.age

class Dog {
// 1、存储属性
let id = 0         // 常量存储属性
var name: String!  // 变量存储属性

// 2、延迟存储属性
// 当第一次去访问该属性的时候才会被创建。
lazy var color = "黄色"

// 3、计算属性 setter / getter
var age: Int!

var yearOfBirth: Int {
get {
return 2016 - self.age
}

set {
self.age = 2016 - newValue
}
}

// 只有get方法的属性叫只读属性；
var food: String {
return "狗粮" // 默认Get方法
}
// 4、类型属性：static
static var 编号: Int = 0
}

struct CGSize {
let width  = 120.0
var height = 0.0
static var 编号: Int = 0
}

Dog.编号 = 1001
CGSize.编号 = 1002

let size = CGSize(height: 100.0)

// size.height = 200 // let 声明的结构体变量，即使属性是可变的，也不能被修改。

let dog = Dog()
dog.name = "小黄"
// dog.id   = 1001 // error

dog.age = 3
dog.yearOfBirth

dog.yearOfBirth = 2008
print(dog.age)

class ToolsInClass {

// 实例化方法
func sayHi(name: String) {
print("Hi, \(name).")
}

// 类型方法
class func sayHello() {
print("Hello, world!")
}
}

struct ToolsInStruct {

var x = 0, y = 0

// 如果在结构体方法中，改变自身属性的值，需要在func关键字前添加‘mutating’
mutating func moveByX(x: Int, y: Int) {
self.x += x
self.y += y
}

func sayHi(name: String) {
print("Hi, \(name).")
}
}

let toolInClass = ToolsInClass()
var toolInStruct = ToolsInStruct(x: 10, y: 10)

toolInClass.sayHi("Tom")
toolInStruct.sayHi("Tom")
toolInStruct.moveByX(3, y: 7)
toolInStruct.x
toolInStruct.y

ToolsInClass.sayHello()

func swap(inout a: Int, inout b: Int) {
let tmp = a
a = b
b = tmp
}

var a = 10
var b = 20

swap(&a, b: &b)

a
b

class Student: Person {
override func sayHi() {
print("Hi, Girl!")
}

/*
override buySomthing() {

}
*/
}

let stu = Student()
stu.name = "Petter"
stu.age  = 20
stu.sayHi()

// MARK:- 析构器和构造器

class Tool {

// 属性观察器
var value: Int! {
willSet {
print("将要设置‘value’属性！其值为\(newValue)")
}

didSet {
print("已经设置‘value’属性，设置之前的值为\(oldValue)")
}
}

// 构造器，对象创建时调用；
init() {
print("有一个对象正在创建！")
}
// 析构器，对象销毁时调用；
deinit {
print("有一个对象已经销毁！")
}
}

var tool: Tool! = Tool()

// tool = nil

// MARK:- 扩展

extension Tool {
// 只能扩展计算属性
var code: Int {
get {
return 1001
}
}
func buyBooks() {
print("买书！")
}
}

tool.buyBooks()
tool.code

tool.value = 10
tool.value = 20

protocol 协议名称 {
var money: Int { get set}
func buySomking()
}

class Teacher: Person, 协议名称{

var money: Int {
set {

}
get {
return 100
}
}
func buySomking() {
print("买零食！")
}
}

// 可选协议
@objc protocol 可选协议 {
optional func buyWater()
}
class Cat: 可选协议 {

}