Swift 基础01 —— Objective-C转战Swift

Swift 初体验

// 1.Swift导入框架
/*
Objective-C
#import <UIKit/UIkit.h>
----------------------------

*/
import UIKit

// 2.定义标识符
/*
Objective-C
int a = 20;
a = 10;
----------------------------
1> 必须明确指定标识符是常量还是变量
2> var定义变量，let定义常量
3> 格式： var/let 标识符名称 : 标识符类型 = 赋值
*/
var a : Int = 20
a = 10

let b : Double = 3.14

// 3.打印内容
/*
Objective-C
NSLog(@"Hello World!");
NSLog(@"%d", a);
----------------------------

*/
print("Hello World!")
print(a)

// 4.创建对象
/*
Objective-C
UIView *view = [[UIView alloc] init];
----------------------------

*/
var view : UIView = UIView()

常量&变量

1. 优先使用常量（let），只有发现标识符需要修改时，再使用变量。

   目的：防止在其他不希望修改的地方不小心将值修改掉。

2. 常量的本质：指向的内存地址不可以修改，但是可以通过内存地址找到对应的对象，之后修改对象内部的属性

   // 1>指向的内存地址不可以修改
   let view : UIView = UIView()
   view = UIView() //错误
   // 2>但是可以通过内存地址找到对应的对象，之后修改对象内部的属性
   view.backgroundColor = UIColor.blue
   

// 需求：创建UIView对象，并且在UIView中添加UIButton

// OC: [[UIView alloc]initWithFrame:CGRect]
let rect = CGRect(x:0, y:0, width:100, height:100)
let view : UIView = UIView(frame:rect)
view.backgroundColor = UIColor.red

let btn : UIbutton = UIButton()
btn.frame = CGRect(x:0, y:0, width:50, height:50)
btn.backgroundColor = UIColor.orange
// Swift枚举类型：
// 方式一：如果可以根据上下文语法推断吃该枚举的类型，可以直接`.具体类型`
// 方式二：如果推断不出来，`枚举类型.具体类型`
btn.setTitle("按钮", for: .normal)

// 在Swift中调用方法，统一使用 点语法
view.addSubview(btn)

数据类型

简单介绍

• 整型
  • 有符号
    • Int8：有符号8位整数
    • Int16：有符号16位整数
    • Int32：有符号32位整数
    • Int64：有符号64位整数
    • Int：和平台相关（相当于OC 的NSInteger）
  • 无符号
    • UInt8：无符号8位整数
    • UInt16：无符号16位整数
    • UInt32：无符号32位整数
    • UInt64：无符号64位整数
    • UInt：和平台相关（相当于OC 的NSUInteger）
• 浮点型
  • Float：32位浮点型
  • Double：64位浮点型（默认）

类型推导

Swift是强类型语言

Swift中任何一个标识符都有明确的类型

/*
	1> 如果在定义标识符时，有直接给该标识符复制，那么可以将标识符后面的类型省略
	2> 编译器会根据我们后面的赋值类型，推导出标识符的类型，这个过程叫类型推导
	3> 可以通过 `Option + 鼠标左键` 来查看标识符类型
*/

let a = 20
var a = 20

let view = UIView()
let btn = UIButton()

基本运算

Swift中进行基本运算时必须保证类型一致，否则会报错

• 相同类型之间可以进行运算
• Swift没有隐式转换

let m = 20
let n = 10.5
// let result = m + n 错误
let result = Double(m) + n

let a : Double = 2.44
let b : CGFloat = 3.55
// let result1 = a + b 错误
let result1 = a + Double(b)

逻辑分支

if…else 的使用

/*
OC:
int a = 20;
if(a > 0){
}
if(a){
}
----------------------
Swift中的区别：
1> if后面的()可以省略
2> 没有非0（nil）即真Bool（true/false）
*/

let a = 10
if a > 0 {
    print("a大于0")
}
if a != 0 {
    print("a不等于0")
}
// else if 的使用
let score = 88
if score < 0 || score > 100 {
    print("不合理的分数")
} else if score < 60 {
    print("不及格")
}

guard 的使用

• guard 是Swift2.0新增的语法
• 减少代码的嵌套，提高代码可读性

let age = 18
func online (age : Int){
    guard age >= 18 else {
        print("回家去")
        return
    }
    
    guard 带了身份证 else {
        print("回家拿身份证")
        return
    }
    
    guard 带了钱 else {
        print("回家拿钱")
        return
    }
    
    print("留下上网")
}

online(age: age)

switch 分支

/*
和OC的区别：
1> switch 后面的()可以省略
2> case语句结束时，可以不加break
*/
let sex = 0
switch sex {
case 0:
    print("男")
case 1:
    print("女")
default
    print("其他")
}
/*
1> 在Swift中，switch后面case可以判断多个条件
2> 如果希望case结束时产生case穿透，加上fallthrough
*/
switch sex {
case 0, 1 :
    print("正常人")
    fallthrough
default
    print("不正常人")
}

// 可以判断浮点型
let m = 3.14
switch m {
case 3.14:
    print("和π相等")
default
    print("和π不相等")
}
// 可以判断字符串
let a = 20
let b = 10
let oprationStr = "+"
var result = 0

switch oprationnStr {
case "+":
    result = a + b
case "-":
    result = a - b
case "*":
    result = a * b
case "/":
    result = a / b
default:
    print("不合理的操作符")
}

// 可以判断区间类型
/*
区间
	1> 半开半闭区间 0~9 0..<10
	2> 闭区间 0~9 0...9
*/
let score = 88

switch score {
case 0..<60 :
    print("不合格")
case 60..<80 :
    print("及格")
case 80..<90 :
    print("良好")
case 90...100 :
    print("优秀")
default :
    print("不合理的分数")
}

循环使用

for 循环

 // Swift中for循环只支持区间遍历
for i in 0..<10 {
    print(i)
}

for i in 0...9 {
    print(i)
}
// 在Swift开发中，如果一个变量常量暂时不会使用，那么可以使用 _ 来代替
for _ in 0..<10 {
    print("Hello World")
}

while/ repeat while 循环

/*
Swift中的区别：
1> while后面的()可以省略
2> 没有非0（nil）即真Bool（true/false）
*/
var m = 0
while m < 10 {
    m += 1
    print(m)
}

repeat {
    m -= 1
    print(m)
}while m > 0