import Foundation
print("Hello, World!")
// 定义函数(无返回值类型，无参数的eat函数)
func eat() {
print("eating...")
}
// 调用函数
eat()
// 定义带有参数和返回值的函数
// func 函数名（参数：参数类型） -> 返回值类型
func run(a: Int, b:Int) -> Int {
return a + b
}
var r = run(4,b:5)
print(r)
// 元组作为函数的返回值
func jump(a: Int, b:Int) -> (a1: Int, b1:Int) {
return (a *10, b * 10)
}
var g = jump(10, b:20)
print(jump(3, b:6))
print(g)
print(g.a1)
// 制作函数的外部参数，作用为提示每个参数的含义 （param1为参数名）
func walk(name param1: String, age param2: Int) {
print("name\(param1) , age\(param2)")
}
walk(name: "张第", age:24)
// 忽略外部参数
func drink(name param1: String, _ param2:Int) {
print("我叫\(param1)今年 \(param2)了")
}
drink(name: "李四",25)
// 函数默认参数值
func add(a: Int, b:Int = 26) ->Int {
return a + b
}
print(add(10))
print(add(10, b:35))
// 函数可变参数（参数个数为未知）
func go(numbers: Int...) ->Int{
var sumst =0
for iin numbers {
sumst += i
}
return sumst
}
print("和为\(go(1,2,3,4,5))")
// 函数的变量参数和常量参数,
// 任何函数的参数默认都为 let类型
func sub(var a:Int,var b:Int) -> Int {
// 在函数中，需要直接修改参数值时，则应该在该参数前添加 var
a = a + 10 ; b = b +10
return a + b
}
print(sub(10, b:10))
// 函数的输入输出参数 inout
func changeTwoWord(inout a:Int,inout b:Int) {
// 在 swift函数中，如果声明的tmp不需要参与运算或改变时，一般都会声明常量 let
let tmp = a
a = b
b = tmp
}
var t1 = 10;var t2 = 20
changeTwoWord(&t1, b: &t2)
print(t1,t2)
// 函数类型的使用
func addTwoWord(a: Int, b: Int) ->Int {
return a + b
}
func sunTwoWord(a: Int, b: Int) ->Int {
return a - b
}
// 以上两个函数的函数类型个为（Int, Int）-> Int
var ts: (Int,Int) -> Int =addTwoWord
var tsw: (Int,Int) -> Int =sunTwoWord
print(ts(10,20))
print(tsw(3,2))
// 函数类型作为参数(类型)使用
func test1(a: (Int,Int) -> Int, b:Int, c: Int) ->Int{
return a(b,c)
}
print(test1(addTwoWord, b:5, c: 6))
// 函数类型当做返回值(类型)来使用
func test2(a: Int, b:Int) -> (Int,Int) -> Int {
if a + b >10 {
returnaddTwoWord
} else {
returnsunTwoWord
}
}
var vas = test2(6, b:6)
print(vas(2,3))
// 定义类首字母要大写
class Student {
// 定义属性 name/age
var name =""
var age =0
// 方法读书、吃饭的方法
}
// 定义结构体首字母大写
struct ClassNumber {
// 定义属性年级 、班级
var myClass =30
var myGrade =5
// 方法
}
// 实例化学生（类） 班级（结构体）
var student = Student()
var classnumber = ClassNumber()
// 调用学生类中的属性
student.name ="李磊"
student.age =23
classnumber.myClass =1572
classnumber.myGrade =1
print("姓名\(student.name),年龄\(student.age)")
print("年级：\(classnumber.myGrade)班级：\(classnumber.myClass)")
// 在 Swift中，类和结构体的混合编程
struct Hand {
// 为手初始化为0
var numberOfHand =0
}
class Person {
var name =""
var age =0
// 当类中包含自定义类型，需要将自定义类型初始化如下：
var hand:Hand = Hand()
}
//创建人类对象
var person = Person()
person.name ="哈哈"
person.age =28
person.hand.numberOfHand =2
print("具有\(person.hand.numberOfHand)只手的 \(person.name)今年 \(person.age)岁了")
// 结构体具有逐一构造器，但是类没有,因为结构体属于值 类型，类属于引用 类型
struct Dog {
var name =""
var age =0
// 在值 类型中定义实例方法，并在实例方法中修改属性 在前面加上关键字 mutating
func eat() {
print("