//枚举 函数 结构体 类 协议 代理设计模式 闭包
import Foundation
//枚举 enum
// enum 枚举名：值类型 {
// case 枚举情况 = 初始值
// case 枚举情况 = 初始值
// ...
// 值类型和初始值可以选择是否赋值
//枚举也是一种数据类型，只不过是我们自定义的数据类型
//}
//季节
enum Season:String {
case spring = "春天"
case summer = "夏天"
case autumn = "秋天"
case winter = "冬天"
}
//定义变量常量
let aSeason:Season = Season.spring
//给定数据类型就赋值时就可以省略枚举类型
let aSeason2:Season = .summer
//不给定数据类型，首次赋值一定要给枚举类型
var aSeason3 = Season.summer
aSeason3 = .spring
//获取枚举情况的值
print(aSeason3.rawValue)//rawValue才是真正的枚举值
print(aSeason3.hashValue)//hashValue case的编号从0开始
//枚举经常和switch结合使用
switch aSeason3{
case .spring:
print("春天来了，夏天还会远吗？")
fallthrough //增加case的穿透性 但是只能穿透一条
case .summer:
print("夏天来了，秋天还会远吗？")
fallthrough
case .autumn:
print("秋天来了，收获的季节到了")
fallthrough
//枚举情况没有列举完的default语句必须添加
// 枚举情况都列举完，default语句不需要再写
case .winter:
print("冬天太冷了")
//default:
// print("你是来自火星的吗")
}
//函数：能完成特定功能的代码段 好处：方便调用，保护知识产权 减少代码冗余
////1无参数，无返回值
//2无参数，有返回值
//3有参数，无返回值
//4有参数，有返回值
// 函数定义的格式
/*
func 函数名(参数列表) -> (返回值类型) {
函数体
}
*/
//小王买红酒(没给钱 ，没红酒)
//1无参数，无返回值
//函数的定义
func buyRedwine() -> Void {
print("钱没给不买")
}
//函数的调用
buyRedwine()
//2无参数，有返回值
func buyRedwine2() -> Int {
print("82年的拉菲来一瓶")
return 1
}
//函数的调用
let bottle = buyRedwine2()
print("买了\(bottle)瓶")
//3有参数，无返回值
//没有返回值的时候 ->void可以省略
func buyXuebi(money:Int){
print("\(money)块钱啊！好多呀！跑路呀")
}
buyXuebi(money: 100)
//4有参数，有返回值
func buyXuebei2(money:Int) -> Int {
print("买了\(money / 2)瓶雪碧")
return money / 2
}
let bottle2 = buyXuebei2(money: 5)
print("买了\(bottle2)瓶")
//计算两个数的和
//a，b是形参 oneNumber,otherNumber是外部参数，对形参进行说明的
func sum(oneNumber a:Int, otherNumber b:Int) -> Int {
return a + b
}
//调用时传的的值为实参
print(sum(oneNumber: 10, otherNumber: 20))
//可变参数函数
func qiuHe(numbers:Int...) -> Int {
//传的多个参数存放在numbers形参里了，此时numbers相当一个数组
var result = 0
for item in numbers {
result += item
}
return result
}
print(qiuHe(numbers: 1,2,3,4,5,6,7))
//定义一个函数交换两个变量的值
//Swift 所有的形参默认都是常量，函数内部不能修改形参的值
func swap(num1: inout Int , num2:inout Int) {
let temp = num1
num1 = num2
num2 = temp
}
var a = 10, b = 20
swap(&a, &b)
print("a\(a)" , "b\(b)")
//结构体 用来描述一个有多个属性组成的整体，也是一种自定数据类型
//结构体的定义格式
/*struct 结构体名{
属性列表
方法
}*/
//类的三大特性封装 类型 多态
struct Orgin {
//存储属性
var x:Float
var y:Float
//对象方法
func drawOrign () {
print("在二维坐标系中画一个点")
}
//类方法
static func showPoint(){
print("我是一个点")
}
}
//结构题的使用
let p1 = Orgin(x: 10.2, y: 15.3)
p1.drawOrign()
//使用结构体名调用类方法
Orgin.showPoint()
print(p1.x,p1.y)
//尺寸的结构体
struct Size {
var height:Float
var width:Float
}
let asize = Size(height: 20.0, width: 100.0)
print(asize)
struct Frame {
//结构体的属性依然可以是结构体
var orign:Orgin
var size:Size
//计算属性不是用来给自己赋值的 而是要间接的为其他属性赋值，自己的值只能通过计算获得，不能直接给自己赋值
var center:Orgin {
// 间接为orign属性赋值
set(newCenter) {
orign.x = newCenter.x - size.width * 0.5
orign.y = newCenter.y - size.height * 0.5
}
//间接的获取到自己的值
get {
let x = orign.x + size.width * 0.5
let y = orign.y + size.height * 0.5
return Orgin(x:x,y:y)
}
}
}
var aFrame = Frame(orign: Orgin(x: 10, y: 20), size: Size(height: 50, width: 100))
//取计算属性的值
print(aFrame.center)
//给计算属性赋值，不是给它自己赋值，是间接的为其他属性赋值
aFrame.center = Orgin(x: 50, y: 50)
print(aFrame.orign) //orgin：（0.0，25.0）
