import Foundation
print("1","2","3","4");
//输出多个字符串，并用“***”并用 \n 换行
print("1","2","3","4", separator: "---", terminator: "\n")
//常量
let num = 120
//变量
var num2 = 18
num2 = 10
print(num,num2)
//类型安全和类型推断
let num3:Int = 18
//num3 = 3.14 类型不匹配
var num4:Float = 2123
//num4 = Int(4) 类型不匹配
//类型推断
//根据赋值推断出变量或常量的类型
var num5 = 19
let num6 = 3.14//Double
var char:Character = "C"
var char2 = "C"//String
var str = String("123123")
var str2 = "123123"//字面变量创建
let 二进制 = 010101
print(二进制)
let 八进制 = 0o11
print(八进制)
let 十进制 = 111
print(十进制)
let 十六进制 = 0x11
print(十六进制)
//数据类型转换
var t = 3
let t1 = 2.34
let result = Double(t) + t1
print("Double:\(result)")
let result2 = t + Int(t1)
print("result2:\(result2)")
let result3 = String(t)
print("String:\(result3)")
let result4 = Int("123")//返回值是可选类型
print(result4)//Optional(123)
let result5 = result4! + 5//可选类型不能直接参与运算,需要解包取出里面的值，再做运算
print(result5)
//布尔值 Boll 主要用作判断条件和循环条件，swift中不在有非零即为真
var flag = true
print(flag)
flag = false
print(flag)
if false{
print("永真")
}//认为不执行，白写
//while ture{
// print("死循环")
//}
//元组 Tuple 主要用来处理当一个函数需要多个返回值的情况
let tuple = (name:"里斯",age:18,123)
//访问元组的内容
//通过下标访问
print(tuple.0)
print(tuple.1)
print(tuple.2)
//通过元素访问
print(tuple.name)
print(tuple.age)
/*
func 函数名(参数列表) -> 返回值类型 {
函数体
}
*/
//求和函数
func sum(num1:Int,num2:Int) ->Int{
return num1+num2
}
print(sum(num1: 1, num2: 2))
//元组的使用场景
func backValue(num1:Int,num2:Int) -> (Int,Int){
return (num1+num2,num1-num2)
}
let tuple2 = backValue(num1: 12, num2: 3)
print(tuple2)
print(tuple2.0,tuple2.1)
//可选类型 Optional 可选类型主要用来处理可能缺失的情况
var aString:String? = nil//定义可选类型的字符串
var aInt:Int? = nil //定义一个可选类型的整数
aString = "JiNingShiFan"
print(aString)
//对一个值为空的可选类型进行解包是很危险的，解包前要判断是否有值，或者赋值
let newString = aString! + "IOS Class"
print(newString)
var sum = 0
//先判断可选类型是否为空，不为空才解包
if aInt != nil{
sum = aInt! + 10
}
print(sum)
//可选绑定
let str3:String? = "I love"
var str4 = ""
//系统内部就帮我们把可选类型str3值解包出来了，不需要手动再解包，如果str3值不为空，if的条件为true，如果str3的值为空，if就是false，则不执行if语句
if let vauleString = str3{
str4 = vauleString + " XiangLaoShi"
}
print(str4)
//隐式解包类型
//隐式解包类型要求必须赋值，才能使用，nil也可以
var v:Int! = nil
//此时再使用v中的值时，就不能再使用！解包了，因为已经解包过了
v = 18
let value = v + 12
print(value)
//for循环
//for C语言的格式已经被弃用了
//for(i:Int;i<10;i++){
//
//}
//使用for循环输出1到10
//...代表闭区间[1,10]
for i in 1...10{
print(i)
}
//使用for输出1到9
//..<代表开区间[1,10)
for i in 1..<10{
print(i)
}
//输出10遍Hello World
//如果没有使用到循环变量，可以用下划线 _ 替换掉
for _ in 1...10{
print("Hello World")
}
//求1～100的和
//定义变量存储最终的结果 sum1
var sum1 = 0
//利用for循环遍历1～100，并把结果放到sum1中
for i in 1...100{
sum1+=i
}
print(sum1)
//repeat-while循环
var m = 0
repeat {
print("班里美女好多")
m += 1// ++ 和 -- 已经被弃用了
}while m < 10
//创建字符串
let s1 = "字面量格式创建"
print(s1)
//使用初始化方法创建
let s2 = String("初始化方法创建")//创建出来的是可选类型字符串
print(s2!)
//操作字符串方法和属性
let s3 = "Hello World"
//获取字符串的长度
print(s3.characters.count)//先获取字符，再count获取长度
//大写字符串的方法
let nStr = s3.uppercased()
print(nStr,s3)
//小写字符串的方法
let nStr2 = nStr.lowercased()
print(nStr2,nStr)
//字符串拼接
var s4 = "zhangquandan"
s4.append(" funtukang")//拼接内容直接作用到原串上了
print(s4)
let nStr3 = s4.appending(" qipashuo")//拼接的内容没有作用到原串上，而是返回一个新的字符串
print("nStr3"+nStr3,"s4"+s4)
//遍历字符串
let s5 = "We are fimily"
for char in s5.characters{
print(char)
}
//字符串的格式化拼接
for i in 1..<10{
let str = String(format: "student%02d", i)//%02d占位符及所占位置
print(str)
}
//数组 Swift创建数组一定要制定存放的元素类型let arr1 = [Int]()var arr2 = [String]()//添加元素arr2.append("zhangsan")print(arr2)arr2[0] = "Lisi"print(arr2)//字面量创建数组var arr3 = ["zhangsan","Lisi","wanger","mazi"]//删除//根据下标删除arr3.remove(at: 0)print(arr3)//删除最后一个元素arr3.removeLast()//arr3.remove(at:2)//删除第一个元素arr3.removeFirst()//删除所有元素arr3.removeAll()//获取元素个数print(arr3.count)print(arr3)//数组遍历var arr4 = ["huaqiangu","shaqianmo","dongfangyuqin","tangbao","zunshang"]for item in arr4{ print(item)}for (i,Item) in arr4.enumerated(){ print("item:\(Item)index:\(i)")}//数组排序arr4.sort()print(arr4)var numArr = [8,4,3,7,2,1]//冒泡排序：外层控制比较趟数，内层控制比较次数//外层控制比较的趟数for i in 0..numArr[j+1] {
let temp = numArr[j]
numArr[j] = numArr[j+1]
numArr[j+1] = temp
}
}
}
print(numArr)
//元素的插入
var arr5 = ["a","b","c","d"]
arr5.insert("f", at: 4)
print(arr5)
//字典 创建字典和创建数组是一样，创建同时就要制定key和value值的类型
let dict = [String:Int]()
let dict2 = ["name":"亚索","age":18,"height":1.8] as [String : Any]//Any说明value的值时任意值
//访问字典的元素
print("国服第一亚索"+(dict2["name"] as! String))
var dic3 = ["name":"蛮子","gender":"妖","skill":"蛮三刀"]
//找得到key值就是改，找不到key值就是添加
dic3["gender"] = "汉子"
dic3["hobby"] = "找妹子"
//字典的删除
dic3.removeValue(forKey: "gender")
print(dic3)
//字典的遍历
//遍历键值对
for value in dic3{
print(value)
}
//遍历字典key值
for key in dic3.keys{
print(key)
}
//遍历value值
for value in dic3.values{
print(value)
}
//枚举
/*enum 枚举名：值类型{
case 枚举情况 = 初始值
case 枚举情况 = 初始值
}*/
//值类型和初始值可以选择是否赋值
//枚举也是一种数据类型，只不过是我们自定义的数据类型
//季节
enum Season:String{
case spring = "春天"//0
case summer = "夏天"//1
case autumn = "秋天"//2
case winter = "冬天"//3
}
//定义变量常量
let aSeason = Season.spring
//给定数据类型时就可以省略枚举类型
let aSeason2:Season = .summer
//不给数据类型首次赋值一定要给枚举类型
var aSeason3 = Season.summer
aSeason3 = .spring//确定输出的值
//获取枚举情况的值
print(aSeason3.rawValue)//rawValue 才是真正的枚举值
print(aSeason3.hashValue)//hashValue case的编号
//枚举常和switch语句结合使用
switch aSeason3{
case .spring:
print("高鞠来了")
fallthrough//增加穿透性，但只能穿一次
case .summer:
print("吓死宝宝了")
case .autumn:
print("秋")
case .winter:
print("冻死宝宝了")
// 枚举情况都列举完，default语句就不要再写
// 枚举情况没有列举完，必须添加default语句
//default:
// print("我来自星星！！！")
}
//函数：能完成特定功能的代码段 好处：方便调用，保护知识产权，减少代码凹余
/*
func 函数名(参数) -> 返回值类型 {
函数体
}
*/
//无参无返回值
//小王给祥哥买红酒(祥哥没给钱，没有红酒给祥哥)
func buyRedWine() -> Void {
print("没钱没酒")
}
//函数调用
buyRedWine()
//无参有返回值
func buyRedWine2() -> Int {
print("82年的拉菲来一瓶")
return 1
}
let bottle = buyRedWine2()
print("买了\(bottle)瓶")
//有参无返回值
func buyXueBi(money:Int) {
print("\(money)块钱啊！好多啊！跑路了")
}
buyXueBi(money: 100)
//有参有返回值
func buyXueBi2(money:Int) -> Int {
print("买了\(money/2)瓶雪碧")
return money / 2
}
let bottle2 = buyXueBi2(money: 5)
print("买了\(bottle2)瓶雪碧")
//写一个函数计算两个数的和
//oneNumber,otherNumber是外部参数，对形参进行解释说明
func sum(oneNumber a:Int,otherNumber b:Int) -> Int {
return a + b
}
//调用时传的值是实参
//print(sum(a: 10, b: 20)) error
print(sum(oneNumber: 10, otherNumber: 20))
//可变参数函数
func qiuHe(numbers:Int...) -> Int {//参数是可变的，个数是不固定的
// 传的多个参数存放在numbers形参里了，此时numbers相当于一个数组
var reslut = 0
for item in numbers {
reslut += item
}
return reslut
}
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()
//创建一个Size的结构体
struct Size {
var width:Float
var height:Float
}
let aSize = Size(width: 100.0, height: 20.0)
print(aSize)
struct Frame {
// 结构体的属性依然可以是结构体
var orign:Orgin
var size:Size
//计算属性不适用给自己赋值，而是间接的给其他属性赋值，自己的值只能通过计算获得，不能直接给自己赋值
var center:Orgin{
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(width: 100, height: 50))
//取计算属性的值
print(aFrame.center)
//给计算属性赋值，不是给他自己赋值，是间接的为其他属性赋值
aFrame.center = Orgin(x: 50, y: 50)
print(aFrame.orign)//orign:(0.0,25)
//类:具有相同特征和行为的事物的抽象
//根据类创建的实例就是：对象
//类的创建格式
/*
class 类名: 父类 {
属性
行为
}
*/
//人类：Person 属性:姓名 年龄 性别 行为:吃饭 睡觉
//NSObject 也是Swift中所有类的根类(基类)
class Person: NSObject {
//属性
//1直接给初始值
//Swift不允许非可选类型的属性不赋初始值
// var name:String = "小肥"
//2
//var name: String
//在初始化方法中，给属性赋值
// init(name:String) {
// self.name = name
// }
//3定义成可选类型
// var name:String?
//4 定义成隐式解析类型
public var name:String!
var age:Int!
fileprivate var gender:String!//文件属性：只能在本文件中使用
//类属性
static var color:String!
//提供一个快速创建对象的初始化方法
init(name:String,age:Int,gender:String) {
self.name = name
self.age = age
self.gender = gender
}
//行为(方法)
func eat() {
print("吃")
}
func sleep() {
print("睡")
}
//类方法
static func daDouDou(){
print("打豆豆")
}
}
//创建一个对象
let p = Person(name: "男哥", age: 16, gender: "女")
print(p.name,p.age,p.gender)
Person.color = "red"
print(Person.color)
//调用类方法
Person.daDouDou()
class Student: Person {
var number:Int!
func study() {
print("好好学习，过四级")
}
//重写从父类继承过来的方法
override func eat() {
super.eat()//保留父类方法的实现
print("吃满汉全席")
}
}
let stu = Student(name: "哲磊", age: 8, gender: "妖")
stu.number = 11
stu.study()
print(stu.name,stu.age,stu.gender)
stu.eat()
stu.sleep()
//协议 代理设计模式
//OC下的协议
@objc protocol GirlDelegate {//协议名
//协议中只写函数声明
//必须实现的方法
func makeMoney()
//选择实现的方法
@objc optional func wish()
@objc optional func cook()
@objc optional func doHousework()
}
class Girl: NSObject {
//设置代理属性
var delegate:GirlDelegate!
//女孩想买东西
func buySomething() {
//男朋友挣钱
self.delegate.makeMoney()
}
//女孩饿了
func hungry() {
//男朋友做饭
self.delegate.cook!()
}
//女孩有脏衣服
func youZangYiFu() {
//男朋友洗衣服
self.delegate.wish!()
}
//女孩家里脏了
func clearHome() {
//男孩做家务
self.delegate.doHousework!()
}
}
class Boy: NSObject,GirlDelegate {
internal func makeMoney() {
print("一天1000块")
}
func cook() {
print("法式甜品")
}
func wish() {
print("手洗")
}
func doHousework() {
print("找保洁")
}
}
let nanGe = Girl()
let LiYiFeng = Boy()
//给代理属性赋值
nanGe.delegate = LiYiFeng
//男哥发号指令
nanGe.buySomething()
nanGe.hungry()
nanGe.youZangYiFu()
nanGe.clearHome()
//代理设计模式的步骤
//1.设计协议
//2.设置代理属性
//3.遵循协议
//4.实现协议中的方法
//5.在外界制定代理属性（给代理属性赋值）
//6.告诉代理对象什么时候干活
//Swift中协议格式，协议中的方法都是必需实现的
protocol HostessDelegate {
func doHomework()
func cook()
func takeCarOf()
}
class Hostess: NSObject {
var delegate:HostessDelegate!
func clearHome() {
self.delegate.doHomework()
}
func hungry() {
self.delegate.cook()
}
func working() {
self.delegate.takeCarOf()
}
}
//给NSObject扩充方法
extension NSObject{
func sayHello() {
print("Hello")
}
}
class Nanny: NSObject {
}
let n = Nanny()
n.sayHello()
//延展：用来扩充一个类,主要用来管理类的方法或者是遵循某个协议的方法
extension Nanny : HostessDelegate{
func doHomework() {
print("做家务")
}
func cook() {
print("做饭")
}
func takeCarOf(){
print("照顾小孩")
}
}
let cuiHua = Hostess()
let chenYang = Nanny()//保姆对象
//5.给代理属性赋值
cuiHua.delegate = chenYang
cuiHua.clearHome()
cuiHua.hungry()
cuiHua.working()
//闭包：闭包的本质就是匿名函数(没有名字的函数),就是能完成特定功能的代码块//求和函数func sum(num1:Int,num2:Int) -> Int { return num1 + num2}/* (Int,Int)->(Int)*///定义闭包,let biBao:((Int,Int)->(Int))biBao = {//函数声明 (num1:Int,num2:Int)->(Int) inreturn num1 + num2}//调用闭包print(biBao(1,2))//无参数无返回值的闭包func sayHello() -> Void { print("Hello")}//()->(Void)let b1:(()->(Void)) = { ()->(Void) in print("无参数无返回值函数") return print("提前结束函数")// 提前结束一个函数（OC中一样） print("110")}b1()//无参数有返回值的闭包类型//() -> (Int)let b2:(()->(Int)) = { () -> (Int) in return 10}print(b2())//有参数有返回值var b3:((Int,Int)->Int) = { (n:Int,m:Int)->(Int) in return n + m}print(b3(1,5))b3 = { (a:Int,b:Int)->(Int) in return a - b}print(b3(10,5))//b3求两个数积的代码块b3 = { (x:Int,y:Int)->(Int) in return x * y}print(b3(3,12))//闭包类型不只能存储一个代码块，而是能存储和变量类型一致的所有代码块//有参数无返回值的闭包//比较两个数最大值，并把最大值输出的闭包//func maxOfTwo(num1:Int,num2:Int)->Void {// print(num1>num2 ? num1 : num2)//}//(Int,Int)->Voidlet b4:((Int,Int)->(Void)) = { (num1:Int,num2:Int)->(Void) in print(num1 > num2 ? num1 : num2)}b4(10,12)var arr = ["zhangsan","Lisi","YiFeng","mazi","xiaofan"]//可变的数组两种排序都可以使用，不可变只能使用sorted方法arr.sort()arr.sorted()arr.sort { (str1:String, str2:String) -> Bool in //比较大于，得出结果是降序 //比较小于，得出结果是升序 return str1 > str2}//< > 控制升序降序print(arr)//泛型func printContent(something:A) {
print(something)
}
printContent(something: "123123")
