//
// 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ù)調用
eat()

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

//3.定義一個有參數(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
}
//實現(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ù)
//主要是為了指明每個參數(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ù)的默認參數(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ù)個數(shù)是動態(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ù)
//默認情況下，函數(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關鍵字來定義函數(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
}
//共同特點是：（Int，Int）->Int
//函數(shù)類型作為類型標注使用
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中的閉包是一個自包含的函數(shù)代碼塊猴抹，可以在代碼中進行傳遞和使用，類似OC中的block
閉包可以在捕獲和存儲所在上下文中任意常量和變量的引用锁荔，也就是閉包并且包裹著這些常量和變量蟀给，俗稱閉包，在Swift中阳堕，會自動的管理在捕獲過程中涉及到的所有內存的操作
*/
//1.閉包表達式的語法
// {（參數(shù)：參數(shù)類型...) ->返回值類型 in
// 執(zhí)行語句

//}
//2.sort函數(shù)
//sort函數(shù)是系統(tǒng)提供的一個排序函數(shù)跋理，用于對數(shù)組中的元素進行排序，但是不會修改原來數(shù)組
let names = ["Jack","Rose","Lily","Mark"]
//比較大小
func prepare(para1: String,para2: String) ->Bool
{
return para1 > para2
}
//實質上將自定義的比較函數(shù)整個作為參數(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)可以自動的推斷參數(shù)和返回值的類型
newNames = names.sort({para1,para2 in
return para1 > para2
})
print(newNames)

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

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

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

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

//四肥缔、類和結構體
//1.定義
//類：使用class關鍵字
class Person {
// 定義屬性
var name = ""
var age = 0
}

//結構體：使用struct關鍵字
struct Student {
// 定義屬性
var number = 20
var grade = 5
}

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

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

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

//4.逐一構造器
//結構體具有逐一構造器辫继，但是類沒有，因為結構體是值類型俗慈，類是引用類型

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

//5.值類型
//值類型的特點是：當賦值給變量或者常量或者函數(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 = "金毛"
//當引用類型給變量或者常量或者函數(shù)進行賦值的時候遣耍，只是做了指針的指向闺阱，內存中并沒有拷貝
var dog1 = dog
print(dog1.name)
dog.name = "大黃"
print(dog.name)
print(dog1.name)
/*
類和結構體的相同點和不同點
相同點：
1.定義的方式一樣
2.都有各自的屬性
3.實例化的方式一樣
4.屬性賦值的方式一樣

不同點
1.定義的關鍵字不一樣，類使用class舵变，結構體是struct
2.實例化的時候酣溃，結構體是另外的逐一構造器，但是類沒有
3.結構體是值類型纪隙，類是引用類型

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

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

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

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

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

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