美文网首页
Swfit-04.类,元类,错误处理,泛型,拓展。。。

Swfit-04.类,元类,错误处理,泛型,拓展。。。

作者: Fight_ing | 来源:发表于2020-12-18 17:17 被阅读0次
    tree_23.jpg
    • 31. X.self、X.Type、AnyClass
      • X.self(对应OC中的类对象)是一个元类型(metadata)的指针，metadata存放着类型相关信息
      • X.self属于X.Type类型(对应OC中的元类对象)
    class Person {}
class Student : Person {}
var perType: Person.Type = Person.self 
var stuType: Student.Type = Student.self 
perType = Student.self

var anyType: AnyObject.Type = Person.self 
anyType = Student.self

public typealias AnyClass = AnyObject.Type 
var anyType2: AnyClass = Person.self 
anyType2 = Student.self

var per = Person()
var perType = type(of: per) // Person.self 
print(Person.self == type(of: per)) // true

  
//元类型的应用
class Animal { required init() {} } 
class Cat : Animal {}
class Dog : Animal {}
class Pig : Animal {}
func create(_ clses: [Animal.Type]) -> [Animal] { 
    var arr = [Animal]()
    for cls in clses {
        arr.append(cls.init()) 
    }
    return arr 
}
print(create([Cat.self, Dog.self, Pig.self]))
    • Swift还有个隐藏的基类:Swift._SwiftObject 源码连接
    • 32.大写Self
    Self
// Self代表当前类型
class Person {
    var age = 1
    static var count = 2
    func run() {
        print(self.age) // 1
        print(Self.count) // 2 等价于Person.count
    }
}
// Self一般用作返回值类型，限定返回值跟方法调用者必须是同一类型(也可以作为参数类型)
protocol Runnable { 
    func test() -> Self
}
class Person : Runnable {
    required init() {}
    func test() -> Self { 
        type(of: self).init() 
    } 
}
class Student : Person {}
var p = Person() 

// Person 
print(p.test())

var stu = Student() 
// Student 
print(stu.test())
    • 33.错误处理
      • 自定义错误:
    // Swift中可以通过Error协议自定义运行时的错误信息
enum SomeError : Error {
    case illegalArg(String) 
    case outOfBounds(Int, Int) 
    case outOfMemory
}
// 函数内部通过throw抛出自定义Error，可能会抛出Error的函数必须加上throws声明
 func divide(_ num1: Int, _ num2: Int) throws -> Int { 
    if num2 == 0 {
        throw SomeError.illegalArg("0不能作为除数")
    }
    return num1 / num2
}
// 需要使用try调用可能会抛出Error的函数
var result = try divide(20, 10)
    • 处理Error的3种方式：

    1 通过do-catch捕捉Error
    2 不捕捉Error，在当前函数增加throws声明，Error将自动抛给上层函数， 如果最顶层函数(main函数)依然没有捕捉Error，那么程序将终止
    3 可以使用try?、try!调用可能会抛出Error的函数，这样就不用去处理Error

    • 抛出Error后，try下一句直到作用域结束的代码都将停止运行

    • rethrows
      rethrows表明:函数本身不会抛出错误，但调用闭包参数抛出错误，那么它会将错误向上抛

    func exec(_ fn: (Int, Int) throws -> Int, _ num1: Int, _ num2: Int) rethrows { 
    print(try fn(num1, num2))
}
// Fatal error: Error raised at top level
try exec(divide, 20, 0)
    • defer
    1. defer语句:用来定义以任何方式(抛错误、return等)离开代码块前必须要执行的代码
    2. defer语句将延迟至当前作用域结束之前执行
    // defer语句的执行顺序与定义顺序相反
func test() {
    defer { fn1() }
    defer { fn2() }
}
test()
// fn2
// fn1
    • assert(断言)
    1. 很多编程语言都有断言机制:不符合指定条件就抛出运行时错误，常用于调试(Debug)阶段的条件判断
    2. 默认情况下，Swift的断言只会在Debug模式下生效，Release模式下会忽略

    增加Swift Flags修改断言的默认行为
    p-assert-config Release:强制关闭断言
    p-assert-config Debug:强制开启断言

    • fatalError
    1. 如果遇到严重问题，希望结束程序运行时，可以直接使用fatalError函数抛出错误(这是无法通过do-catch捕捉的错误)
    2. 使用了fatalError函数，就不需要再写return
    3. 在某些不得不实现、但不希望别人调用的方法，可以考虑内部使用fatalError函数
    • 34.泛型
      • 泛型可以将类型参数化，提高代码复用率，减少代码量
      // 泛型函数赋值给变量
func swapValues<T>(_ a: inout T, _ b: inout T) { (a, b) = (b, a) }
      • 关联类型(Associated Type)
        关联类型的作用:给协议中用到的类型定义一个占位名称。就是协议中泛型的实现
        协议中可以拥有多个关联类型
       protocol Stackable {
     associatedtype Element // 关联类型 
     mutating func push(_ element: Element) 
     mutating func pop() -> Element
     func top() -> Element
     func size() -> Int
 }
 class StringStack : Stackable {
     // 给关联类型设定真实类型
     // typealias Element = String
     var elements = [String]()
     func push(_ element: String) { elements.append(element) } 
     func pop() -> String { elements.removeLast() }
     func top() -> String { elements.last! }
     func size() -> Int { elements.count } 
 }
 var ss = StringStack() 
 ss.push("Jack") 
 ss.push("Rose")
      • where类型约束
      protocol Stackable {
 associatedtype Element: Equatable
}
class Stack<E : Equatable> : Stackable { typealias Element = E }

func equal<S1: Stackable, S2: Stackable>(_ s1: S1, _ s2: S2) -> Bool 
 where S1.Element == S2.Element, S1.Element : Hashable {
 return false
}
      • 协议类型的注意点
      • some 不透明类型应用
       泛型解决
 // 解决方案1:使用泛型
 func get<T : Runnable>(_ type: Int) -> T { 
     if type == 0 {
         return Person() as! T
     }
     return Car() as! T
 }
 var r1: Person = get(0)
 var r2: Car = get(1)

 不透明类型(Opaque Type): 屏蔽内部实现细节
 // 解决方案2:使用some关键字声明一个不透明类型
 // some限制只能返回一种类型
 func get(_ type: Int) -> some Runnable { 
     Car() 
 } 
 var r1 = get(0)
 var r2 = get(1)
    
 // some
 // some除了用在返回值类型上，一般还可以用在属性类型上
 protocol Runnable { associatedtype Speed }
 class Dog : Runnable { typealias Speed = Double }
 class Person {
     var pet: some Runnable {
         return Dog()
     } 
 }
      • 可选项的本质是enum类型
       public enum Optional<Wrapped> : ExpressibleByNilLiteral { 
     case none // nil
     case some(Wrapped) // 关联值
     public init(_ some: Wrapped) 
 }

 var age: Int? = .none 
 age = 10
 age = .some(20)
 age = nil

 var age: Int? = 10
 var age0: Optional<Int> = Optional<Int>.some(10)
 var age1: Optional = .some(10)
 var age2 = Optional.some(10)
 var age3 = Optional(10)

 age = nil
 age3 = .none

 // 两种判断nil的写法

 switch age {
     // 默认会解包
     case let v?:
         print("some", v)
     case nil:
         print("none")
 }

 switch age {
     case let .some(v):
     print("some", v) 

     case .none:
     print("none")
 }
    • 35. 关于String的本质探索
      // 字符串长度 <= 0xF(15)，字符串内容直接存放在str1变量的内存中。（类似OC中的tagger pointer 技术）
 var str1 = "0123456789"
 
 // 字符串长度 > 0xF，字符串内容存放在__TEXT.cstring中（常量区）
 // 字符串的地址值信息存放在str2变量的后8个字节中
 var str2 = "0123456789ABCDEF"
 
 // 由于字符串长度 <= 0xF，所以字符串内容依然存放在str1变量的内存中
 str1.append("ABCDE")
 // 开辟堆空间
 str1.append("F")
 
 // 开辟堆空间
 str2.append("G")
    • 36.call，jmp指令区别

    • call会把他的下一条指令的地址压入堆栈，然后跳转到他调用的开始处，同时ret会自动弹出返回地址。

    • JMP只是简单的跳转
      call的本质相当于push+jmp ret的本质相当于pop+jmp

    • 37.高级运算符
      • 溢出运算符(Overflow Operator)：
    1. Swift的算数运算符出现溢出时会抛出运行时错误
    2. Swift有溢出运算符(&+、&-、&*)，用来支持溢出运算 
       var min = UInt8.min
 print(min &- 1) // 255, Int8.max
 var max = UInt8.max
 print(max &+ 1) // 0, Int8.min 
 print(max &* 2) // 254, 等价于 max &+ max
 // 逐渐递增
 UInt8.min 0
 UInt8.max 255
      • 运算符重载(Operator Overload):
        • 类、结构体、枚举可以为现有的运算符提供自定义的实现，这个操作叫做:运算符重载
          struct Point : Equatable {
     var x = 0, y = 0
     static func + (p1: Point, p2: Point) -> Point {
         Point(x: p1.x + p2.x, y: p1.y + p2.y)
     }
     static func - (p1: Point, p2: Point) -> Point {
         Point(x: p1.x - p2.x, y: p1.y - p2.y)
     }
     static prefix func - (p: Point) -> Point {
         Point(x: -p.x, y: -p.y)
     }
     static func += (p1: inout Point, p2: Point) {
         p1 = p1 + p2
     }
     static prefix func ++ (p: inout Point) -> Point {
         p += Point(x: 1, y: 1)
         return p
     }
     static postfix func ++ (p: inout Point) -> Point {
         let tmp = p
         p += Point(x: 1, y: 1)
         return tmp
     }
 }
      • Equatable:
        • 要想得知2个实例是否等价，一般做法是遵守Equatable 协议，重载== 运算符
        • 与此同时，等价于重载了 != 运算符
        • Swift为以下类型提供默认的Equatable 实现
        1. 没有关联类型的枚举
        2. 只拥有遵守 Equatable 协议关联类型的枚举
        3. 只拥有遵守 Equatable 协议存储属性的结构体
        • 引用类型比较存储的地址值是否相等(是否引用着同一个对象)，使用恒等运算符=== 、!==
      • Comparable
        • 要想比较2个实例的大小，一般做法是: 1.遵守 Comparable 协议 2.重载相应的运算符
        // score大的比较大，若score相等，age小的比较大 
  struct Student : Comparable {
     var age: Int
     var score: Int
     init(score: Int, age: Int) {
     self.score = score
     self.age = age 
     }
     static func < (lhs: Student, rhs: Student) -> Bool { 
         (lhs.score < rhs.score)
         || (lhs.score == rhs.score && lhs.age > rhs.age)
     }
     static func > (lhs: Student, rhs: Student) -> Bool {
         (lhs.score > rhs.score)
         || (lhs.score == rhs.score && lhs.age < rhs.age)
     }
     static func <= (lhs: Student, rhs: Student) -> Bool {
         !(lhs > rhs) 
     }
     static func >= (lhs: Student, rhs: Student) -> Bool { 
         !(lhs < rhs)
     } 
 }

 var stu1 = Student(score: 100, age: 20) 
 var stu2 = Student(score: 98, age: 18) 
 var stu3 = Student(score: 100, age: 20) 
 print(stu1 > stu2) // true
 print(stu1 >= stu2) // true
 print(stu1 >= stu3) // true
 print(stu1 <= stu3) // true
 print(stu2 < stu1) // true
 print(stu2 <= stu1) // true
      • 自定义运算符(Custom Operator)
        • 可以自定义新的运算符:在全局作用域使用operator进行声明
       prefix operator 前缀运算符
 postfix operator 后缀运算符
 infix operator 中缀运算符 : 优先级组
 precedencegroup 优先级组 {
     associativity: 结合性(left\right\none)
     higherThan: 比谁的优先级高
     lowerThan: 比谁的优先级低
     assignment: true代表在可选链操作中拥有跟赋值运算符一样的优先级
 }

 prefix operator +++
 infix operator +- : PlusMinusPrecedence 
 precedencegroup PlusMinusPrecedence {
     associativity: none
     higherThan: AdditionPrecedence 
     lowerThan: MultiplicationPrecedence 
     assignment: true
 }
      Apple文档参考1
      Apple文档参考2
      • 示例：
       struct Point {
     var x: Int, y: Int
     static prefix func +++ (point: inout Point) -> Point {
         point = Point(x: point.x + point.x, y: point.y + point.y)
         return point
     }
     static func +- (left: Point, right: Point) -> Point { 
         return Point(x: left.x + right.x, y: left.y - right.y)
     }
     static func +- (left: Point?, right: Point) -> Point {
         print("+-")
         return Point(x: left?.x ?? 0 + right.x, y: left?.y ?? 0 - right.y) 
     }
 }
 struct Person {
     var point: Point
 }
 var person: Person? = nil 
 person?.point +- Point(x: 10, y: 20)
    • 38. 扩展(Extension)

      • Swift中的扩展，有点类似于OC中的分类(Category)

      • 扩展可以为枚举、结构体、类、协议添加新功能

      • 可以添加方法、计算属性、下标、(便捷)初始化器、嵌套类型、协议等等

      • 扩展不能办到的事情:

      不能覆盖原有的功能
      不能添加存储属性，不能向已有的属性添加属性观察器
      不能添加父类
      不能添加指定初始化器，不能添加反初始化器
      ...

      • 协议拓展
        扩展可以给协议提供默认实现，也间接实现『可选协议』的效果
        扩展可以给协议扩充『协议中从未声明过的方法』
      • 注意下面代码的打印信息：
       protocol TestProtocol {
     func test1()
 }
 extension TestProtocol {
     func test1() { 
         print("TestProtocol test1")
     }
     func test2() {
         print("TestProtocol test2")
     }
 }
 class TestClass : TestProtocol {
     func test1() { 
         print("TestClass test1") 
     } 
     func test2() { 
         print("TestClass test2") 
     }
 }
 var cls = TestClass()
 cls.test1() // TestClass test1 
 cls.test2() // TestClass test2

 var cls2: TestProtocol = TestClass() 
 cls2.test1() // TestClass test1 
 cls2.test2() // TestProtocol test2
      • 泛型拓展： 
          // 符合条件才扩展(只有Stack中的元素遵守Equatable协议，拓展才有效)
extension Stack : Equatable where E : Equatable {
  static func == (left: Stack, right: Stack) -> Bool { 
      left.elements == right.elements
  } 
}
    • 39.访问控制(Access Control)
      • 在访问权限控制这块，Swift提供了5个不同的访问级别(以下是从高到低排列， 实体指被访问级别修饰的内容)

    open:允许在定义实体的模块、其他模块中访问，允许其他模块进行继承、重写(open只能用在类、类成员上)
    public:允许在定义实体的模块、其他模块中访问，不允许其他模块进行继承、重写
    internal:只允许在定义实体的模块中访问，不允许在其他模块中访问
    fileprivate:只允许在定义实体的源文件中访问
    private:只允许在定义实体的封闭声明中访问
    绝大部分实体默认都是internal 级别

    • 访问级别的使用准则:一个实体不可以被更低访问级别的实体定义

    1.元祖，泛型都以最低那个为准
    2.协议实现不得小于协议和类中的较小的那个
    3.枚举不能每项单独定义
    4.public 限定作用域内部默认是internal
    5.required初始化器 ≥ 它的默认访问级别

    • 直接在全局作用域下定义的private等价于fileprivate
    • 40.内存管理
    • 跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案(针对堆空间)
    • Swift的ARC中有3种引用:

      • 1.强引用(strong reference):默认情况下，引用都是强引用

      • 2.弱引用(weak reference):通过weak定义弱引用

        • 必须是可选类型的var，因为实例销毁后，ARC会自动将弱引用设置为nil
        • ARC自动给弱引用设置nil时，不会触发属性观察器

      • 3.无主引用(unowned reference):通过unowned定义无主引用

        • 不会产生强引用，实例销毁后仍然存储着实例的内存地址(类似于OC中的unsafe_unretained)
        • 试图在实例销毁后访问无主引用，会产生运行时错误(野指针)
          • Fatal error: Attempted to read an unowned reference but object 0x0 was already deallocated

      • 用inout输入输出参数时，注意内存访问冲突问题

      • 内存访问冲突(Conflicting Access to Memory)

    内存访问冲突会在两个访问满足下列条件时发生:
    至少一个是写入操作
    它们访问的是同一块内存
    它们的访问时间重叠(比如在同一个函数内)

        // 不存在内存访问冲突
    func plus(_ num: inout Int) -> Int { num + 1 } var number = 1
    number = plus(&number)

    // 存在内存访问冲突
    // Simultaneous accesses to 0x0, but modification requires exclusive access var step = 1
    func increment(_ num: inout Int) { num += step }
    increment(&step)

    // 解决内存访问冲突
    var copyOfStep = step 
    increment(&copyOfStep) 
    step = copyOfStep

    以上均根据CoderMJLee老师的视频及资料整理，祝小码哥教育越来越好，特此感谢！！！

    如有侵权，请联系删除：fm939071955@163.com

    相关文章

      网友评论

          本文标题：Swfit-04.类,元类,错误处理,泛型,拓展。。。

          本文链接：https://www.haomeiwen.com/subject/ayctnktx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|Swfit-04.类,元类,错误处理,泛型,拓展。。。|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！