接着昨天的接着写,直接上代码:

var point = (0, 10)
switch point{
case (0, _): //"_"代表可以忽略对应位置的值
    print("在y轴上")
case (_, 0):
    print("在x轴上")
default:
    print("other")
}
//要求枚举的每个值在命名时首字母要大写,且每个值不在隐视转换为0, 1等
enum Day {
    case AM
    case PM
}

let now = Day.AM
switch now {
case .AM :
    print("am")
case .PM :
    print("pm")
}
//函数
//函数的定义形式:
//func 方法名(参数列表)->返回值 {函数体}

//无参数无返回值
func sayHello() {
    print("hello world!")
}
sayHello()

//有参数无返回值
//函数默认第一个参数无标签,当参数为多个的时候,第二个参数开始有标签
func sayHello1(name:String, name1:String) {
    print("hello," + name + name1)
}
sayHello1("玉田", name1: "刘英")
//可以给参数设置一个默认值,当调用该函数时,如果给参数传参,则使用传进来的参数值,如果没有传参,则使用默认值
func sayHello2(name:String = "刘能", name1:String) {
    print("hello," + name + name1)
}
sayHello2("玉田", name1: "刘英")
//可以给参数加一个标签用于提示调用者
func sayHello3(personName1 name1:String, personName2 name2:String) {
    print("hello," + name1 + name2)
}
sayHello3(personName1: "刘英", personName2: "玉田")

//有参数有返回值
func sayHello4(name:String) -> String {
    return "hello," + name
}
sayHello4("赵四")
//多参数(不确定参数个数)
func 求和(numbers:Int...)->Int {
    var sum = 0
    for i in numbers {
        sum += i
    }
    return sum
}

求和(1,2,3)
//如果我们想要改变传过来的参数的值,需要将形参前加, inout关键字修饰
var value = 10
func changeVlue(inout number: Int) {
    number = 11
}
changeVlue(&value)
value
func 返回值元组(name:String, age:Int) -> (String, Int) {
    return (name, age)
}
let 元组 = 返回值元组("玉田", age: 99)
元组.0
//函数的返回值可以是一个函数,并且函数可以嵌套定义,嵌套定义时里层的小函数是有作用域的(外层大函数的范围内)

func 大函数(number:Int) -> (Int)->Int {
    func 小函数(numberSmall: Int)->Int{
        return number + numberSmall
    }
    return 小函数
}
let 得到的函数 = 大函数(1)
得到的函数(2)

//闭包
//闭包的声明:
//   (参数列表) ->返回值
//闭包的定义:
// {(参数列表)->返回值 in 函数体}


func compare(num: Int , array:[Int], 闭包比较:(num1: Int, num2:Int)-> Bool) -> [Int] {
    var arr = [Int]()
    for i in array {
        if 闭包比较(num1:i, num2:num) {
            arr .append(i)
        }
    }
    return arr
}
//完整的闭包定义
compare(3, array: [0, 1, 2, 3, 4, 5, 6],
        闭包比较:{(num1: Int, num2: Int)-> Bool in return num1 > num2} )
//闭包的参数类型可以省略,编译器可以根据我们输入的值结合声明自动识别它的数据类型
compare(3, array: [0, 1, 2, 3, 4, 5, 6],
        闭包比较:{(num1, num2)-> Bool in return num1 > num2} )
//返回值类型也可以省略
compare(3, array: [0, 1, 2, 3, 4, 5, 6],
        闭包比较:{(num1, num2) in return num1 > num2} )
//$0代表传人闭包的第0个参数,$1代表传人的第1个参数
compare(3, array: [0, 1, 2, 3, 4, 5, 6],
        闭包比较:{ return $0 > $1} )
//对于此案例,系统已经预定好了一些比较符号的意义,可以直接使用">"
compare(3, array: [0, 1, 2, 3, 4, 5, 6],
        闭包比较:>)
//推荐的方式
//尾随闭包
compare(3, array: [0, 1, 2, 3, 4, 5, 6])
        {(num1, num2)-> Bool in return num1 > num2
}

//结构体
//swift中的结构体和类特别的相似
//结构体可以向类一样定义构造方法,和自定义方法,甚至可以遵循协议
//不同点:结构体是值类型,类是引用类型;结构体不能被继承;结构体没有析构方法(swift中的析构方法相当于oc里的ARC下dealloc方法,用于销毁资源);
struct point1 {
    var x: Float = 0
    var y: Float = 0
    //构造方法(相当于我们以前的初始化方法)
//    init(myX:Float, myY:Float){
//        x = myX
//        y = myY
//    }
    func hello()  {
        print("hello")
    }
}

var p = point1(x:10, y:10)
p.x
p.hello()

struct Size {
    var width : Float = 0
    var height : Float = 0
    
}
//存储属性:用来存值
//计算属性:涉及到计算过程来获取,或通过计算影响其他值
struct Rect {
    var origin = point1()
    var size = Size(){
        willSet(setSize){
            print(setSize.width)
        }
        didSet{
            print("did")
        }
    }
    var center: point1{
        get{
            let centerX = origin.x + size.width / 2
            let centerY = origin.y + size.height / 2
            return point1(x: centerX, y:centerY)
        }
        set(newCenter){
            origin.x = newCenter.x - size.width / 2
            origin.y = newCenter.y - size.height / 2
        }
    }
    //当我们在结构体中的方法想要修改成员变量的值时,需要使用mutating 关键字(ps:类不需要加, 因为类中的成员变量的意义是对于类内透明的)
    mutating func foo() {
        size = Size(width: 300, height: 300)
    }
    
}

var frame = Rect(origin: point1(x: 100, y: 100), size: Size(width: 100, height: 100))
frame.center.x
frame.size = Size(width: 200, height: 200)
//类

class people {
    var name : String?//如果不使用可选类型的话,要求必须赋初值(ps:在init方法里或者在变量声明处直接赋初始值)
    var age : Int
    init(name:String, age:Int){
        self.name = name
        self.age = age
    }
    //析构方法
    deinit{
        //释放一些资源
    }
    func sayHello() {
        print("hello")
    }
    //类方法
    class func sayBeyBey() {
        print("bey bey")
    }
}

class Student: people {
    var studentNumber:Int?//ps:如果子类的属性没有在声明时赋初值且不是可选类型,在初始化方法里赋值操作要在调用super的init之前
    init(name: String, age: Int, studentNumber:Int){
        self.studentNumber = studentNumber
        super.init(name: name, age: age)
    }
    //重写父类的方法需要前面加override关键字
    override func sayHello() {
        print("hello, my name is " + self.name!)
    }
}

var stu = Student(name: "玉田", age: 99, studentNumber: 911)
stu.sayHello()
//协议

protocol A {
    func foo()
}
class B: Student, A {
    func foo() {
        print("foo")
    }
}

明天会用Swift写一些在项目中的具体用法.