第二周学习小结
概述：
本周开始系统的对Swift语法部分进行学习。
Swift是面向对象的编程，在我的理解中，面向对象编程就是首先创建一个对象，然后通过向创建的对象发送消息指令来操作对象，使之满足设计所需。在大学曾经学习过一些编程语言，但由于学习时间少，内容少，且学习目的仅是为了应付考试。所以对学习Swift并没有太多的帮助。但是曾经的学习经历让我明白学好编程需要强大的逻辑思维作基础，在编程过程中，很多时候需要你讲自然语言翻译成电脑语言，而为了精简代码，你需要对复杂的自然语言进行提炼重组，尽量让你写出的代码精简高效，具备自然语言所描述的功能且具有高度的逻辑性，这样即达到了预期的效果，又让代码变的美好。下面通过每一天的学习来进行总结。
2016.08.01
1.swift可输入类型
let myName = "龚资深"
let myClass : String
myClass = "Ios1605"
var myAge = 22
let myScore : Double
myScore = 99.5
这里需要说明的是，swift可以输出整型数和浮点型数，以及字符串等，这些都和大多数编程语言类似，但是swift拥有强大的类型推断能力，可以直接赋值，赋值以后该变量的类型久确定。注意所有的字符都要在英文输入法的状态下才可以。
2.swift运算符
按照参与运算的元素来分，可以将swift的运算符分为一元、二元和三元运算符。
print("加法运算结果\(a + b)")
print("\(a) - \(b) = \(a - b)")
print("\(a) * \(b) = \(a * b)")
print("\(a) / \(b) = \(a / b)")
print("\(a) % \(b) = \(a % b)") //求余数
以上是算数运算符
a > b
a < b
a == b
a != b
a >= b
a <= b
以上为关系运算符
if a == b && c == d{
}
else if a == b || e == f
以上是短路运算符。即都成立为真（首行），或一个成立即可。
let c = a < b ? a : b
唯一的三元运算符
问好前面的条件为真，取冒号前面的值，否则取冒号后面的值。注意问好前打空格，否则会被认为是可空类型。
2016.08.02
元组(tuple)
用一个变量或者一个常量就能保存多项数据信息的类型
var stu = (1001, "王大锤", true, 23)
print(stu.0)
print(stu.1)
print(stu.2)
print(stu.3)
let stu: (id: Int, name: String, gender: Bool, age: Int) = (1001, "王大锤", true, 23)
print(stu.id)
print(stu.name)
存储和调用信息
(x,y) = (y,x)
print(x,y)
可以用元组来交换信息
switch选择
switch a{
case 1:
case 2:
default:
}
casei相当于入口，会根据a值的多少进入相应的窗口完成指令。注意，无论什么情况必须有defaule。
2016.08.03
循环结构
本日主要讲解了swift中的循环结构，主要分为三大类，即for循环，while循环和repeat-while循环。
for i in 1..<10{
print("\(i).hello world")
} cewwasz
for _ in 1...10{ //省略了参数
print("hello world")
}
for循环主要针对需要满足一定循环次数的需求，比如很明确的需要尽心多少次循环，需要对某些事物进行便利的时候，其条件布明显则选用for循环
var i = 0
while i < 10{
print("hello world")
i += 1
}
while循环，在满足while后面的条件的情况下就会循环，这种循环结构在条件明确的情况下，可以选用，一直到条件不再成立为止
var i = 0
repeat{
print("hello world")
i += 1
}while i < 10
与while循环不一样的是，无论条件是什么，该循环都会无条件执行一次，然后再判断条件是否还成立，成立的话就继续循环，不成立久终止循环。
2016.08.04
程序就是指令的结合，而再复杂的程序也是基于简单的循环选择分支等结构组成的。老师重点让我们掌握了四个小程序
1.赌博
func roll() -> Int{
return Int(arc4random_uniform(6)) + 1
}
var money = 1000
repeat{
print("玩家总资产：¥\(money)元")
var debt : Int
repeat{
print("请下注:", terminator:" ")
debt = inputInt()
}while debt <= 0 || debt > money
var needsGoOn = false
let firstPoint = roll() + roll()
print("玩家摇出了\(firstPoint)点")
switch firstPoint{
case 7, 11:
money += debt
print("玩家胜")
case 2,3,12:
money -= debt
print("庄家胜")
default:
needsGoOn = true
}
while needsGoOn{
let currentPoint = roll() + roll()
print("玩家摇出了\(currentPoint)点")
if currentPoint == 7{
money -= debt
print("庄家胜")
needsGoOn = false
}
else if currentPoint == firstPoint{
print("玩家胜")
money += debt
needsGoOn = false
}
}
}while money > 0
if money <= 0
{
print("你破产了")
}
在这段程序中，核心的矛盾是，第一次摇出的两个数之和为7和11时，玩家胜利；为2，3，12时庄家胜，若为其他数则继续摇，摇到7时庄家胜，摇到于第一次摇的一样的数时玩家胜。因此我们应该先写出第一次摇的情况。仔细琢磨一下，只是一次分情况的摇，不用循环，且分支结构明显，所以选用switch完成第一次摇的情况，如下：
switch firstPoint{
case 7, 11:
money += debt
print("玩家胜")
case 2,3,12:
money -= debt
print("庄家胜")
default:
needsGoOn = true
}
这里的needgoon是表示，如果第一次摇没有结束游戏，就要进行下一次。注意这是一个条件，且不需要无条件进行第一次，所以选用while来进行接下来的摇数：
while needsGoOn{
let currentPoint = roll() + roll()
print("玩家摇出了\(currentPoint)点")
if currentPoint == 7{
money -= debt
print("庄家胜")
needsGoOn = false
}
else if currentPoint == firstPoint{
print("玩家胜")
money += debt
needsGoOn = false
}
}
先梳理好思路，找到主要矛盾，完成主要的代码部分，再进行修饰，加入赌金本金之类的，就完成了这一段代码
2.猜数字
func roll() -> Int{
return Int(arc4random_uniform(99)) + 1
}
var yournum : Int
let compnum = roll()
repeat{
print("请输入你的数字：")
yournum = inputInt()
if yournum > compnum{
print("little")
}
else if yournum < compnum{
print("more")
}
else{
print("good")
}
}while yournum != compnum
这段代码用了if else的分支结构，主要作用是用于单一方面的条件，成立如何，不成立如何。当然也可以有多个if语句。
2016.08.05
1.数组
var array1 = [Int]()//空数组
var array: [Int] = []//空数组
var array3 = [99, 12, 34, 156, 7]
var array4 = [Int](count: 100, repeatedValue: 1)
var array5 = [String]()
var array6 = [String](count: 4, repeatedValue: "kkk")
var array7 = [";;", "kkk", "djiwodj"]
数组的创建有多种方法，但直接复制法（3）和指定数量（4）用的较多
print(array7.count)
获取数组元素个数
for index in 0..<array7.count{
//[]是对数组进行下标(索引)运算(取出指定位置的元素)
print(array7[index])
if index == 1{
array7[index] = "de"
}
}
//只读循环(每个元素都要遍历，在循环过程中不能修改数组元素)
for str in array7{
print(str)
}
对数组中的元素进行遍历
array1.append(1)
array1.append(3) // 追加，放在前一个的后面
array1.insert(4, atIndex: 0)// 插入，前面是值，后面是位置参数
array1.insert(7, atIndex: array1.count) //插到最后一个
向数组中添加元素
array1.removeAll()
array1.removeAll(keepCapacity: <#T##Bool#>)// true久只删数据，保留空间
array1.removeAtIndex(<#T##index: Int##Int#>) //删指定位置的
array1.removeFirst() //删第一个
array1.removeFirst(<#T##n: Int##Int#>) //删前面n个
删除的方法还有很多，这里是一部分
let array8 = array7 //复制全部
var array9 = array7[1...2] // [1..<2] // 复制一部分
数组的复制
let array10 = array1 + array3
同种类型数组相加,可以合并
数组是对大量数据进行操作的有效方法，通过运用数组和循环选择等结构的组合应用，通过简单的代码完成复杂的问题。
接前一天的四个程序，接下来的两个就摇用到数组
2.冒泡排序
var array = [44, 78, 2, 39, 89, 12, 66]
for j in 0..<array.count - 1{
var stop = false
for i in 0..<array.count - 1 - j{
if array[i] > array[i + 1] {
(array[i], array[i + 1]) = (array[i + 1], array[i])
stop = true
}
}
if !stop{
break
}
}
print(array)
冒泡法排序的核心矛盾是两两比较，将两者中较大的数换到后面去，然后每遍历一次就将一个最大的数放在最后。写stop是当检测到没有交换但循环未完，提前结束循环保证效率。
3.简单选择
var array = [44, 78, 2, 39, 89, 12, 66]
for i in 0..<array.count - 1{
var minIndex = i
for j in i + 1..<array.count{
if array[j] < array[minIndex]{
minIndex = j
}
}
(array[i], array[minIndex]) = (array[minIndex], array[i])
}
print(array)
}
简单选择是首先确定一个存放目标值的变量，这里为minindex，然后初始默认与i代表的数一致，通过j对i以后的数进行遍历，当找到比minindex更小的数以后，讲minindex的值（这里的值表示数组的索引号，初始为i）与j代表的索引号交换，第一次循环完后minindex索引代表的值就是数组的最小值，再遇第一个值交换，然后i＝ i+1，接着继续做同样的事，指示循环次数减少1。
4.百鸡百元
for i in 0...20{
for j in 0...33{
let n = 100 - i - j
if n % 3 == 0 && i * 5 + j * 3 + n / 3 == 100{
print(i,terminator: " ")
print(j,terminator: " ")
print(n)
}
}
}
这是一个穷举法，将所有情况遍历一次，求解。值得注意的是，第三个调节写成循环时，程序会因为不够优化而报错。这也告诉我们要学会优化程序。
网友评论