android开发分享Swift继承Inheritance浅析介绍

继承(inheritance)1、值类型(枚举、结构体)不支持继承,只有类支持继承2、没有父类的类,称为:基类swift并没有像oc、java那样的规定:任何类最终都要继承自某个基类。3、子类可以重写

上述就是android开发分享Swift继承Inheritance浅析介绍的全部内容,如果对大家有所用处且需要了解更多关于Android学习教程,希望大家多多关注—计算机技术网(www.ctvol.com)!

继承(inheritance)

1、值类型(枚举、结构体)不支持继承,只有类支持继承

2、没有父类的类,称为:基类

swift并没有像oc、java那样的规定:任何类最终都要继承自某个基类。

3、子类可以重写父类的下标、方法、属性,重写必须加上override关键字。

内存结构

class animal {      var age = 0  }  class dog : animal {      var weight = 0  }  class erha : dog {      var iq = 0  }
let a = animal()  a.age = 10

看一下a需要多少内存,a是堆空间的,所以必然是16的倍数,最前面有8个字节拿来放类型信息,第二个8个字节放引用计数相关的东西,再往后8个字节才是放age,总共用到的是24个字节,但是需要保证是16的倍数,所以是32个字节。

dog因为有继承,所以等价于

class animal {      var age = 0  }  class dog : animal {      var weight = 0  }  class dog {      var age = 0      var weight = 0  }  class erha : dog {      var iq = 0  }
let d = dog()  d.age = 10  d.weight = 20

d对象里面有两个属性,age和weight,各占8个字节,并且一般来说父类的属性内存靠前,d对象也占用32个字节,第一块是类型相关的8个字节,第二块是引用计数相关的8个字节,第三块是存储age的8个字节,第四块是存储weight的8个字节。

同样的一个erha对象要有24个字节存储age、weight、iq,另外还有前面的16个字节,所以是40个字节,但是要保证是16的倍数,所以就是48。

重写实例方法、下标

class animal {      func speak() {          print("animal speak")      }      subscript(index: int) -> int {          return index      }  }  class cat : animal {      override func speak() {          super.speak()          print("cat speak")      }      override subscript(index: int) -> int {          return super[index] + 1      }  }  var anim: animal  anim = animal()  //animal speak  anim.speak()  //6  print(anim[6])  anim = cat()  //animal speak  //cat speak  anim.speak()  // 7  print(anim[6])

重写类型方法、下标

1、被class修饰的类型方法、下标,允许被子类重写

2、被static修饰的类型方法、下标,不允许被子类重写

class animal {      class func speak() {          print("animal speak")      }      class subscript(index: int) -> int {          return index      }  }  class cat : animal {      override class func speak() {          super.speak()          print("cat speak")      }      override class subscript(index: int) -> int {          return super[index] + 1      }  }

Swift继承Inheritance浅析介绍

static修饰的类型方法、下标重写报错

Swift继承Inheritance浅析介绍

子类重写可以用static修饰,只不过不能再继续被重写了

重写属性

1、子类可以将父类的属性(存储、计算)重写为计算属性

2、子类不可以将父类属性重写为存储属性

3、只能重写var属性,不能重写let属性

4、重写时,属性名、类型要一致

5、子类重写后的属性权限,不能小于父类属性的权限

如果父类属性是只读的,那么子类重写后的属性可以是只读的,也可以是可读写的。

如果父类属性是可读写的,那么子类重写后的属性也必须是可读写的。

重写实例属性

class circle {      var radius: int = 0      var diameter: int {          set {              print("circle setdiameter")              radius = newvalue / 2          }          get {              print("circle getdiameter")              return radius * 2          }      }  }  class subcircle: circle {      override var radius: int {          set {              print("subcircle setradius")              super.radius = newvalue > 0 ? newvalue : 0          }          get {              print("subcircle getradius")              return super.radius          }      }      override var diameter: int {          set {              print("subcircle setdiameter")              super.diameter = newvalue > 0 ? newvalue : 0          }          get {              print("subcircle getdiameter")              return super.diameter          }      }  }
var circle = subcircle()  circle.radius = 6  //subcircle setradius  print(circle.diameter)  //subcircle getdiameter  //circle getdiameter  //subcircle getradius  //12  circle.diameter = 20  //subcircle setdiameter  //circle setdiameter  //subcircle setradius  print(circle.radius)  //subcircle getradius  //10

重写类型属性

1、被class修饰的计算类型属性,可以被子类重写

存储类型属性只能用static来修饰。

2、被static修饰的类型属性(存储、计算),不可以被子类重写

属性观察器

1、可以在子类中为父类属性(除了只读计算属性、let属性)增加属性观察器

class circle {      var radius: int = 1  }  class subcircle: circle {      override var radius: int {          willset {              print("subcircle willsetradius", newvalue)          }          didset {              print("subcircle didsetradius", oldvalue, radius)          }      }  }  var circle = subcircle()  circle.radius = 10  //subcircle willsetradius 10  //subcircle didsetradius 1 10

2、父类和子类中都有属性观察器

class circle {      var radius: int = 1 {          willset {              print("circle willsetradius", newvalue)          }          didset {              print("circle didsetradius", oldvalue, radius)          }      }  }  class subcircle: circle {      override var radius: int {          willset {              print("subcircle willsetradius", newvalue)          }          didset {              print("subcircle didsetradius", oldvalue, radius)          }      }  }  var circle = subcircle()  circle.radius = 10  //subcircle willsetradius 10  //circle willsetradius 10  //circle didsetradius 1 10  //subcircle didsetradius 1 10

3、子类是可以给父类中的计算属性增加属性观察器的。

class circle {      class var radius: int {          set {              print("circle setradius", newvalue)          }          get {              print("circle getradius")              return 20          }      }  }  class subcircle: circle {      override static var radius: int {          willset {              print("subcircle willsetradius", newvalue)          }          didset {              print("subcircle didsetradius", oldvalue, radius)          }      }  }  subcircle.radius = 10  //        circle getradius (oldvalue)  //        subcircle willsetradius 10  //        circle setradius 10  //        circle getradius (radius)  //        subcircle didsetradius 20 20

final

1、被final修饰的方法、下标、属性,禁止被重写

2、被final修饰的类,禁止被继承

到此这篇关于swift继承inheritance浅析介绍的文章就介绍到这了,更多相关swift继承内容请搜索<计算机技术网(www.ctvol.com)!!>以前的文章或继续浏览下面的相关文章希望大家以后多多支持<计算机技术网(www.ctvol.com)!!>!

本文来自网络收集,不代表计算机技术网立场,如涉及侵权请联系管理员删除。

ctvol管理联系方式QQ:251552304

本文章地址:https://www.ctvol.com/addevelopment/1209190.html

(0)
上一篇 2022年8月30日
下一篇 2022年8月30日

精彩推荐