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) 類型不匹配
//類型推斷
//根據(jù)賦值推斷出變量或常量的類型
var num5 = 19
let num6 = 3.14//Double
var char:Character = "C"
var char2 = "C"http://String
var str = String("123123")
var str2 = "123123"http://字面變量創(chuàng)建
let 二進(jìn)制 = 010101
print(二進(jìn)制)
let 八進(jìn)制 = 0o11
print(八進(jìn)制)
let 十進(jìn)制 = 111
print(十進(jìn)制)
let 十六進(jìn)制 = 0x11
print(十六進(jìn)制)
//數(shù)據(jù)類型轉(zhuǎn)換
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 主要用作判斷條件和循環(huán)條件嘹黔，swift中不在有非零即為真
var flag = true
print(flag)
flag = false
print(flag)
if false{
print("永真")
}//認(rèn)為不執(zhí)行管搪，白寫
//while ture{
//? ? print("死循環(huán)")
//}
//元組? Tuple 主要用來處理當(dāng)一個函數(shù)需要多個返回值的情況
let tuple = (name:"里斯",age:18,123)
//訪問元組的內(nèi)容
//通過下標(biāo)訪問
print(tuple.0)
print(tuple.1)
print(tuple.2)
//通過元素訪問
print(tuple.name)
print(tuple.age)
/*
func 函數(shù)名(參數(shù)列表) -> 返回值類型 {
函數(shù)體
}
*/
//求和函數(shù)
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 //定義一個可選類型的整數(shù)
aString = "JiNingShiFan"
print(aString)
//對一個值為空的可選類型進(jìn)行解包是很危險的，解包前要判斷是否有值，或者賦值
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 = ""
//系統(tǒng)內(nèi)部就幫我們把可選類型str3值解包出來了，不需要手動再解包魂那，如果str3值不為空悲龟，if的條件為true，如果str3的值為空冰寻，if就是false须教，則不執(zhí)行if語句
if let vauleString = str3{
str4 = vauleString + " XiangLaoShi"
}
print(str4)
//隱式解包類型
//隱式解包類型要求必須賦值，才能使用斩芭，nil也可以
var v:Int! = nil
//此時再使用v中的值時轻腺，就不能再使用！解包了划乖，因為已經(jīng)解包過了
v = 18
let value = v + 12
print(value)
//for循環(huán)
//for C語言的格式已經(jīng)被棄用了
//for(i:Int;i<10;i++){
//
//}
//使用for循環(huán)輸出1到10
//...代表閉區(qū)間[1,10]
for i in 1...10{
print(i)
}
//使用for輸出1到9
//..<代表開區(qū)間[1,10)
for i in 1..<10{
print(i)
}
//輸出10遍Hello World
//如果沒有使用到循環(huán)變量贬养，可以用下劃線 _ 替換掉
for _ in 1...10{
print("Hello World")
}
//求1～100的和
//定義變量存儲最終的結(jié)果 sum1
var sum1 = 0
//利用for循環(huán)遍歷1～100，并把結(jié)果放到sum1中
for i in 1...100{
sum1+=i
}
print(sum1)
//repeat-while循環(huán)
var m = 0
repeat {
print("班里美女好多")
m += 1// ++ 和 -- 已經(jīng)被棄用了
}while m < 10
//創(chuàng)建字符串
let s1 = "字面量格式創(chuàng)建"
print(s1)
//使用初始化方法創(chuàng)建
let s2 = String("初始化方法創(chuàng)建")//創(chuàng)建出來的是可選類型字符串
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")//拼接內(nèi)容直接作用到原串上了
print(s4)
let nStr3 = s4.appending(" qipashuo")//拼接的內(nèi)容沒有作用到原串上误算，而是返回一個新的字符串
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)
}
//數(shù)組 Swift創(chuàng)建數(shù)組一定要制定存放的元素類型let arr1 = [Int]()var arr2 = [String]()//添加元素arr2.append("zhangsan")print(arr2)arr2[0] = "Lisi"print(arr2)//字面量創(chuàng)建數(shù)組var arr3 = ["zhangsan","Lisi","wanger","mazi"]//刪除//根據(jù)下標(biāo)刪除arr3.remove(at: 0)print(arr3)//刪除最后一個元素arr3.removeLast()//arr3.remove(at:2)//刪除第一個元素arr3.removeFirst()//刪除所有元素arr3.removeAll()//獲取元素個數(shù)print(arr3.count)print(arr3)//數(shù)組遍歷var arr4 = ["huaqiangu","shaqianmo","dongfangyuqin","tangbao","zunshang"]for item in arr4{? ? print(item)}for (i,Item) in arr4.enumerated(){? ? print("item:\(Item)index:\(i)")}//數(shù)組排序arr4.sort()print(arr4)var numArr = [8,4,3,7,2,1]//冒泡排序：外層控制比較趟數(shù)，內(nèi)層控制比較次數(shù)//外層控制比較的趟數(shù)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)
//字典 創(chuàng)建字典和創(chuàng)建數(shù)組是一樣迷殿，創(chuàng)建同時就要制定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 枚舉情況 = 初始值
}*/
//值類型和初始值可以選擇是否賦值
//枚舉也是一種數(shù)據(jù)類型，只不過是我們自定義的數(shù)據(jù)類型
//季節(jié)
enum Season:String{
case spring = "春天"http://0
case summer = "夏天"http://1
case autumn = "秋天"http://2
case winter = "冬天"http://3
}
//定義變量常量
let aSeason = Season.spring
//給定數(shù)據(jù)類型時就可以省略枚舉類型
let aSeason2:Season = .summer
//不給數(shù)據(jù)類型首次賦值一定要給枚舉類型
var aSeason3 = Season.summer
aSeason3 = .spring//確定輸出的值
//獲取枚舉情況的值
print(aSeason3.rawValue)//rawValue 才是真正的枚舉值
print(aSeason3.hashValue)//hashValue case的編號
//枚舉常和switch語句結(jié)合使用
switch aSeason3{
case .spring:
print("高鞠來了")
fallthrough//增加穿透性庆寺，但只能穿一次
case .summer:
print("嚇?biāo)缹殞毩?)
case .autumn:
print("秋")
case .winter:
print("凍死寶寶了")
//? ? 枚舉情況都列舉完蚊夫，default語句就不要再寫
//? ? 枚舉情況沒有列舉完，必須添加default語句
//default:
//? ? print("我來自星星Ｅ吵ⅰＶ住！")
}
//函數(shù)：能完成特定功能的代碼段 好處：方便調(diào)用陵霉，保護(hù)知識產(chǎn)權(quán)琅轧，減少代碼凹余
/*
func 函數(shù)名(參數(shù)) -> 返回值類型 {
函數(shù)體
}
*/
//無參無返回值
//小王給祥哥買紅酒(祥哥沒給錢，沒有紅酒給祥哥)
func buyRedWine() -> Void {
print("沒錢沒酒")
}
//函數(shù)調(diào)用
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)瓶雪碧")
//寫一個函數(shù)計算兩個數(shù)的和
//oneNumber,otherNumber是外部參數(shù)模蜡，對形參進(jìn)行解釋說明
func sum(oneNumber a:Int,otherNumber b:Int) -> Int {
return a + b
}
//調(diào)用時傳的值是實參
//print(sum(a: 10, b: 20)) error
print(sum(oneNumber: 10, otherNumber: 20))
//可變參數(shù)函數(shù)
func qiuHe(numbers:Int...) -> Int {//參數(shù)是可變的漠趁，個數(shù)是不固定的
//? ? 傳的多個參數(shù)存放在numbers形參里了，此時numbers相當(dāng)于一個數(shù)組
var reslut = 0
for item in numbers {
reslut += item
}
return reslut
}
print(qiuHe(numbers: 1,2,3,4,5,6,7))
//定義一個函數(shù)交換兩個變量的值
//swift中所有的形參默認(rèn)都是常量忍疾，函數(shù)內(nèi)部不能修改函數(shù)的值
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)")
//結(jié)構(gòu)體 用來描述一個由多個屬性組成的整體闯传，也是一種自定數(shù)據(jù)類型
/*
struct 結(jié)構(gòu)體名 {
屬性列表
方法
}
*/
//類的三大特性：分裝，繼承卤妒，多態(tài)
struct Orgin {
//存儲屬性
var x:Float
var y:Float
//? ? 對象方法
func drawOrign() {
print("在二維坐標(biāo)系中畫一個點")
}
//? ? 類方法
static func showPoint(){
print("我是一個點")
}
}
//結(jié)構(gòu)體的 使用
let p1 = Orgin(x: 10.2, y: 15.3)
p1.drawOrign()
//使用結(jié)構(gòu)體名調(diào)用方法
Orgin.showPoint()
//創(chuàng)建一個Size的結(jié)構(gòu)體
struct Size {
var width:Float
var height:Float
}
let aSize = Size(width: 100.0, height: 20.0)
print(aSize)
struct Frame {
//? ? 結(jié)構(gòu)體的屬性依然可以是結(jié)構(gòu)體
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)
//類:具有相同特征和行為的事物的抽象
//根據(jù)類創(chuàng)建的實例就是：對象
//類的創(chuàng)建格式
/*
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!
//提供一個快速創(chuàng)建對象的初始化方法
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("打豆豆")
}
}
//創(chuàng)建一個對象
let p = Person(name: "男哥", age: 16, gender: "女")
print(p.name,p.age,p.gender)
Person.color = "red"
print(Person.color)
//調(diào)用類方法
Person.daDouDou()
class Student: Person {
var number:Int!
func study() {
print("好好學(xué)習(xí)图谷，過四級")
}
//重寫從父類繼承過來的方法
override func eat() {
super.eat()//保留父類方法的實現(xiàn)
print("吃滿漢全席")
}
}
let stu = Student(name: "哲磊", age: 8, gender: "妖")
stu.number = 11
stu.study()
print(stu.name,stu.age,stu.gender)
stu.eat()
stu.sleep()
//協(xié)議 代理設(shè)計模式
//OC下的協(xié)議
@objc protocol GirlDelegate {//協(xié)議名
//協(xié)議中只寫函數(shù)聲明
//必須實現(xiàn)的方法
func makeMoney()
//選擇實現(xiàn)的方法
@objc optional func wish()
@objc optional func cook()
@objc optional func doHousework()
}
class Girl: NSObject {
//設(shè)置代理屬性
var delegate:GirlDelegate!
//女孩想買東西
func buySomething() {
//男朋友掙錢
self.delegate.makeMoney()
}
//女孩餓了
func hungry() {
//男朋友做飯
self.delegate.cook!()
}
//女孩有臟衣服
func youZangYiFu() {
//男朋友洗衣服
self.delegate.wish!()
}
//女孩家里臟了
func clearHome() {
//男孩做家務(wù)
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
//男哥發(fā)號指令
nanGe.buySomething()
nanGe.hungry()
nanGe.youZangYiFu()
nanGe.clearHome()
//代理設(shè)計模式的步驟
//1.設(shè)計協(xié)議
//2.設(shè)置代理屬性
//3.遵循協(xié)議
//4.實現(xiàn)協(xié)議中的方法
//5.在外界制定代理屬性（給代理屬性賦值）
//6.告訴代理對象什么時候干活
//Swift中協(xié)議格式，協(xié)議中的方法都是必需實現(xiàn)的
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()
//延展：用來擴充一個類,主要用來管理類的方法或者是遵循某個協(xié)議的方法
extension Nanny : HostessDelegate{
func doHomework() {
print("做家務(wù)")
}
func cook() {
print("做飯")
}
func takeCarOf(){
print("照顧小孩")
}
}
let cuiHua = Hostess()
let chenYang = Nanny()//保姆對象
//5.給代理屬性賦值
cuiHua.delegate = chenYang
cuiHua.clearHome()
cuiHua.hungry()
cuiHua.working()
//閉包：閉包的本質(zhì)就是匿名函數(shù)(沒有名字的函數(shù)),就是能完成特定功能的代碼塊//求和函數(shù)func sum(num1:Int,num2:Int) -> Int {? ? return num1 + num2}/* (Int,Int)->(Int)*///定義閉包,let biBao:((Int,Int)->(Int))biBao = {//函數(shù)聲明? ? (num1:Int,num2:Int)->(Int) inreturn num1 + num2}//調(diào)用閉包print(biBao(1,2))//無參數(shù)無返回值的閉包func sayHello() -> Void {? ? print("Hello")}//()->(Void)let b1:(()->(Void)) = {? ? ()->(Void) in? ? print("無參數(shù)無返回值函數(shù)")? ? return print("提前結(jié)束函數(shù)")// 提前結(jié)束一個函數(shù)（OC中一樣）? ? print("110")}b1()//無參數(shù)有返回值的閉包類型//() -> (Int)let b2:(()->(Int)) = {? ? () -> (Int) in? ? return 10}print(b2())//有參數(shù)有返回值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求兩個數(shù)積的代碼塊b3 = {? ? (x:Int,y:Int)->(Int) in? ? return x * y}print(b3(3,12))//閉包類型不只能存儲一個代碼塊阱洪，而是能存儲和變量類型一致的所有代碼塊//有參數(shù)無返回值的閉包//比較兩個數(shù)最大值便贵，并把最大值輸出的閉包//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"]//可變的數(shù)組兩種排序都可以使用，不可變只能使用sorted方法arr.sort()arr.sorted()arr.sort { (str1:String, str2:String) -> Bool in? ? //比較大于冗荸，得出結(jié)果是降序? ? //比較小于承璃，得出結(jié)果是升序? ? return str1 > str2}//< > 控制升序降序print(arr)//泛型func printContent(something:A) {
print(something)
}
printContent(something: "123123")
