上一篇文章与大家分享了一些Swift语言最基础的语法入门，今天来继续和大家接着上面的来分享，今天的知识点包括：函数、类、结构体、协议 的一些相关使用。
学习完这些知识点大家基本就掌握了Swift语言中的大部分语法，再了解学习一下Swift在实际开发中的一些应用，以及与OC混编的桥接就基本可以独立写一些小项目来练手了（前提熟悉UIKit下大部分控件的使用）。
下面话不多说还是直接上代码。
//MARK:-----------------函数相关-----------------
//上面这一行代码相当于OC的#pragma mark -
//定义函数
func eat() {
print("eating....")
}
//调用函数
eat()
//定义带有参数和返回值的函数
//func 函数名（参数：参数类型） -> 返回值类型
func run(a: Int, b: Int) -> Int {
return a + b
}
var r = run(10, b: 5)
print(r)
//元组作为函数的返回值
func jump(a: Int ,b: Int) -> (a1: Int, b1: Int) {
return (a * 10, b * 10)
}
var g = jump(2, b: 3)
print(g.b1)
//制作函数的外部参数，作用是提示每个参数的含义
func walk(name param1: String, age param2: Int) {
print("name:\(param1) age:\(param2)")
}
walk(name: "奥特曼", age: 100)
//忽略外部参数
func drink(name param1: String, _ param2: Int) {
print("name:\(param1) age:\(param2)")
}
drink(name: "小怪兽", 200)
//函数默认的参数值
func add(a: Int, b: Int = 25) -> Int {
return a + b
}
print(add(10))
print(add(5, b: 50))
//声明可变参数的函数
func sum(numbers: Int...) -> Int {
var sumst = 0
for i in numbers {
sumst += i
}
return sumst
}
//此函数可以写多个参数
print(sum(1, 2, 3, 5, 10))
//函数的变量参数和常量参数
//任何函数的参数默认都为let类型
func sub(var a: Int, b: Int) -> Int {
//在函数中需要直接修改参数值时，则应该在该参数前添加var
a += b
return a
}
print(sub(10, b: 1))
//函数的输入输出参数 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 is (t1)\nt2 is (t2)")
//函数类型的使用
func addTwoWord(a: Int, b: Int) -> Int {
return a + b
}
func subTwoWord(a: Int, b: Int) -> Int {
return a - b
}
//以上两个函数的函数类型为 (Int, Int) -> Int
//将一个变量的类型定义为一个函数类型，则此变量就可以当做该函数来使用
var ts: (Int, Int) -> Int = addTwoWord
print(ts(10, 20))
//函数类型作为参数使用
func test1(a: (Int, Int) -> Int, b: Int, c: Int) -> Int {
//这里的a就代表了 (Int, Int) -> Int 此类型函数
return a(b, c)
}
print(test1(addTwoWord, b: 10, c: 30))
//函数类型当作返回值
func test2(a: Int, b: Int) -> (Int, Int) -> Int {
if a + b > 10 {
return addTwoWord
} else {
return subTwoWord
}
}
var va = test2(10, b: 20)
print(va(2, 3))
//MARK:-----------------类与结构体的使用-----------------
//定义类
class Student {
//定义属性
var name = ""
var age = 0
//方法
}
//定义结构体
struct ClassNumber {
//定义属性
var myClass = 20
var myGrade = 5
}
//实例化学生类
var student = Student()
//调用学生类中的属性
student.name = "老王"
student.age = 66
print("姓名：(student.name) 年龄：(student.age)")
//实例化班级结构体
var classnumber = ClassNumber()
classnumber.myClass = 100
classnumber.myGrade = 30
print("(classnumber.myClass) (classnumber.myGrade)")
//类和结构体的混合编程
struct Hand {
//为手初始化为0
var numberOfHand = 0
}
class Person {
var name = ""
var age = 0
//当类中包含自定义类型，需要将自定义类型初始化
var hand: Hand = Hand()
}
//创建人类对象
var person = Person()
person.name = "凹凸曼"
person.age = 23
person.hand.numberOfHand = 2
print("具有 (person.hand.numberOfHand) 只手的 (person.name) 年龄是 (person.age)")
//MARK:-----------------逐一构造器的使用-----------------
//�结构体具有逐一构造器，但是类没有，因为结构体属于值类型，类属于引用类型
struct Dog {
var name = ""
var age = 0
//在值类型中定义实例方法，并在实例方法中修改属性
mutating func eat() {
self.name = "xiaowang"
}
}
//通过逐一构造器创建狗对象
var dog = Dog(name: "旺财", age: 5)
//值类型的特点为，当赋值给变量常量或函数时，是通过拷贝的形式进行了赋值
var dog2 = dog
//修改dog的名字
dog.name = "小黑"
print(dog.name)
print(dog2.name)
class Cat {
var name = ""
var age = 0
}
var cat = Cat()
cat.name = "花花"
cat.age = 18
//引用类型给变量常量或函数赋值时，就是做了指针的指向，内存中并没有拷贝
var cat2 = cat
cat2.name = "加菲猫"
print(cat.name)
print(cat2.name)
//恒等运算符 ===，作用为判断两个由类创建的对象是否相等，不能判断结构体的对象是否相等
if cat === cat2 {
print("两个类对象相同")
}
//MARK:--------------------实例方法与类方法---------------------
//实例方法，类方法的特点
class Tiger {
var name = ""
var age = 0
//创建实例方法
func eat() {
print("eat meat...")
//在实例方法中 self 就是当前类的对象
self.name = "跳跳虎"
}
func run(name: String) {
//可以通过self区分属性和形参
self.name = name
}
//声明类方法，可以通过static或class去声明
static func bark() {
print("barking...")
}
}
//调用实例方法
var tiger = Tiger()
//无论调用属性还是实例方法，都是通过 点 去调用
tiger.eat()
print(tiger.name)
//通过类名调用类方法
Tiger.bark()
class Car {
var name = ""
var price = 0.0
//可以通过final 关键字设置该方法不被子类重写
func run() {
print("running...")
}
}
//MARK:-------------------继承---------------------
//通过类的继承，子类可以继承父类的所有属性和方法
//Swift语言中不允许多继承，但是OC，Swift可以多层继承
class DasAuto: Car {
var factory = "长春"
}
//创建DasAuto对象
var das = DasAuto()
das.name = "大众"
das.price = 22.22
das.run()
print("(das.name) (das.price) (das.factory)")
class Golf: DasAuto {
var size = 11
//在子类中重写父类的方法
override func run() {
print("golf running...")
}
}
var golf = Golf()
golf.name = "高尔夫"
golf.run()
print("(golf.name) (golf.size)")
//MARK:----------------------构造函数----------------------
//构造函数的使用
class Bird {
var name = ""
var age = 0
let weight: Double
//创建构造方法
//构造方法的作用为当类被实例化时，第一个调用的方法
//Swift中的构造函数，可以给let赋值
init() {
print("I am a bird")
self.weight = 1.3
}
//带有内部参数的构造方法
init(name: String) {
self.name = name
self.weight = 2.3
}
//带有外部参数的构造方法
init(name param1: String, age param2: Int) {
self.name = param1
self.age = param2
self.weight = 3.3
}
//隐藏外部参数的构造函数
init(_ param1: String, _ param2: Int) {
self.name = param1
self.age = param2
self.weight = 4.4
}
}
//创建鸟的对象
//var bird = Bird()
//var bird = Bird(name: "小怪兽")
//var bird = Bird(name: "小鸟", age: 3)
var bird = Bird("鸟", 2)
print(bird.name)
class FlyBird: Bird {
//在子类中重写父类中的构造方法
override init() {
//调用父类中对应的构造方法，这一步的必须的
super.init()
}
//定义析构函数，当类对象为nil 的时候回调用
deinit {
print("析构函数~~~")
}
}
var flyBird: FlyBird? = FlyBird()
//当flyBird = nil 调用析构函数
flyBird = nil
//MARK:--------------------扩展---------------------
//Swift中的扩展，相当于OC中的类别（类目）
extension Int {
//为Int类型扩展一个属性，求平方
var a: Int {
return self * self
}
}
print(5.a)
extension Bird {
//扩展属性
var birdColor: String {
return self.name + "是白颜色"
}
//扩展方法
func singSong() {
print("\(self.name) 在唱歌")
}
}
//通过扩展向父类中添加的属性、方法也可以传递给子类
var exBird = FlyBird()
exBird.name = "八哥"
exBird.singSong()
print(exBird.birdColor)
//MARK:----------------------协议相关---------------------
//协议的语法
protocol Bark {
//协议中可以定义属性
var name: String {get set}
//协议中也可以定义方法
func barking ()
}
//如果某个类既有父类又要遵守协议，语法为
//class A: 父类，协议1，协议2... {
//}