Swift4 类与继承, 类型转换, 类型判断

最新推荐文章于 2021-12-15 15:59:25 发布

weixin_30292843

最新推荐文章于 2021-12-15 15:59:25 发布

阅读量269

点赞数

文章标签： swift c/c++

原文链接：http://www.cnblogs.com/lancgg/p/8510002.html

版权

创建: 2018/03/05

完成: 2018/03/07

更新: 2018/03/09 完善标题 [Swift4 类与继承, 类型转换] -> [Swift4 类与继承, 类型转换与判断]

补充指定final的属性/方法无法被子类重载

更新: 2018/03/30 修改标题 [Swift4 类与继承, 类型转换与判断] -> [Swift4 类与继承, 类型转换, 类型判断]

【任务表】TODO

类定义

类的概要

class 型名: 父类, 采用的协议 {
    变量/常量定义 // var/let
    构造函数定义
    方法定义
    其他定义  // 型, 属性, 索引subscript
}

例

class NullClass: ClassNameAchievable, CustomStringConvertible {
    var className: String {
        return "NullClass"
    }
    var description: String {
        return self.className
    }
    func printName() {
        print("printName: \(self)")
    }
}

● 只能继承一个父类

● 顺序随意

● 类的实例与闭包的实例是参照型

● 没有全项目构造函数, 不定义构造函数则只有默认构造函数(必须索所有属性都有初始值)

● 改变自身属性的函数不需要mutating

类实例是参照型, 改变自身是指改变自身所指。let的不能改变自身所指

构造体是值型, 改变自身属性也是改变自身

类的继承

● 只能继承一个父类

● 被继承的叫父类(super class), 继承的叫子类(sub class), 没有继承其他类的叫基类(base class)

注: C++里父类叫做基类(基底类)(base class)

● 不继承构造函数 继承属性(容纳型, 计算型), 方法, 索引subscript.

继承构造函数的特例: 没有指定构造函数 --> 继承父类所有构造函数

重写父类所有指定构造函数 --> 继承父类所有简易构造函数

　详细搜本博文: 构造函数的继承

● 重载父类的方法或属性加上override

适用于: 方法, 计算型属性, subscript

区分自身与父类的方法与实例: self, super

protocol ClassNameAchievable {
    var className: String { get }
}

class NullClass: ClassNameAchievable, CustomStringConvertible {
    var className: String {
        return "NullClass"
    }
    var description: String {
        return self.className
    }
}

class FirstChildClass: NullClass {
    override var className: String { // 重载计算型属性className
        return "FirstChildClass"
    }
}

动态结合与类型转换

动态结合: 运行时候判别类型进行条件分歧

判定是否是该类或者继承该类

as, as?, as!

普通型转换

as?

可能会失败, 失败返回nil

downcast可能会失败

as!

理论上可能会失败, 但是此处一定成功。失败则报错

downcast可能会失败

upcast: 朝上cast, cast成父类, 父父类等

downcast: 朝下cast, cast成子类等, 可能会失败

类方法与类属性

静态属性与静态方法

前面加static

用例: 静态属性设定默认值, 默认模式, 静态方法改变默认模式等

● 计算型属性和容纳型属性都可以定义

类属性与类方法

前面加class

区别:

● 属性: 只能定义计算型属性

● 子类可以改写类属性, 类方法

class NullClass {
    class var sampleStr: String { // 类属性
        return "NullClass"
    }
    
    class func getClassName() -> String { // 类方法
        return sampleStr
    }
}

class FirstChildClass: NullClass {
    override class var sampleStr: Str { // 改写类属性
        return "FirstChildClass"
    }

    override class func getClassName() -> String { // 改写类方法
        return "overrided " + sampleStr
    }
}

继承与方法的呼出

所有方法内部对其他类内部方法的呼出都相当于self.方法名(参数)

类方法与实例方法都是

class A {
    func getName() -> String {
        return "A"
    }

    func printName() {
        print(getName()) // 内部的呼出相当于self.方法名
    }
}

class B: A {
    override func getName() -> String {
        return "B"
    }
}

A().printName() // A
B().printName() // B

构造函数

指定初始函数和简易初始函数

init(参数) { //指定构造函数
    ... // 初始化该类新增的属性
    super.init(...)        // 没有父类时不需要这行
    ... //更改父类里的属性
}


convenience init(参数) { // 简易构造函数
    self.init(参数)  // 先呼出带有指定构造函数的函数
    ...  // 变更所有需要变更的属性
}

● 指定构造函数(designated initializer): 仅靠来初始化的构造函数

基类的默认构造函数是指定构造函数

　　　　 类不可用全项目构造函数(违反封装原则)

简易构造函数(convenience initializer): 呼出本类的其他构造函数再进行附加处理的构造函数

● 子类必须含有至少一个指定构造函数(只呼出父类的某个指定构造函数, 不呼出本类的其他构造函数)

● 父类的指定构造函数改为简易构造函数的重载加override convenience, 关键词顺序不限

父类的简易构造函数的重载不要override, 因为不会被子类呼出

class Sample {
    var a:Int
    init(a: Int) { // 指定构造函数
        self.a = a
    }
}


class Sample2: Sample {
    var b: Int
    init(a: Int, b: Int) { // 指定构造函数
        self.b = b
        super.init(a: a)
    }

    override convenience init(a:  Int) { // 改为简易构造函数重载, 关键词顺序不限
        self.init(a: a, b: 0)
    }
}

● 构造函数是否相同只看参数数量, 参数名(最外侧标签), 参数型

无视是否可失败

init(a: Int) {
    ...
}

init(a aaaa: Int)? { // 两个被看成相同
    ...
}

初始化的步骤和规则

● (a)指定构造函数必须先初始化新增的属性才能呼出super.init(...)

(b)指定构造函数不能在super.init(...)之前设定super里有的属性

init(参数) { //指定构造函数
    ... // 初始化该类新增的属性
    super.init(...)
    ... //更改父类里的属性
}

● 简易构造函数必须先self.init(...), 也就是必须先呼出指定构造函数/呼出内部呼出指定构造函数的简易构造函数

　因为指定构造函数运行完以前的设定会被更改

由此简易构造函数不能设定let量

convenience init(参数) { // 简易构造函数
    self.init(参数)  // 先呼出带有指定构造函数的函数
    ...  // 变更所有需要变更的属性
}

● 所有属性初始化完成以前不能使用实例变量, 实例方法, 不能把self作为值来用

　用的话写成更外层的函数(如全局函数)或写成静态方法/类方法

● 不可生成指定构造函数和简易构造函数的合体构造函数

不可用条件分歧(if等)既有super.init(...) 呼出父类指定构造函数,

　也有self.init(...) 呼出自身的其他构造函数

构造函数的继承

满足一下任意条件则继承一部分

● 子类一个指定构造函数也没有

继承所有指定构造函数 -> 继承所有简易构造函数

-> 继承所有构造函数

● 子类带有父类所有指定函数

　(a) 和上面一样, 子类一个指定构造函数也没有。

(b) 子类重载了所有指定构造函数

继承所有简易构造函数

总结: 只新建简易构造函数则继承父类所有构造函数

没有指定构造函数 --> 继承父类所有构造函数

重写父类所有指定构造函数 --> 继承父类所有简易构造函数

可能会失败的构造函数

类, 构造体可以定义init?(...) { ... }

● 呼出父类的可失败构造函数的也变成可失败构造函数

因为失败时 return nil , 整个构造函数都结束

● 构造函数是否相同只看参数数量, 参数名(最外侧标签), 参数型

无视是否可失败

init(a: Int) {
    ...
}



init(a aaaa: Int)? { // 两个被看成相同
    ...
}

必须构造函数

required initializer

所有子类都必须带的构造函数, 名字前加上required

required init(...) {
    ...
}

● 重载不需要override, 因为所有子类都必须具有

● 子类的该构造函数也必须加上required

● 多个关键词是顺序不限

required convenience init(...) { ... }

convenience required init(...) { ... } // 两者一样, 关键词顺序不限

排他性法则

同一个变量同时只接受一个可读写的接入

目的: 增加安全性

var sampleArray = [1, 2, 3]
swap(&sampleArray[0], &sampleArray[2]) // 报错

sampleArray.swapAt(0, 2) // 用swapAt(_:_:)

继承与子类的定义

属性的继承

class Sample1 {
    var a: Int = 0
}

class Sample2: Sample1 {
    override var a: Int {
        get {
            return super.a // super获取上一级
        }
        set {
            super.a = newValue
        }
    }
}

可以以计算型属性来重载父类的计算型, 容纳型属性

● 获取父类的属性 super.属性名

● 容纳型属性是重载必须同时有get, set

● 计算型属性重载

只有get ---> { get }， { get set } 都可

{get set} ---> 必须{ get set}

索引的继承

subscript

class Sample1 {
    let array = [1, 2 ,3 ,4 ,5]
    subscript(id: Int) -> Int? {
        return id < array.count ? array[id] : nil
    }
}

class Sample2: Sample1 {
    override subscript(id: Int) ->Int { // 重载索引
        return id < self.array.count ? (super[id]! * super[id]!) : nil
    }
}

● 获取父类的索引: super[索引]

继承与属性监听

可以添加属性监听, 加override

● 可加在父类的容纳型属性与计算型属性里

只可读属性不可加监听

● 同类内部同一个属性, { get set } { didSet willSet } 不可共存

● 重载以后原监听不会失效。按从进到远顺序运行

不允许重载的设定

加上关键词finnal

● 可用于类, 类属型, 类方法

指定final的无法被继承, 指定final的属性/方法无法被重载

final class Sample { // 指定final的无法被继承
    // 指定final的属性/方法无法被重载
    final var property: Int = 0  // 指定final的属性
    final func sample() -> Bool { // 指定final的方法
        return false
    }
}

● 优点: 减少动态结合，提高运行速度

缺点: 不好维护(不好扩张和继承)

类与协议

类来实现协议时

	类	构造体
static 属性/方法	可以以静态或类属性/方法来实现 static/class	以静态属性/方法来实现 static
mutating	参照型，不需要mutating	改变自身要加mutating
构造函数	成为必须构造函数 required ● 带final的不需要required, 因为不会被继承	构造函数来实现

为类定义准备的协议

● 只有类, 结构体, 枚举型可以采用协议

● 只运行类采用的协议定义方法

protocol 协议名: class, 继承的协议 { // 协议名后加上class
    ... // 方法不用也不能附mutating
}

类与型

类型转换运算符

cast operator

is	式 is T	左边是否是是T型或者T的子类，左边是否继承了T协议
as	式 as T	转换为typealias声明的型, ObjC的兼容的型等必须一定会成功 ● 无视元组标签带不带标签都不影响转换 ● upcast用as, 即从子类转为父类, 父父类等... ● 不可用于downcast, 即转为子类 # TODO: Supply: [T是协议时的情况]
as?	式 as? T	● downcast专用, 失败返回nil 即转为子类 ● upcast一定成功, 用as?/as!会有警告 # TODO: Supply: [T是协议时的情况]
as!	式 as! T	● downcast专用, 失败报错

分歧语法与类型转换

case let/var 变量名 as 型

● 例

switch sample { // 子类放在上方
    case let s = sample as FirstChildClass: // 是FirstChildClass或子类
        ...
    case let s = sample as NullClass: // 是NullClass或其子类
        ...
    default:
        ...
}

● if-let和if-case的例

if let v = obj as? Sample { // if-let, if-var
    ...
}


if case let v as Sample = obj { // if-case
    ...
}

● case条件写的时候和switch里一样, 加上 = 测试对象

case (1, 1..<100) = (x, y)

meta type和dynamic type

dynamic type

也叫type instance, 型自身的实例

程序里所有的类型. 等都相当于类型.self. 等

占内存, 是实体

获取	类型.self ● 实例.self 返回实例自己, 不是类型 "hello".self // "hello" 1.self // 1
获取	type(of: 型实例) type(of: Int(1)) // Int.self print(type(of: Int(1))) // Int ● 可用于所有数据类型 (类与结构体) (除类与闭包外所有数据都是结构体)

● 判断类型时使用的是类型实例

type(of: Int(1)) == Int.self // true

meta type

类型本身, 不占内存

类型.Type

● 协议.Protocol 获取协议的meta type(原型), 表示该协议自身meta type

● 协议作型时, 协议.Type 表示采用该协议的型

(协议内部不能有附属型 associatedtype , 不能有 Self )

具体型为采用该协议的型

class Sample: CustomStringConvertible { ... }
var type: CustomStringConvertible.Type = Sample.self // 协议型

继承与Self

● Self只可用于class内部函数的返回型和protocol

● Self表示当前的类

协议与类的合成

typealias Sample = ClassAndTypeTest & CustomStringConvertible & Equatable

表示采用协议的类或其子类

类似于协议的合成

继承与类型推导

● 包含不同型元素的数组

AnyObject: 任何类的型

Any: 任何类的型与任何构造体

var array1: [AnyObject] = [ ClassA(), ClassB(), ClassC() ]

var array2: [Any] = [ ClassA(), 1, "Hello" ]

● 获取时要自己类型转换, as/as?/as!

● AnyObject主要用于和Objc交换信息

继承Obejctive-C类

和正常继承一样

● 除了可用继承类的功能, 还可用作为Obejctive-C类的功能

只是想要作为ObjC类来用的话继承NSObject

释放时的处理

释放时的处理与析构函数

● 必要性

读写文件的变量释放前关闭文件等, 动态释放内存

析构函数的定义

deinit {
    ...
}

● 释放前自动呼出, 只呼出一次

● 从最下层子类一层层往上呼出

没定义的地方跳过, 继续网上

● 内部处理不限, 但不能妨碍释放(如把要释放的实例代入到全局变量等)

析构函数的例

class DeinitSampleClass {
    deinit {
        print("deinited")
    }
}


var deinitTest: DeinitSampleClass? = DeinitSampleClass()
deinitTest = nil
deinitTest = DeinitSampleClass()
deinitTest = nil
deinitTest = DeinitSampleClass()


/*输出结果
----------------
deinited
deinited
deinited
/*