var b : Book? = Book() 。

• 这里的b就是对象,就是指针，用于存储地址。相当于 Person *p = [[Person alloc] init]，创建出来的p。这里的p就相当于b

swift注意点

• swift中如果定义一个标识符.必须告诉编译器该标识符是一个变量还是一个常量。这时候分别用到了两个修饰符
  • var:修饰变量的修饰符
  • let:修饰常量的修饰符
• swift调用方法用的都是点语法，没有[a b]的形式了
• 不能给常量赋值，能给变量赋值

swift类型推导

- let centerX = 100  // 不写标识符类型，底层自动类型推导，得到的是Int
- let cneterX ： double = 100 // 写标识符类型，底层不再自动类型推导，就根据你写的类型，得到double

精华拓展:
let btn:UIButton = UIButton() 等价 let btn = UIButton()  // 1

区别 UIButton()  // 2

1是用类创建了一个对象， 2是直接调用UIButton方法
1默认调用init方法

常量的使用注意

• 注意一:在开发中,apple建议优先使用常量,只有发现需要修改时再改成变量
• 注意二:常量的本质:指向的内存地址不可以修改,但是可以通过内存地址获取到对象,之后修改对象内部的属性

例子:

let rect = CGRectMake(0, 0, 100, 100)
let view:UIView = UIView(frame: rect) // 创建view的对象
view.backgroundColor = UIColor.orangeColor() // 修改对象内部的属性

let btnRect = CGRectMake(0, 0, 50, 30)
let btn:UIButton = UIButton(frame: btnRect) // 创建btn对象
btn.backgroundColor = UIColor.blueColor() // 修改对象内部的属性
btn.setTitle("按钮", forState: .Normal)  // 修改对象内部的属性
// 将btn添加到view中
view.addSubview(btn) // oc中使用[view addSubView:btn]，swifit中替换成了点语法

最终效果:

51-01.png

简写

修饰常量的修饰符 标识符(对象)的名称:标识符类型 = 创建对象
let view:UIView = UIView(frame: rect)    // 标识符类型放在标识符后面，即 view:UIView

修饰变量的修饰符 标识符(对象)的名称:标识符类型 = 创建对象
var view:UIView = UIView(frame: rect) 

let m : int = 20 等价 let m = 20(可以省略int,自动识别哦，实际上底层利用了类型推导，根据后面的类型，判断前面的类型)
let n :double = 3.14 等价let n = 3.14 
let btn:UIButton = UIButton() 等价 let btn = UIButton()

let btn:UIView = UIButton()   // UIButton 是UIView的子类，所以也可以这样写

---
两种写法(简写+繁写)：.Normal是不写Normal的类型的形式.
          UIControlState.Normal是写Normal的类型的形式.
setTitle(title,forState:.Normal)// 全写:setTitle(title, forState: UIControlState.Normal)  

swift中两个不同类型的常量不能相加，不能相乘，必须转类型。因为没有隐式转换

• oc中的隐式转化:在Int类型和Double进行基本运算(加减乘除)时,会自动将Int类型转成Double

let a = 20
let b = 30.5
let tmpA = Double(a) //将整形a转成浮点型
let result = tmpA + b

---

let a = 20
let b = 30.5
let tempB = Int(b) // 将浮点型b转成整形
let result1 = a + tempB

swift和OC的if的区别

• 等同 swift和OC的while的区别

  1.swift中if后面的()可以省略
  2.swift中if没有非0即真,必须有明确的Bool -> true/false

// 错误写法:因为swift中if没有非0即真，所以下面不能写成if a，否则会报错.
//而if a这行代码在oc中表示，a > 0，因为a的值为20嘛，所以在oc中不会报错
let a = 20

if a  {
    print("a大于0")
} else {
    print("a不大于0")
}

// 正确写法: 必须指定 a > 0还是 a < 0  还是 a == 0 
let a = 20

if a > 0  {
    print("a大于0")
} else {
    print("a不大于0")
}

swift和oc中的switch的区别

1，2，3，4，5是swift中的switch case:

1.switch后面的（）,可以省略不写
2.switch中的case的后面，不用加break，系统底层会自动加上break
3.switch后面的参数支持浮点型，字符串类型，所以case后面可以为浮点型和字符串类型，因为case后面的值的类型是和swtich后面的参数的类型是一致的(一直以来的规定)
4.switch中的case后面跟多个条件时,多个条件以,进行分割
5.switch中的case后面支持区间类型


---switch后面的参数支持浮点类型+多个条件用都好分隔开----

let sex = 0.5  //系统底层自动判断为浮点类型

switch sex {
case 0.5,0.8,20:  // 多个条件
    print("男")
case 0.7:
    print("女")
default:
    print("其他")
}


---浮点类型+switch中的case后面支持区间类型+逗号分隔多个条件----


let sex = 0.4

switch sex {
case 0.2...0.3: //区间是 0.2 ≤ sex ≤ 0.5
    print("男")
case 0.4..<0.6: //区间是  0.4 ≤ sex < 0.6
    print("女")
default:
    print("其他")
}

输出结果为：女


-----------switch后面的参数支持字符串类型----------

let m = 20
let n = 30

var result = 0

let opration = "+"

switch opration {
    case "+":
        result = m + n
    case "*":
        result = m * n
    case "-":
        result = m - n
    case "/":
        result = m / n
    default:
        print("非法操作符")
}

print(result)

输出结果为：50

• 泛型集合必须必须指定类型

• 可变数组和可变字典，必须得创建，利用[NSMubtableArray array];
  [NSMutableDictionary dictionary]这种形式创建，这样才能往里面存对象

• 注意:两个数组中内容的类型一致，可以进行相加合并，两个字典中内容的类型一致，不可以进行相加合并.

• 不懂：为什么定义字典用[] 还有什么时候用{ }

• 对象类型可以赋值nil，普通类型可以赋值为0

guard用法

/*
 guard的使用
    1.如果条件表达式为真,则会执行后面的语句
    2.如果条件表达式为假,则会执行else后面的{}中的语句
*/

// guard条件为真:年龄大于18，继续判断是否带了身份证，继续判断是否带了钱，如果都满足，就能上网
// guard条件为假: 年龄小于18，直接执行紧随其后的else，所以打印“回家去”，然后退出程序，不再往下执行
func online(age : Int) {
    // 1.判断年龄
    guard age > 18 else {
        print("回家去")
        return
    }
    
    // 2.判断是否带了身份证
    guard 带了身份证 else {
        print("回家拿身份")
        return
    }
    
    // 3.判断是否带钱了
    guard 带了钱 else {
        print("回家拿钱")
        return
    }
    
    // 语句块
    print("开机上网")
}

swift利用for循环打印内容+条件的简写

// 写法1:
// 打印结果:0,1,2,3,4,5,6,7,8,9
for var i = 0; i < 10; i++ {
    print(i)
}

// 写法2:
// 打印结果:0,1,2,3,4,5,6,7,8,9(包括0，因为是左闭右开)
for i in 0..<10 {
    print(i)
}

// 写法3: 如果i不需要使用可以使用_来代替
// 打印结果:10个hello swift
for _ in 0..<10 {
    print("hello swift")
}

// 写法4: 如果i不需要使用可以使用_来代替
// 打印结果:11个hello swift
for _ in 0...10 {
    print("hello swift")
}

swift字符串基本使用

51-02.png

swift字符串截取

51-03.png

swift数组基本使用

51-04.png

swift遍历数组

51-05.png

swift字典基本使用

51-06.png

swift遍历字典

51-07.png

元组的使用

51-08.png

可选类型作用

51-09.png

特别注意：

• 以下面截图1的方式创建Swift的playground文件和以截图2的方式创建Swift文件是有区别的
• 截图1

51-10.png

• 截图2

51-11.png

• 总结：
• 1.Swift文件，访问属性必须写在类的函数体{}内，不能在函数体外访问属性.函数体不是最外层的{}哦
• 2.playground就没有这样的限制，playground只是让你体验一下的，让你玩一下的，所以要求不严格。

swift中，函数名后面一定有(),浪费 4小时

函数是系统底层的函数，一定在函数前面加override(重写)

class Person:NSObject{
 override init(){
        
    }
}

函数是自己定义的函数，函数前面不要加override

func myInfo(name : String,age : Int, score : Double){
    print("myInfo：name:\(name),age:\(age),score:\(score)")
    
    }

声明属性一定要写在当前类的最外层的{ }

class Person:NSObject {
    var name : String = " "
    var age  : Int = 0
    var score :Double = 0.0
}

访问属性，修改属性，不要写在当前类的最外层的{}

错误做法
class Person:NSObject {
    // 声明age并初始化age属性
    var age  : Int = 0
    
    let p = Student()
    // 访问age属性
    p.age = 100  // 提示 Expected declaration 错误
    
}

访问(修改)属性的代码一定要写在函数体里面，写在哪个类的函数体里面都可以[已验证]

• 例1:访问age属性的代码写在Person类的zb函数体里面

class Person:NSObject {
    // 声明age并初始化age属性
    var age  : Int = 0
    
    func zb(){
    let p = Student()
    // 访问age属性
    p.age = 100  
    }
}

• 例2:访问age属性的代码写在ViewController类的viewDidLoad函数体里面

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        
        let a = Student()
        a.age = 10
    }

}

声明自定义的函数，既可以写在Student类中，也可以写在Student的类扩展中

• 声明自定义的myInfo函数,写在Student类中

class Student: NSObject {
    func myInfo(name : String,age : Int, score : Double){
        ...............
    }
}

• 声明自定义的myInfo函数,写在Student的类扩展中

extension  Student{
    func myInfo(name : String,age : Int, score : Double){
        ...............
    }

}

Swift也分对象函数和类函数

• 效果截图

51-12.png

详情代码：

Student.swift文件

import UIKit

class Student: NSObject {
    var name : String = " "
    var age  : Int = 0
    var score :Double = 0.0
    
    func myInfo(name : String,age : Int, score : Double){// 1 对象函数
    print("myInfo：name:\(name),age:\(age),score:\(score)")
    
    }
    class func lsInfo(name : String,age : Int, score : Double) {// 2 类函数
         print( "lsInfo：name:\(name),age:\(age),score:\(score)")
    }
    // 修改age属性写在函数体外面,所以会报错。写在1,2,3,4,5,6函数体里面不会报错
   // let p = Student()
   // p.age = 10

}

// 类扩展:Student类的扩展。等价于OC的分类Category
extension  Student{
   // 类扩展中不能扩充属性，只能扩充函数，所以你声明属性sex提示错误
   // var sex : String = " "
        func mz(name : String,age : Int, score : Double){// 3 对象函数
     print("mzInfo：name:\(name),age:\(age),score:\(score)")
    }
       class func ww(name : String,age : Int, score : Double){// 4 类函数
        print("wwInfo：name:\(name),age:\(age),score:\(score)")
    }

    private func ml(name : String,age : Int, score : Double){ // 5 私有的对象函数
        print("mlInfo：name:\(name),age:\(age),score:\(score)")
    }
}
func test() { // 6
    let p = Student()
    p.myInfo("100", age: 22, score: 20)
    // 修改age属性属于test()函数中的内容，所以不会报Expected declaration的错误
    p.age = 250
    print(p.age)
}

ViewController.swift文件

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

    let stu = Student()
        // 对象调用对象函数
        stu.myInfo("zb", age: 22, score: 100.0)
        // 类调用类函数
        Student.lsInfo("ls", age: 35, score: 60)
        // 对象调用类扩展中的函数
        stu.mz("mz", age: 44, score: 70.0)
        // 类调用类扩展中的函数
        Student.ww("mz", age: 44, score: 70.0)
    
       // 对象试图调用类扩展中的私有函数,会提示错误
       // ml方法被private修饰,所以只能在Student类中使用,外界调用会提示错误
       //stu.ml("ml", age: 10, score: 37)
    }
}