Swift笔记

//
// main.swift
// Swift-SeniorGrammar
//
// Created by qianfeng on 16/7/8.
// Copyright © 2016年 SharkTop. All rights reserved.
//

import Foundation

print("Hello, World!")

//一、函数
//1.定义函数
//无参无返回值的函数
func eat(){
print("eating")
}
//函数调用
eat()

//2.定义一个有参数无返回值的函数
//func 函数名（函数名称:参数类型。。。）
func drink(a: Int,b: Int){
print(a+b)
}
drink(2, b: 2)

//3.定义一个有参数和返回值的函数
//func 函数名 （参数名称：参数类型。。。）->返回值类型
func relax(a: Int, b: Int) ->Int{
return a - b
}
var result1 = relax(30, b: 20)
print(result1)

//4.可以让元组作为函数的返回值
func run(a: Int,b: Int) ->(a1:Int,b1:Int){
return (a * 10,b * 10)
}
var r = run(10, b: 20)
print(r)
print(r.a1)
print(r.b1)

//5.多参量函数
//函数可以有多种不同类型的参数
//函数一
func greet(personName: String) ->String{
return "hello" + personName
}
//函数二
func greetAgain(personName: String) ->String{
return "hello again" + personName
}
//实现多参量函数
func sayHello(personName: String,alreadyGreet:Bool) ->String{
if alreadyGreet{
return greetAgain(personName)
}else{
return greet(personName)
}
}

print(sayHello("尼古拉斯赵四", alreadyGreet: true))

//6.函数的外部参数
//主要是为了指明每个参数所代表的意义
func login(userName para1: String,password para2: String){
print("用户名是(para1) ,密码是(para2)")
}
login(userName: "xiaohong", password: "123456")

//忽略参数
func jump(para1: String,_ para2: String){
print("(para1),(para2)")
}
jump("123", "456")

//7.函数的默认参数值
func fly(a: Int,b: Int = 10) ->Int{
return a * b
}
var f = fly(20)
var f1 = fly(10, b: 30)
print(f1)

//8.定义可变参数的函数（通过...使得函数的参数个数是动态的）
func sum(numbers: Int...) ->Int{
var result = 0
for i in numbers{
result += i
}
return result
}
var sumResult = sum(1,3,5,6,7)
print(sumResult)

//9.函数的常量参数和变量参数
//默认情况下，函数的参数都是let类型的
func swim(var a: Int,b: Int) ->Int{
a = a + 10
return a
}

var s = swim(10, b: 0);
print(s)

//10.函数的输入输出参数
//使用inout关键字来定义函数的输入输出参数，只有变量才能作为函数的输入输出参数
func change(inout a: Int,inout b: Int){
let temp = a
a = b
b = temp
}
var c1 = 10
var c2 = 15
change(&c1, b: &c2)
print("c1 is (c1),c2 is (c2)")

//11.函数类型的使用
//加法
func add(a:Int, b:Int) ->Int{
return a + b
}
//减法
func sub(a: Int,b: Int) ->Int{
return a - b
}
//共同特点是：（Int，Int）->Int
//函数类型作为类型标注使用
var res1: (Int,Int) ->Int = add
var finalResa = res1(2,3)
print(finalResa)

//函数类型作为参数类型
func hehe(a: (Int,Int) ->Int,b: Int,c: Int) ->Int{
return a(b,c)
}
var h = hehe(sub, b: 10, c: 30)
print(h)

//函数类型可以作为函数返回类型
func test(a: Int,b: Int) ->(Int,Int) ->Int{
if a + b > 10{
return sub
}else{
return add
}
}
var t = test(5, b: 7)
print(t(100,200))

//二、闭包
/*
Swift中的闭包是一个自包含的函数代码块，可以在代码中进行传递和使用，类似OC中的block
闭包可以在捕获和存储所在上下文中任意常量和变量的引用，也就是闭包并且包裹着这些常量和变量，俗称闭包，在Swift中，会自动的管理在捕获过程中涉及到的所有内存的操作
*/
//1.闭包表达式的语法
// {（参数：参数类型...) ->返回值类型 in
// 执行语句

//}
//2.sort函数
//sort函数是系统提供的一个排序函数，用于对数组中的元素进行排序，但是不会修改原来数组
let names = ["Jack","Rose","Lily","Mark"]
//比较大小
func prepare(para1: String,para2: String) ->Bool
{
return para1 > para2
}
//实质上将自定义的比较函数整个作为参数传给了sort函数
var newNames = names.sort(prepare)
print(newNames)

//3.使用闭包的语法
newNames = names.sort(
{
(para1: String,para2: String) ->Bool in
return para1 > para2
})
print(newNames)

//4.根据上下文推断类型
//在Swift中，系统可以自动的推断参数和返回值的类型
newNames = names.sort({para1,para2 in
return para1 > para2
})
print(newNames)

//5.单表达式闭包隐式返回
//单行表达式闭包可以通过隐藏return关键字来达到隐式返回的目的
newNames = names.sort({para1,para2 in
para1 > para2
})
print(newNames)
//尾随闭包

//三、枚举
/*
在C语言中，枚举将枚举名和一个整型值相对应。但是，在Swift中，枚举变得更加灵活，枚举名不再只跟整型值相对应，我们也不必给每个枚举名提供一个值，如果有值，则值的类型很可能字符串，字符，整型或者浮点型
/
//1.定义一个枚举
//使用enum关键字
enum Direction {
// 枚举成员值
// case关键字表明新的一行成员值将被定义
case west
case east
case north
case south
}
//多个成员值可以定义在同一条语句中，用逗号隔开
enum Animal {
case dog,pig,cat,elephant
}
/
注意：
1.与c和oc不同的是，Swift中枚举成员在被创建的时候不会被赋予一个默认的整型值
2.枚举名的第一个字母必须要大写，以及后面的类和结构体都是同样的要求，函数的命名以小写字母开头
*/

//2.使用枚举值
var direction = Direction.east
//枚举在被初次初始化之后，获取另外的值时可以直接使用（.）来调用
direction = .south
print(direction)

//3.匹配枚举值和switch语句
switch direction{
case .north:
print("north")
case .west:
print("west")
case .east:
print("east")
case .south:
print("south")
}

//四、类和结构体
//1.定义
//类：使用class关键字
class Person {
// 定义属性
var name = ""
var age = 0
}

//结构体：使用struct关键字
struct Student {
// 定义属性
var number = 20
var grade = 5
}

//2.实例化
//Person类
var per = Person()
//给类的属性赋值
per.name = "懒羊羊"
per.age = 4
print("姓名:(per.name) , 年龄:(per.age)岁")

//Student结构体
var stu = Student()
stu.grade = 7
stu.number = 60
print("年级:(stu.grade)年级 ,人数:(stu.number)人")

//3.类和结构体的混合编程
struct Orange {
var number = 0
}
class Child {
var name = ""
var age = 0
// 将结构体作为类型标注，当类中包含自定义类型时，需要将包含定义类型初始化
var oranges:Orange = Orange()
}
//实例化Child
var child = Child()
//属性设置
child.name = "喜羊羊"
child.age = 4
child.oranges.number = 5
print("小🐑叫(child.name)今年(child.age)岁有(child.oranges.number)个橘子")

//4.逐一构造器
//结构体具有逐一构造器，但是类没有，因为结构体是值类型，类是引用类型

struct Cat {
var name = ""
var age = 0
}
//逐一构造器：在实例化结构体的同时对属性进行赋值
var cat = Cat(name: "金吉拉", age: 3)

//5.值类型
//值类型的特点是：当赋值给变量或者常量或者函数时，是通过拷贝的形式
var cat1 = cat
print(cat1.name)
cat.name = "小怪"
print(cat.name)
print(cat1.name)

//6.引用类型
//类是引用类型
class Dog {
var name = ""
var age = 0
}
var dog = Dog()
dog.name = "金毛"
//当引用类型给变量或者常量或者函数进行赋值的时候，只是做了指针的指向，内存中并没有拷贝
var dog1 = dog
print(dog1.name)
dog.name = "大黄"
print(dog.name)
print(dog1.name)
/*
类和结构体的相同点和不同点
相同点：
1.定义的方式一样
2.都有各自的属性
3.实例化的方式一样
4.属性赋值的方式一样

不同点
1.定义的关键字不一样，类使用class，结构体是struct
2.实例化的时候，结构体是另外的逐一构造器，但是类没有
3.结构体是值类型，类是引用类型

联系：可以将结构体作为类型标注在类中使用
*/
//7.实例方法和类方法的使用
class Tiger {
var name = ""
var age = 0
// 创建实例方法
func eat() {
print("practice makes perfect")

// 在实例方法中self表示的就是当前类的对象
self.name = "tiger"
print(self.name)
}
// self还可以用来区分属性和形参
func run(name:String){
self.name = name
}
// 创建类方法，可以通过static或者class关键字来标明
// 在实例方法前面加上static或者class关键字就成了一个类方法
static func bark() {
print("barking")
}
}
//调用类方法和实例方法
//实例化
var tiger = Tiger()
//调用实例方法：通过对象调用
tiger.run("tiger")
tiger.eat()
//调用类方法：通过类名直接调用
Tiger.bark()
/*
类方法和实例方法的相同点和不同点
相同点
1.实质上都是函数
2.都可以对类的属性进行修改
不同点
1.类方法需要用static或者class关键字进行标明，实例方法不需要
2.在调用的时候，实例方法只能通过类的对象来调用，类方法是通过类名直接调用
*/

//8.在值类型（结构体）中修改属性
struct Student1 {
// 定义属性
var number = 100
var grade = 3
// 在值类型中定义实例方法，并在实例方法中修改结构体属性的话需要使用关键字mutating
mutating func study() {
self.number = 60
print("班级人数：(self.number)")
}
// 在实例方法中，可以直接对self进行修改
mutating func play() {
// 使用逐一构造器
self = Student1(number: 30, grade: 8)
print("学生人数：(self.number) 年级：(self.grade)")
}
}
var stu1 = Student1()
stu1.play()
stu1.study()

//9.类的继承
class Car {
var carName = ""
var price = 0.0
// 可以在父类的实例方法中添加final关键字设置此方法不被子类重写
func run() {
print("奔跑吧，皮卡丘")
}
}

//通过类的继承，子类可以继承父类所有的方法和属性
//和OC一样，Swift中不允许多继承
class AutoCar:Car {
// 给子类添加新的属性
var factory = "山东蓝翔"
}
var autoCar = AutoCar()
autoCar.carName = "兰博基尼"
autoCar.price = 1.0
autoCar.run()

class Bicycle: Car {
// 如果要在子类中重写父类的方法，需要用override关键字进行标明
override func run(){
print("奔跑吧，兄弟")
}
}