swift之方法&下标&继承重写

最新推荐文章于 2021-02-28 14:23:57 发布
最新推荐文章于 2021-02-28 14:23:57 发布
阅读量369 收藏
点赞数
分类专栏： swift 文章标签： swift subscript func overwrite
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blances/article/details/106029391
版权
macos 同时被 2 个专栏收录
16 篇文章 0 订阅
订阅专栏
swift
14 篇文章 0 订阅
订阅专栏

swift之方法、下标、继承

一、方法

1.1-什么是方法

/*
枚举、结构体、类都可以定义实例方法、类型方法
实例方法：通过实例调用
	需要创建实例后调用的方法
类型方法：通过类型调用，用static或者class关键字定义
	static func getCount() -> Int{count}
	直接调用，类名.方法调用

self在实例方法中代表实例对象，在类型方法中代表类型
Person->static var count=0在类型方法中count=self.count=Person.self.count=Person.count
*/
class Person{
    static var count=0
    init(){
        Person.count+=1
    }
    static func getCount()->Int{ count }
}
let p1=Person()
let p2=Person()
let p3=Person()
print(Person.getCount())
3

1.2-mutating(值类型方法修改自身属性)

/*
结构体和枚举是值类型，默认情况下，值类型的属性不能被自身的实例方法修改
在func关键字前加mutating可以允许修改
*/
struct Person {
    var height=180,weight=140
    mutating func grow(_ h:Int,_ w:Int){
        height += h
        weight += w
        //self=Person(height:height+h,weight:weight+w)
    }
}
var p = Person()
p.grow(5, 5)
print(p.height,p.weight)
185 145

enum Person {
    case child,old,young
    mutating func grow(){
        switch self {
        case .child:
            self = .young
        case .young:
            self = .old
        case .old:
            self = .old
        }
    }
}
var p=Person.child
p.grow()
print(p)
young

1.3-@discardableResult(忽略警告)

/*

*/
//Result of call to 'getCount()' is unused
class Person{
    var count=0
    @discardableResult
    func getCount()->Int{ 1 }
}
var p = Person()
p.getCount()

@discardableResult
func run()->Int{
    //process
    10
}
run()

二、下标

2.1-什么是下标

/*
使用subscript可以给人以类型增加下标功能，下标脚本
语法类似于实力方法、计算属性、本质就是方法（函数）
subscript中定义了返回值类型决定了get方法的返回值类型和set中的newValue的类型
subscript可以接受多个参数并任意类型
*/


class Person{
    var height=180,weight=140
    subscript(type:Int)->Int{
        set{
            if type==0{
                height=newValue
            } else if type==1{
                weight=newValue
            }
        }
        get{
            if type==0{
                return height
            } else if type==1{
                return weight
            }
            return 0
        }
    }
}
var p = Person()
print(p[0],p[1])
p[0]=175
p[1]=120
print(p.height,p.weight)
180 140
175 120

2.2-下标的细节

/*
subscript可以没有set方法，但必须要有get方法，如果只有get方法可以省略get
subscript可以设置参数标签，下标也可以是类型方法
*/

class Person{
    var height=180,weight=140
    subscript(type:Int)->Int{
            if type==0{
                return height
            } else if type==1{
                return weight
            }
            return 0
    }
}
var p = Person()
print(p[0],p[1])
180 140

class Person{
    var height=180,weight=140
    subscript(type type:Int)->Int{
            if type==0{
                return height
            } else if type==1{
                return weight
            }
            return 0
    }
}
var p = Person()
print(p[type:0],p[type:1])
180 140

class Person{
    static subscript(height:Int)->Double{
        return Double(height)*0.7
    }
}
print(Person[185])
185

2.3-结构体、类做为返回值对比

/*
类是引用类型可以直接修改，结构体是值类型所以要set

*/

class Person{
    var height=0,weight=0
}
class Child{
    var person = Person()
    subscript(index:Int)->Person{
        get {person}
    }
}
var c = Child()
c[0].height=180
print(c[0].height,c[0].weight)
180 0


struct Person{
    var height=0,weight=0
}
class Child{
    var person = Person()
    subscript(index:Int)->Person{
        set {person=newValue}
        get {person}
    }
}
var c = Child()
c[0].weight=140
print(c[0].height,c[0].weight)
0 140

2.4-接受多个参数的下标

class Map{
    var data=[
        [0,1,2],
        [3,4,5],
        [6,7,8]
    ]
    subscript(row:Int,col:Int)->Int{
        set{
            guard row>=0 && row<3 && col>=0 && col < 3 else{
                return
            }
            data[row][col]=newValue
        }
        get{
            guard row>=0 && row<3 && col>=0 && col < 3 else{
                return 0
            }
            return data[row][col]
        }
    }
}
var m = Map()
print(m[1,2])
5
m[1,2]=55
print(m.data)
[[0, 1, 2], [3, 4, 55], [6, 7, 8]]

三、继承

3.1-什么是继承

/*
值类型（枚举、结构体）不支持继承，只有类支持继承
没有父类的类称为基类
swift并没有像oc、java规定任何类最终都要继承自某个基类
子类可以重写父类的下标、方法、属性，重写必须加上override
*/

3.2-内存结构

/*
一个属性8个字节,类信息头两行16字节,整体是16的倍数
*/
class Person{
    var age=0
}
class Child:Person{
    var weight=0
}
class Young: Child{
    var height=0
}
var p = Person()
p.age=1
/*
 0x0000000100008300
 0x0000000000000002
 0x0000000000000001
 0x0000000000000000
 */
var c=Child()
c.age=2
c.weight=2
/*
0x0000000100009302
0x0000000000000002
0x0000000000000002
0x0000000000000000
*/
var y = Young()
y.age=3
y.height=4
y.weight=5
/*
0x0000000100009531
0x0000000000000002
0x0000000000000003
0x0000000000000004
0x0000000000000005
0x0000000000000000
*/

3.3-重写实例方法、实例下标

/*
*/
class Person{
    func walk(){
        print("person walk")
    }
    subscript(index:Int)->Int{
        return index
    }
}
class Child:Person{
    override func walk(){
        super.walk()
        print("child walk")
    }
    override subscript(index: Int) -> Int {
        return super[index]+1
    }
}
var p:Person
p=Person()
p.walk()
person walk
print(p[3])
3
p=Child()
p.walk()
person walk
child walk
print(p[3])
4

3.4-重写类型方法、类型下标

/*
类方法既可用class来修饰，也可用static来修饰。
如果父类的类方法使用static修饰的话，子类不能重写这个类方法；
如果父类的类方法使用class修饰的话，子类能够重写这个类方法。
如果父类的类方法是使用final class修饰的话，子类不能重写这个类方法。
综上，static自带final class的性质。
你希望子类能够重写其父类的某个类方法，那就使用class修饰这个类方法。
你不希望子类能够重写其父类的某个类方法，那就使用static修饰这个类方法。
PS：
final class classMethod：可继承，但禁止子类重写其父类中的类方法
final intanceMethod：可继承，但禁止子类重写其父类中的对象方法
private：本类私有的方法或属性，子类不可继承
fileprivate：本文件私有的方法或属性，本文件外不可访问、继承
*/
class Person{
    class func walk(){
        print("person walk")
    }
    class subscript(index:Int)->Int{
        return index
    }
}
class Child:Person{
    override class func walk(){
        super.walk()
        print("child walk")
    }
    override class subscript(index: Int) -> Int {
        return super[index]+1
    }
}
Person.walk()
person walk
print(Person[1])
1
Child.walk()
person walk
child walk
print(Child[1])
2

3.5-重写属性

/*
子类可以将父类的属性（存储、计算）重写为计算属性，不能重写为存储属性
计算属性的本质是方法所以可以重写
只能重写var属性，不能重写let属性
重写时，属性吗、类型要一致

子类重写后的属性权限不能小于父类属性的权限
如果父类是只读的，那么子类重写后的属性可以是只读的也可以是可读写的
如果父类是可读写的，那么子类重写后必须是可读写的
*/

3.6-重写实例属性

/*

*/
class Square{
    var lenght:Int=0
    var perimeter:Int{
        set{
            print("Square.perimeter set")
            lenght=newValue/4
        }
        get{
            print("Square.perimeter get")
            return lenght*4
        }
    }
}
var square:Square
square=Square()
square.lenght=3
print(square.perimeter)
Square.perimeter get
12
square.perimeter=20
print(square.lenght)
Square.perimeter set
5


class SubSquare:Square{
    override var lenght: Int{
        set{
            print("SubSquare.lenght set")
            super.lenght=newValue>0 ? newValue:0
        }
        get{
            print("SubSquare.lenght get")
            return super.lenght
        }
    }
    override var perimeter: Int{
        set{
            print("SubSquare.perimeter set")
            super.perimeter=newValue>0 ? newValue:0
        }
        get{
            print("SubSquare.perimeter get")
            return super.perimeter
        }
    }
}
var ss=SubSquare()
ss.lenght=5
SubSquare.lenght set
print(ss.perimeter)
SubSquare.perimeter get
Square.perimeter get
SubSquare.lenght get
20
ss.perimeter=20
SubSquare.perimeter set
Square.perimeter set
SubSquare.lenght set
print(ss.lenght)
SubSquare.lenght get
5

3.7-属性观察器

/*
子类可以给父类的计算属性增加属性观察器，之前说的willSet和set不能共存原则但是可以在子类实现
不管父类是实例属性、类型属性、存储属性、计算属性都可以增加属性观察器
*/
class Square{
    var lenght:Int=0
}
class SubSquare:Square{
    override var lenght: Int{
        willSet{
            print("SubSquare.lenght willSet",newValue)
        }
        didSet{
            print("SubSquare.lenght didSet",oldValue)
        }
    }
}
var ss=SubSquare()
ss.lenght=20
SubSquare.lenght willSet 20
SubSquare.lenght didSet 0


class Square{
    var lenght:Int=0{
        willSet{
            print("Square.lenght willSet",newValue)
        }
        didSet{
            print("Square.lenght didSet",lenght)
    }
    }
}
class SubSquare:Square{
    override var lenght: Int{
        willSet{
            print("SubSquare.lenght willSet",newValue)
        }
        didSet{
            print("SubSquare.lenght didSet",lenght)
        }
    }
}
var ss=SubSquare()
ss.lenght=20
SubSquare.lenght willSet 20
Square.lenght willSet 20
Square.lenght didSet 20
SubSquare.lenght didSet 20


class Square{
    var lenght:Int{
        set{
            print("Square.lenght set",newValue)
        }
        get{
            print("Square.lenght get")
            return 11
        }
    }
}
class SubSquare:Square{
    override var lenght: Int{
        willSet{
            print("SubSquare.lenght willSet",newValue)
        }
        didSet{
            print("SubSquare.lenght didSet",lenght)
        }
    }
}
var ss=SubSquare()
ss.lenght=5
Square.lenght get
SubSquare.lenght willSet 5
Square.lenght set 5
Square.lenght get
SubSquare.lenght didSet 11

3.8-final

/*
被final修饰的方法、下标、属性禁止被重写
被final修饰的类禁止被继承
*/
class Square{
    var lenght:Int=0
    final subscript(index:Int)->Int{
        11
    }
    final func perimeter()->Int{
        return 22
    }
}
class SubSquare:Square{
    override var lenght:Int=1 //Cannot override with a stored property 'lenght'
    override subscript(index:Int)->Int{ //Subscript overrides a 'final' subscript
        return 111
    }
    override func perimeter()->Int{ //Instance method overrides a 'final' instance method
        return 222
    }
}
simon5169
关注
专栏目录
Swift：（十）、下标、继承、重写、构造方法
九天揽月
03-02 395
//一、下标：一个类型可以定义多个下标,通过不同索引类型进行重载。下标不限于一维,你可以定义具有多个入参的下标满足自定义类型的需求。//（1）、下标语法：与定义实例方法类似,定义下标使用 subscript 关键字,指定一个或多个输入参数和返回类型struct TimesTable {    let multiplier: Int    subscript(index: Int) -&gt; In...
Swift基础 重写父类已有的方法
乐事派的专栏
05-15 918
重写 重写方法 重写父类已有的方法，需要在方法名前加 override 的关键字。 class Person{ var age:Int var name:String init(name:String,age:Int){ self.name = name self.age = age } } class Student:Person{ var classScore:Dictionary<String,Int> =
iOS --- 下标和计算符重载（swift2.3）
yhy1271927580的博客
07-02 361
iOS — 下标和计算符重载（swift） 下面简单的介绍下标和计算符重载的应用下标基础 多维下标 运算符重载基础 重载比较运算符 自定义运算符 一：下标基础struct Vector3 { var x:Double = 0.0 var y:Double = 0.0 var z:Double = 0.0 subscript(index: Int) ->Double?{/
《从零开始学Swift》学习笔记（Day 46）——下标重写
关东升
12-09 93
原创文章，欢迎转载。转载请注明：关东升的博客   下标是一种特殊属性。子类属性重写是重写属性的getter和setter访问器，对下标的重写也是重写下标的getter和setter访问器。 下面看一个示例： c lass DoubleDimensionalArray { let rows: Int, columns: Int var grid: [I...
Swift教程之继承详解
09-03
在这个“Swift教程之继承详解”中，我们将深入探讨这个话题。 首先，一个类可以通过继承来获得父类的特性，包括方法、属性和下标。这种关系中，继承类被称为子类，而被继承的类称为父类或基类。Swift的类并不直接...
解析Swift语言面相对象编程中的继承特性
09-03
在Swift编程语言中，面向对象编程的一个核心概念是继承，它是构建复杂软件系统的基础。继承允许我们创建新的类，这些类不仅拥有已有类的特性，还可以添加新的功能或修改现有行为。通过继承，我们可以实现代码复用，...
Swift 继承
01-06
在 Swift 中，类可以调用和访问超类的方法，属性和下标脚本，并且可以重写它们。 我们也可以为类中继承来的属性添加属性观察器。 基类 没有继承其它类的类，称之为基类（Base Class）。 以下实例中我们定义了基类 ...
Swift重载和自定义运算符
imxiangzi的专栏
05-05 2330
最近一直边忙毕设边学Swift，终于看完了官方的教程（语言参考暂不打算看），在iBooks上做了一些笔记（看英文伤不起），感觉Swift是一门大杂烩类型的语言，我会记录一些我自认为以前遇到较少或者需要重点记忆的语法特性，在此作为分享，这次是运算符的重载，几乎每门语言都有，只是语法不一样罢了。 (2014-8-8更新至beta5语法) 运算符重载 在Swift的官方文档中运算符重载叫做
Swift自定义运算符的数学符号-Swift开发
05-27
Euler Euler在“数学符号”字符集中使用自定义运算符，以使用传统的数学符号实现功能。 请记住，这不打算或不建议用于生产。 自定义运算符Euler Euler在“数学符号”字符集中使用自定义运算符，以使用传统的数学符号实现功能。 请记住，这不打算或不建议用于生产。 任何种类的自定义运算符都容易被滥用和滥用，应谨慎使用，就像方法混乱或复杂的宏一样。 欧拉（Euler）更适合用于游乐场，在游乐场可以用于教学和学习逻辑与数学
swift5基本语法-方法/重写
u010707262的博客
02-28 300
一、方法 Swift中枚举、结构体、类都可以定义实例方法、类型方法。 实例方法(OC中的-减号方法)： 通过实例调用 类型方法(OC中的+加号方法)： 通过类型调用，用static或者class关键词定义。 实例方法实例： class Person { static var age = 0 init() { Person.age += 1 } ...
ios swift 继承_Swift中的继承
weixin_26638123的博客
08-27 261
ios swift 继承 什么是继承？ (What is Inheritance?) Inheritance allows a class to have the same behavior as of another class and extend that behavior to provide specific needs. 继承允许一个类具有与另一个类相同的行为，并扩展该行为以提供特定的...
Swift中的选项集合
小桥流水哗啦啦，iOS Coder 哒哒哒
08-21 920
Swift3中的选项集合（Option Set） 作者：Ole Begemann，原文链接，原文日期：2016/09/28 译者：Lanford3_3；校对：saitjr；定稿：CMB 选项集合在OC中的形态 对于位掩码[可以多选的]，Swift 给出的方案是：选项集合（option sets）。在 C 和 Objective-C 中，通常的做法是将一个布尔值选项集合表示为一系列值为 2
IOS开发Swift笔记12-继承
qq_25218777的博客
09-03 198
继承 值类型（枚举、结构体）不支持继承，只有类支持继承 没有父类的类，称为：基类 Swift并没有想OC，Java那样的规定：任何类最终都要继承自某个基类 子类可以重写父类的下标、方法、属性，重写必须加上override关键字 class Animal { var age = 0 } class Dog: Animal { var weight = 0 } class ErHa: Dog { var iq = 0 } let a = Animal() a.age = 10 p
Swift 继承 override重写父类方法以及属性 final用法
chenzheiu1210的博客
11-07 8434
var str = "Hello, playground" class Fruit { var speed : Double = 0 func info() -> () { print("fruit111111.............") } //修饰词 final 表示 不可重写 可以将类或者类中的部分实现保护起来,从而避免子类破坏
Swift中重写重载构造(初始化)方法
weixin_30892889的博客
04-25 758
引自 https://www.jianshu.com/p/5c133b123c74 转载于:https://www.cnblogs.com/-WML-/p/8945087.html
Swift-重写与重载的使用和比较
Mazy's Blog
11-28 5159
1、重载: 函数名相同，参数名／参数类型／参数个数不同 重载函数并不仅仅局限于构造函数 函数重载是面相对象程序设计语言的重要标志 OC 不支持函数重载，OC 的替代方式是 withXXX… 2、重写： 也叫覆盖，指在子类中定义一个与父类中方法同名同参数列表的方法。 重写是子类的方法覆盖父类的方法，要求方法名和参数都相同 因为子类会继承父类的方法，而重写就是将从父类继承过来的方法重新定义一次，重新填写
Swift编程：深入解析继承机制
在Swift编程语言中，继承是一种面向对象编程的关键特性，允许一个类（子类）获取另一个类（父类）的特性，包括属性、方法和下标。这种方式使得代码复用和扩展变得更加简单。继承不仅能够减少重复代码，还能在不改变...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值