23.swift继承

import Foundation

/*

继承语法

继承是面向对象最显著的一个特性, 继承是从已经有的类中派生出新的类

新的类能够继承已有类的属性和方法, 并能扩展新的能力

术语: 基类(父类, 超类), 派生类(子类, 继承类)

语法:

class 子类: 父类{

}

继承有点: 代码重用

继承缺点: 增加程序耦合度, 父类改变会影响子类

注意:Swift和OC一样没有多继承

*/

class Man {

var name:String = "lnj"

var age: Int = 30

func sleep(){

print("睡觉")

}

}

class SuperMan: Man {

var power:Int = 100

func fly(){

// 子类可以继承父类的属性

print("飞 \(name) \(age)")

}

}

var m = Man()

m.sleep()

//m.fly() // 父类不可以使用子类的方法

var sm = SuperMan()

sm.sleep()// 子类可以继承父类的方法

sm.fly()

/*

super关键字:

派生类中可以通过super关键字来引用父类的属性和方法

*/

class Man2 {

var name:String = "lnj"

var age: Int = 30

func sleep(){

print("睡觉")

}

}

class SuperMan2: Man2 {

var power:Int = 100

func eat()

{

print("吃饭")

}

func fly(){

// 子类可以继承父类的属性

print("飞 \(super.name) \(super.age)")

}

func eatAndSleep()

{

eat()

super.sleep()

// 如果没有写super, 那么会现在当前类中查找, 如果找不到再去父类中查找

// 如果写了super, 会直接去父类中查找

}

}

var sm2 = SuperMan2()

sm2.eatAndSleep()

/*

方法重写: override

重写父类方法, 必须加上override关键字

*/

class Man3 {

var name:String = "lnj"

var age: Int = 30

func sleep(){

print("睡觉")

}

}

class SuperMan3: Man3 {

var power:Int = 100

// override关键字主要是为了明确表示重写父类方法,

// 所以如果要重写父类方法, 必须加上override关键字

override func sleep() {

//        sleep() // 不能这样写, 会导致递归

super.sleep()

print("子类睡觉")

}

func eat()

{

print("吃饭")

}

func fly(){

// 子类可以继承父类的属性

print("飞 \(super.name) \(super.age)")

}

func eatAndSleep()

{

eat()

sleep()

}

}

var sm3 = SuperMan3()

// 通过子类调用, 优先调用子类重写的方法

//sm3.sleep()

sm3.eatAndSleep()

/*

重写属性

无论是存储属性还是计算属性, 都只能重写为计算属性

*/

class Man4 {

var name:String = "lnj" // 存储属性

var age: Int { // 计算属性

get{

return 30

}

set{

print("man new age \(newValue)")

}

}

func sleep(){

print("睡觉")

}

}

class SuperMan4: Man4 {

var power:Int = 100

// 可以将父类的存储属性重写为计算属性

// 但不可以将父类的存储属性又重写为存储属性, 因为这样没有意义

//    override var name:String = "zs"

override var name:String{

get{

return "zs"

}

set{

print("SuperMan new name \(newValue)")

}

}

// 可以将父类的计算属性重写为计算属性, 同样不能重写为存储属性

override var age: Int { // 计算属性

get{

return 30

}

set{

print("superMan new age \(newValue)")

}

}

}

let sm4 = SuperMan4()

// 通过子类对象来调用重写的属性或者方法, 肯定会调用子类中重写的版本

sm4.name = "xxx"

sm4.age = 50

/*

重写属性的限制

1.读写计算属性/存储属性, 是否可以重写为只读计算属性? (权限变小)不可以

2.只读计算属性, 是否可以在重写时变成读写计算属性? (权限变大)可以

3.只需

*/

class Man5 {

var name:String = "lnj" // 存储属性

var age: Int { // 计算属性

get{

return 30

}

set{

print("man new age \(newValue)")

}

}

func sleep(){

print("睡觉")

}

}

class SuperMan5: Man5 {

var power:Int = 100

override var name:String{

get{

return "zs"

}

set{

print("SuperMan new name \(newValue)")

}

}

override var age: Int { // 计算属性

get{

return 30

}

set{

print("superMan new age \(newValue)")

}

}

}

/*

重写属性观察器

只能给非lazy属性的变量存储属性设定属性观察器,

不能给计算属性设置属性观察器,给计算属性设置属性观察器没有意义

属性观察器限制:

1.不能在子类中重写父类只读的存储属性

2.不能给lazy的属性设置属性观察器

*/

class Man6 {

var name: String = "lnj"

var age: Int = 0 { // 存储属性

willSet{

print("super new \(newValue)")

}

didSet{

print("super new \(oldValue)")

}

}

var height:Double{

get{

print("super get")

return 10.0

}

set{

print("super set")

}

}

}

class SuperMan6: Man6 {

// 可以在子类中重写父类的存储属性为属性观察器

override var name: String {

willSet{

print("new \(newValue)")

}

didSet{

print("old \(oldValue)")

}

}

// 可以在子类中重写父类的属性观察器

override var age: Int{

willSet{

print("child new \(newValue)")

}

didSet{

print("child old \(oldValue)")

}

}

// 可以在子类重写父类的计算属性为属性观察器

override var height:Double{

willSet{

print("child height")

}

didSet{

print("child height")

}

}

}

var m6 = SuperMan6()

//m6.age = 55

//print(m.age)

m6.height = 20.0

/*

利用final关键字防止重写

final关键字既可以修饰属性, 也可以修饰方法, 并且还可以修饰类

被final关键字修饰的属性和方法不能被重写

被final关键字修饰的类不能被继承

*/

final class Man7 {

final var name: String = "lnj"

final var age: Int = 0 { // 存储属性

willSet{

print("super new \(newValue)")

}

didSet{

print("super new \(oldValue)")

}

}

final var height:Double{

get{

print("super get")

return 10.0

}

set{

print("super set")

}

}

final func eat(){

print("吃饭")

}

}

时间: 2024-11-05 09:57:41

23.swift继承的相关文章

swift 继承相关

class Vehicle { var numberOfWheels: Int var maxPassengers: Int func description() -> String { return "\(numberOfWheels) wheels; up to \(maxPassengers) passengers" } init() { numberOfWheels = 1; maxPassengers = 3; } } class Bicycle: Vehicle {

swift 继承和构造器

继承 class Vehicle { var numberOfWheels: Int var maxPassengers: Int func description() -> String { return "\(numberOfWheels) wheels; up to \(maxPassengers) passengers" } init() { numberOfWheels = 0 maxPassengers = 1 } } class Bicycle: Vehicle {

Swift - 继承UIView实现自定义可视化组件(附记分牌样例)

在iOS开发中,如果创建一个自定义的组件通常可以通过继承UIView来实现.下面以一个记分牌组件为例,演示了组件的创建和使用,以及枚举.协议等相关知识的学习. 效果图如下: 组件代码:ScoreView.swift 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 5

Swift继承的用法

一个类可以继承另一个类的方法,属性和其它特性.当一个类继承其它类,继承类叫子类,被继承类叫超类(或父类).在Swift中,继承是区分「类」与其它类型的一个基本特征. 在Swift中,类可以调用和访问超类的方法,属性和下标,并且可以重写(override)这些方法,属性和下标来优化或修改它们的行为.Swift会检查你的重写定义在超类中是否有匹配的定义,以此确保你的重写行为是正确的. 可 以为类中继承来的属性添加属性观察器(property observer),这样一来,当属性值改变时,类就会被通知

学习Swift -- 继承

继承 一个类可以继承另一个类的方法(methods),属性(properties)和其它特性.当一个类继承其它类时,继承类叫子类,被继承类叫超类(父类). 在 Swift 中,子类可以调用和访问父类的方法,属性和下标脚本(subscripts),并且可以重写(override)这些方法.属性和下标脚本来优化或修改它们的行为.Swift 会检查你的重写定义在超类中是否有匹配的定义,以此确保你的重写行为是正确的. 可以为子类中继承来的属性添加属性观察器(property observers),这样一

swift继承与重载

一个类可以继承(inherit)另一个类的方法(methods),属性(property)和其它特性.当一个类继承其它类时,继承类叫子类(subclass),被继承类叫超类(或父类,superclass).在 Swift 中,继承是区分「类」与其它类型的一个基本特征. 在 Swift 中,类可以调用和访问超类的方法,属性和附属脚本(subscripts),并且可以重写(override)这些方法,属性和附属脚本来优化或修改它们的行为.Swift 会检查你的重写定义在超类中是否有匹配的定义,以此确

【Swift初见】Swift继承

对于继承这个名字大家应该都不陌生,在swift中也是一样,swift中的一个类可以继承另一个类的方法,属性和其他特性.当一个类继承其他类时,继承类叫做子类,被继承的类叫做父类,在swift中继承是区分类与其他类型的一个基本特征. 定义一个基类: 当一个类不继承其他类,这个类叫做基类.比如看下面的代码: class vehicle { var maxPassengers : Int var manufacturer : String func description() -> String{ re

Swift 继承

继承我们可以理解为一个类获取了另外一个类的方法和属性. 当一个类继承其它类时,继承类叫子类,被继承类叫超类(或父类) 在 Swift 中,类可以调用和访问超类的方法,属性和下标脚本,并且可以重写它们. 我们也可以为类中继承来的属性添加属性观察器. 基类 没有继承其它类的类,称之为基类(Base Class). 以下实例中我们定义了基类 StudDetails ,描述了学生(stname)及其各科成绩的分数(mark1.mark2.mark3): class StudDetails { var s

2016.2.23(继承)

什么为继承? 在面向对象的编程中,通过扩展一个已有的类,并继承该类的属性和行为,来创建一个新的类,这种方式为继承. 继承需要注意什么? 继承时,子类可以继承来自于父类的所有的属性和行为, 但构造方法不能被继承! java中的类只能继承一个类. 继承有什么优点? 1.代码的重用性 2.父类的属性和方法可用于子类 3.子类可以扩展父类的属性和方法 方法重写需要注意哪些规则? 1.子类方法的返回类型,方法名和形式参数列表,必须与父类中的是相同的. 2.访问修饰符必须不能小于父类中的访问修饰符. 3.子