枚举
// swift中的枚举值，描述的不仅仅是无符号整型值，可以是符合swift的各种数据类型，比如字符型，浮点型等等。
enum Season {
case Spring
case Summer
case Autumn
case Winter
}
var s = Season.Spring
print(s)
enum TheEightDiagrams:String {
case 乾 = "天"
case 坤 = "地"
case 巽 = "风"//(xun)
case 震 = "雷"
case 坎 = "水"
case 离 = "火"
case 艮 = "山"//(gen)
case 兑 = "泽"
}
// 可变枚举变量
var diagram = TheEightDiagrams.坤
// 枚举值打印
print(diagram) // 结果：坤
// 枚举值所代表的值
print(diagram.rawValue) // 结果：地
分支结构
// if
if diagram.rawValue == "地" {
print("拣尽寒枝不肯栖，寂寞沙洲冷")
}
let number = 10
if number > 20 {
print("这个数比20大")
}else if number < 15 {
print("这个数比15小")
}else {
print("我也不知道了......")
}
// switch...case
// ①switch观察的量可以是任意类型，包括但不限于数值型
// ②swift中switch语句的特点：默认不贯穿（自带break），要求罗列的每一种情况都要有处理语句，default要书写并做处理。
switch diagram.rawValue {
case "天":
print("天行健，君子以自强不息")
case "地":
print("地势坤，君子以厚德载物")
case "风":
print("风好大")
default:
print("此卦无解......")
}
var rect = (20,30)
switch rect{
case (20,_):
print("case1")
fallthrough // 人为贯穿
case (_,30):
print("case2")
fallthrough
case (_,_):
print("case3")
fallthrough
case (_,40):
print("case4")
fallthrough
default:
print("其他情况")
}
var num = 89757
switch num{
// 在条件语句中，当where后面的语句满足条件时，前面的变量会被定义，并且可以使用(在保持原值不改变的情况下，可以使用新的量来替代原值参与计算)
case var a where num > 4096 :
a += 10
print(a)
fallthrough
default:
print(num)
}
函数
// 1.无参无返回值
func test1()->Void{
print("相顾无言，唯有泪千行")
}
test1()
// 2.无参有返回值
func test2()->String{
return "太上老君急急如律令"
}
print(test2())
// 3.有参无返回值
// nameArray 外部参数：用于告知外界参数描述(可以为汉字)
// names 内部参数：函数内部使用的参数
func test3(nameArray names:Array<String>){
for name in names{
print(name)
}
}
let names = ["鑫","森","淼","焱","垚"]//（miao，yan，yao）
test3(nameArray: names)
// 4.有参有返回值
// 注意，在函数拥有多个参数前提下，从第二个开始，将默认变成外部参数，若想改变这一点，需要使用"_"来修饰以后的参数
func num(num1:Int,_ num2:Int) -> Int{
return num1 * num2
}
print(num(12345679, 8))
// 练习->斐波那契数列：1，1，2，3，5，8，13，21，34，56
func numberFor(需要计算的第几个数 count:Int) -> Int{
if count < 3{
return 1
}else{
return numberFor(需要计算的第几个数: (count - 1)) + numberFor(需要计算的第几个数: (count - 2))
}
}
print(numberFor(需要计算的第几个数: 10))
func arrayFor(斐波那契额数列的个数 count:Int) -> Array<Int>{
var array = Array<Int>()
for i in 1...count{
array.append(numberFor(需要计算的第几个数: i))
}
return array
}
print(arrayFor(斐波那契额数列的个数: 20))
// 有参多个返回值（返回值为元组）
func test4(name:String) -> (name:String,age:Int,score:Float){
return(name:"马泽坤",age:19,score:59.9)
}
print(test4(""))
// 练习 阶乘
func factorial(number n:Int) -> Int{
if n == 1 {
return 1
}else{
return n * factorial(number: n - 1)
}
}
print(factorial(number: 5))
var a = 10, b = 11
// 补存点：
// ①默认内部参数使用let修饰，无法对参数本身进行修改
// ②若需要通过函数来修改外部变量的值，需要使用inout修饰（本质上是量的地址传递）
func exchange(inout a:Int,inout _ b:Int){
var temp = 0
temp = a
a = b
b = temp
}
exchange(&a, &b)
print("a = \(a),b = \(b)")
// 必须有值才能解包，实际开发中写if
// 可选类型，可以不给初始值，但解包才可以获取其表示的值
var x:String?
x = "xxx"
print(x!)
// ！表示强制解包，若值为空时，解包会崩溃，所以必须在确定其有值的前提下解包
// 可选绑定，可以不给初始值，不需要解包，若值为空时，一样会崩溃，所以必须在确定其有值的前提下获取值
var y:String!
y = "yyy"
print(y)
结构体
struct Point{
var x:Float?
var y:Float?
}
var p1 = Point(x:100,y:200)
print(p1.x!)
struct Size {
var width:Float?
var height:Float?
}
struct Frame {
var point:Point?
var size:Size?
// 计算属性
var centerX:Float{
get{
return (point?.x)! + (size?.width)!/2
}
}
}
var frame = Frame(point: Point(x:100,y:100), size:Size(width:100,height:100))
print(frame.centerX)
struct Person {
// 结构体的成员变量（相当于类的实例变量）
var name:String
var age:Int
var gender:String
// 结构体成员变量方法（相当于类的实例方法）
func sayHi(){
print("你好，你见过这么大的月亮么？")
}
// 结构体属性
static var soul:String?
// 结构体方法
static func think(){
print("t将来的你会感谢现在奋斗的自己！")
}
// 计算属性：本身作为一个属性，并无实际意义，但可以进行对成员变量的取值和赋值等操作
var value:String{
// 类似于setter方法
set{
// 给name赋值
name = newValue// 代指外界赋的新值
}
// 类似于getter方法
get{
// 返回name
return name
}
}
}
// 创建结构体变量
var person1 = Person(name: "雷文豪", age: 15, gender:"?")
// 对结构体变量单独赋值
person1.gender = "!"
// 调用实例方法
person1.sayHi()
// 使用计算属性赋值（相当于给name赋值）
person1.value = "岳桂庆"
// 使用计算属性取值（相当于向name取值）
print(person1.value)
// 结构体属性赋值
Person.soul = "如果要求唯有循规蹈矩的、道德上四平八稳的灵魂才能在艺术中表现自己"
// 结构体方法调用
Person.think()
类
class Animal{
// 实例变量
var name:String?
var age:Int?
var gender:String?
// 实例方法
func calculation(){
print("小动物学画画")
}
// 类属性
static var hair:Bool?
// 类方法
// 使用static修饰的类方法，子类不可以重写
// 使用class修饰的类方法，子类可以重写
class func drink(){
print("动物都爱喝好喝的")
}
// 初始化方法（自定义）
// ①当前类为根类时，不需要向super发送消息
// ②默认初始化方法无参数，自定义初始化方法可以自己书写参数，但是两者在书写时都没有返回值
init(name:String,age:Int,gender:String){
self.name = name
self.age = age
self.gender = gender
}
}
class Cat: Animal {
// 子类扩充的实例变量
var color:String?
// 子类的初始化方法
init(name: String, age: Int, gender: String, color: String) {
// 向父类发送消息，让父类初始化公共的实例变量
super.init(name: name, age: age, gender: gender)
// 子类单独初始化独有的实例变量
self.color = color
}
// 覆写父类的方法
// 覆写实例方法
override func calculation() {
super.calculation() // 父类原本的操作
print("这是一只小猫在计算") // 子类添加的操作
}
// 覆写父类方法
override class func drink(){
super.drink() // 父类原本的操作
print("这是一只饥渴的小猫")
}
}
// 创建一个Animal实例
var animal = Animal(name:"折耳猫",age:2,gender:"M")
var _animal = Animal.init(name: "折耳猫", age: 2, gender: "M")
//animal.name = "折耳猫"
//animal.age = 2
//animal.gender = "M"
// 调用实例方法
animal.calculation()
// 类属性赋值
Animal.hair = true
// 调用类方法
Animal.drink()
// 创建一个Cat的实例
var cat = Cat.init(name: "小猫", age: 1, gender: "M", color: "yellow")
print(cat.name!)
// 子类实例可以继承父类的静态方法和动态方法
cat.calculation()
Cat.drink()
值类型
// 1.简单值类型
var num1:Int = 10
var num2 = num1
num2 = 20
print(num1)
// 2.构造值类型
var point1 = Point(x: 20, y: 20)
var point2 = point1
point2 = Point(x: 30, y: 30)
print(point1)
// 引用类型:在进行复制的传递时，为了节省资源，或者保证访问统一资源，指向了同一内存区域（类似于浅拷贝）
var animal1 = Animal.init(name: "蛇", age: 10, gender: "安能辨你是雌雄")
var animal2 = animal1
animal2.name = "猴"
print(animal1.name)
