//
// main.swift
// Swift-SeniorGrammar
//
// Created by qianfeng on 16/7/8.
// Copyright ? 2016年 SharkTop. All rights reserved.
//

import Foundation

print("Hello, World!")

//一、函數(shù)
//1.定義函數(shù)
//無參無返回值的函數(shù)
func eat(){
print("eating")
}
//函數(shù)調(diào)用
eat()

//2.定義一個(gè)有參數(shù)無返回值的函數(shù)
//func 函數(shù)名（函數(shù)名稱:參數(shù)類型。。。）
func drink(a: Int,b: Int){
print(a+b)
}
drink(2, b: 2)

//3.定義一個(gè)有參數(shù)和返回值的函數(shù)
//func 函數(shù)名 （參數(shù)名稱：參數(shù)類型。。。）->返回值類型
func relax(a: Int, b: Int) ->Int{
return a - b
}
var result1 = relax(30, b: 20)
print(result1)

//4.可以讓元組作為函數(shù)的返回值
func run(a: Int,b: Int) ->(a1:Int,b1:Int){
return (a * 10,b * 10)
}
var r = run(10, b: 20)
print(r)
print(r.a1)
print(r.b1)

//5.多參量函數(shù)
//函數(shù)可以有多種不同類型的參數(shù)
//函數(shù)一
func greet(personName: String) ->String{
return "hello" + personName
}
//函數(shù)二
func greetAgain(personName: String) ->String{
return "hello again" + personName
}
//實(shí)現(xiàn)多參量函數(shù)
func sayHello(personName: String,alreadyGreet:Bool) ->String{
if alreadyGreet{
return greetAgain(personName)
}else{
return greet(personName)
}
}

print(sayHello("尼古拉斯趙四", alreadyGreet: true))

//6.函數(shù)的外部參數(shù)
//主要是為了指明每個(gè)參數(shù)所代表的意義
func login(userName para1: String,password para2: String){
print("用戶名是(para1) ,密碼是(para2)")
}
login(userName: "xiaohong", password: "123456")

//忽略參數(shù)
func jump(para1: String,_ para2: String){
print("(para1),(para2)")
}
jump("123", "456")

//7.函數(shù)的默認(rèn)參數(shù)值
func fly(a: Int,b: Int = 10) ->Int{
return a * b
}
var f = fly(20)
var f1 = fly(10, b: 30)
print(f1)

//8.定義可變參數(shù)的函數(shù)（通過...使得函數(shù)的參數(shù)個(gè)數(shù)是動(dòng)態(tài)的）
func sum(numbers: Int...) ->Int{
var result = 0
for i in numbers{
result += i
}
return result
}
var sumResult = sum(1,3,5,6,7)
print(sumResult)

//9.函數(shù)的常量參數(shù)和變量參數(shù)
//默認(rèn)情況下，函數(shù)的參數(shù)都是let類型的
func swim(var a: Int,b: Int) ->Int{
a = a + 10
return a
}

var s = swim(10, b: 0);
print(s)

//10.函數(shù)的輸入輸出參數(shù)
//使用inout關(guān)鍵字來定義函數(shù)的輸入輸出參數(shù)，只有變量才能作為函數(shù)的輸入輸出參數(shù)
func change(inout a: Int,inout b: Int){
let temp = a
a = b
b = temp
}
var c1 = 10
var c2 = 15
change(&c1, b: &c2)
print("c1 is (c1),c2 is (c2)")

//11.函數(shù)類型的使用
//加法
func add(a:Int, b:Int) ->Int{
return a + b
}
//減法
func sub(a: Int,b: Int) ->Int{
return a - b
}
//共同特點(diǎn)是：（Int，Int）->Int
//函數(shù)類型作為類型標(biāo)注使用
var res1: (Int,Int) ->Int = add
var finalResa = res1(2,3)
print(finalResa)

//函數(shù)類型作為參數(shù)類型
func hehe(a: (Int,Int) ->Int,b: Int,c: Int) ->Int{
return a(b,c)
}
var h = hehe(sub, b: 10, c: 30)
print(h)

//函數(shù)類型可以作為函數(shù)返回類型
func test(a: Int,b: Int) ->(Int,Int) ->Int{
if a + b > 10{
return sub
}else{
return add
}
}
var t = test(5, b: 7)
print(t(100,200))

//二、閉包
/*
Swift中的閉包是一個(gè)自包含的函數(shù)代碼塊，可以在代碼中進(jìn)行傳遞和使用，類似OC中的block
閉包可以在捕獲和存儲所在上下文中任意常量和變量的引用，也就是閉包并且包裹著這些常量和變量，俗稱閉包，在Swift中，會自動(dòng)的管理在捕獲過程中涉及到的所有內(nèi)存的操作
*/
//1.閉包表達(dá)式的語法
// {（參數(shù)：參數(shù)類型...) ->返回值類型 in
// 執(zhí)行語句

//}
//2.sort函數(shù)
//sort函數(shù)是系統(tǒng)提供的一個(gè)排序函數(shù)，用于對數(shù)組中的元素進(jìn)行排序，但是不會修改原來數(shù)組
let names = ["Jack","Rose","Lily","Mark"]
//比較大小
func prepare(para1: String,para2: String) ->Bool
{
return para1 > para2
}
//實(shí)質(zhì)上將自定義的比較函數(shù)整個(gè)作為參數(shù)傳給了sort函數(shù)
var newNames = names.sort(prepare)
print(newNames)

//3.使用閉包的語法
newNames = names.sort(
{
(para1: String,para2: String) ->Bool in
return para1 > para2
})
print(newNames)

//4.根據(jù)上下文推斷類型
//在Swift中，系統(tǒng)可以自動(dòng)的推斷參數(shù)和返回值的類型
newNames = names.sort({para1,para2 in
return para1 > para2
})
print(newNames)

//5.單表達(dá)式閉包隱式返回
//單行表達(dá)式閉包可以通過隱藏return關(guān)鍵字來達(dá)到隱式返回的目的
newNames = names.sort({para1,para2 in
para1 > para2
})
print(newNames)
//尾隨閉包

//三、枚舉
/*
在C語言中，枚舉將枚舉名和一個(gè)整型值相對應(yīng)。但是，在Swift中，枚舉變得更加靈活，枚舉名不再只跟整型值相對應(yīng)，我們也不必給每個(gè)枚舉名提供一個(gè)值，如果有值，則值的類型很可能字符串，字符，整型或者浮點(diǎn)型
/
//1.定義一個(gè)枚舉
//使用enum關(guān)鍵字
enum Direction {
// 枚舉成員值
// case關(guān)鍵字表明新的一行成員值將被定義
case west
case east
case north
case south
}
//多個(gè)成員值可以定義在同一條語句中，用逗號隔開
enum Animal {
case dog,pig,cat,elephant
}
/
注意：
1.與c和oc不同的是，Swift中枚舉成員在被創(chuàng)建的時(shí)候不會被賦予一個(gè)默認(rèn)的整型值
2.枚舉名的第一個(gè)字母必須要大寫，以及后面的類和結(jié)構(gòu)體都是同樣的要求，函數(shù)的命名以小寫字母開頭
*/

//2.使用枚舉值
var direction = Direction.east
//枚舉在被初次初始化之后，獲取另外的值時(shí)可以直接使用（.）來調(diào)用
direction = .south
print(direction)

//3.匹配枚舉值和switch語句
switch direction{
case .north:
print("north")
case .west:
print("west")
case .east:
print("east")
case .south:
print("south")
}

//四、類和結(jié)構(gòu)體
//1.定義
//類：使用class關(guān)鍵字
class Person {
// 定義屬性
var name = ""
var age = 0
}

//結(jié)構(gòu)體：使用struct關(guān)鍵字
struct Student {
// 定義屬性
var number = 20
var grade = 5
}

//2.實(shí)例化
//Person類
var per = Person()
//給類的屬性賦值
per.name = "懶羊羊"
per.age = 4
print("姓名:(per.name) , 年齡:(per.age)歲")

//Student結(jié)構(gòu)體
var stu = Student()
stu.grade = 7
stu.number = 60
print("年級:(stu.grade)年級 ,人數(shù):(stu.number)人")

//3.類和結(jié)構(gòu)體的混合編程
struct Orange {
var number = 0
}
class Child {
var name = ""
var age = 0
// 將結(jié)構(gòu)體作為類型標(biāo)注，當(dāng)類中包含自定義類型時(shí)，需要將包含定義類型初始化
var oranges:Orange = Orange()
}
//實(shí)例化Child
var child = Child()
//屬性設(shè)置
child.name = "喜羊羊"
child.age = 4
child.oranges.number = 5
print("小??叫(child.name)今年(child.age)歲有(child.oranges.number)個(gè)橘子")

//4.逐一構(gòu)造器
//結(jié)構(gòu)體具有逐一構(gòu)造器，但是類沒有，因?yàn)榻Y(jié)構(gòu)體是值類型，類是引用類型

struct Cat {
var name = ""
var age = 0
}
//逐一構(gòu)造器：在實(shí)例化結(jié)構(gòu)體的同時(shí)對屬性進(jìn)行賦值
var cat = Cat(name: "金吉拉", age: 3)

//5.值類型
//值類型的特點(diǎn)是：當(dāng)賦值給變量或者常量或者函數(shù)時(shí)，是通過拷貝的形式
var cat1 = cat
print(cat1.name)
cat.name = "小怪"
print(cat.name)
print(cat1.name)

//6.引用類型
//類是引用類型
class Dog {
var name = ""
var age = 0
}
var dog = Dog()
dog.name = "金毛"
//當(dāng)引用類型給變量或者常量或者函數(shù)進(jìn)行賦值的時(shí)候，只是做了指針的指向，內(nèi)存中并沒有拷貝
var dog1 = dog
print(dog1.name)
dog.name = "大黃"
print(dog.name)
print(dog1.name)
/*
類和結(jié)構(gòu)體的相同點(diǎn)和不同點(diǎn)
相同點(diǎn)：
1.定義的方式一樣
2.都有各自的屬性
3.實(shí)例化的方式一樣
4.屬性賦值的方式一樣

不同點(diǎn)
1.定義的關(guān)鍵字不一樣，類使用class，結(jié)構(gòu)體是struct
2.實(shí)例化的時(shí)候，結(jié)構(gòu)體是另外的逐一構(gòu)造器，但是類沒有
3.結(jié)構(gòu)體是值類型，類是引用類型

聯(lián)系：可以將結(jié)構(gòu)體作為類型標(biāo)注在類中使用
*/
//7.實(shí)例方法和類方法的使用
class Tiger {
var name = ""
var age = 0
// 創(chuàng)建實(shí)例方法
func eat() {
print("practice makes perfect")

// 在實(shí)例方法中self表示的就是當(dāng)前類的對象
self.name = "tiger"
print(self.name)
}
// self還可以用來區(qū)分屬性和形參
func run(name:String){
self.name = name
}
// 創(chuàng)建類方法，可以通過static或者class關(guān)鍵字來標(biāo)明
// 在實(shí)例方法前面加上static或者class關(guān)鍵字就成了一個(gè)類方法
static func bark() {
print("barking")
}
}
//調(diào)用類方法和實(shí)例方法
//實(shí)例化
var tiger = Tiger()
//調(diào)用實(shí)例方法：通過對象調(diào)用
tiger.run("tiger")
tiger.eat()
//調(diào)用類方法：通過類名直接調(diào)用
Tiger.bark()
/*
類方法和實(shí)例方法的相同點(diǎn)和不同點(diǎn)
相同點(diǎn)
1.實(shí)質(zhì)上都是函數(shù)
2.都可以對類的屬性進(jìn)行修改
不同點(diǎn)
1.類方法需要用static或者class關(guān)鍵字進(jìn)行標(biāo)明，實(shí)例方法不需要
2.在調(diào)用的時(shí)候，實(shí)例方法只能通過類的對象來調(diào)用，類方法是通過類名直接調(diào)用
*/

//8.在值類型（結(jié)構(gòu)體）中修改屬性
struct Student1 {
// 定義屬性
var number = 100
var grade = 3
// 在值類型中定義實(shí)例方法，并在實(shí)例方法中修改結(jié)構(gòu)體屬性的話需要使用關(guān)鍵字mutating
mutating func study() {
self.number = 60
print("班級人數(shù)：(self.number)")
}
// 在實(shí)例方法中，可以直接對self進(jìn)行修改
mutating func play() {
// 使用逐一構(gòu)造器
self = Student1(number: 30, grade: 8)
print("學(xué)生人數(shù)：(self.number) 年級：(self.grade)")
}
}
var stu1 = Student1()
stu1.play()
stu1.study()

//9.類的繼承
class Car {
var carName = ""
var price = 0.0
// 可以在父類的實(shí)例方法中添加final關(guān)鍵字設(shè)置此方法不被子類重寫
func run() {
print("奔跑吧，皮卡丘")
}
}

//通過類的繼承，子類可以繼承父類所有的方法和屬性
//和OC一樣，Swift中不允許多繼承
class AutoCar:Car {
// 給子類添加新的屬性
var factory = "山東藍(lán)翔"
}
var autoCar = AutoCar()
autoCar.carName = "蘭博基尼"
autoCar.price = 1.0
autoCar.run()

class Bicycle: Car {
// 如果要在子類中重寫父類的方法，需要用override關(guān)鍵字進(jìn)行標(biāo)明
override func run(){
print("奔跑吧，兄弟")
}
}