类继承2

【struts2】继承ActionSupport类 【struts2】继承ActionSupport类——基础篇 *萌新必备 1.在Struts2中,Action可以不实现任何特殊的接口或者继承特殊的类,因此,在实际开发中,会更多的使用继承ActionSupport类来实现Action的方式. 2.ActionSupport类本身实现了Action接口,所以继承ActionSupport类就相当于实现了Action接口, 除此之外,Acti... 阅读详情

重写实例方法

在子类中,你可以重写继承来的实例方法或类方法,提供一个定制或替代的方法实现。

class Person{
    var name:String
    var age:Int

    func description() -> String{           //定义实例方法description
        return "\(name) 年龄是: \(age)"
    }
    class func printClass() -> (){
        print("Person 打印...")             //静态方法不能访问实例属性
    }
    init(name:String, age:Int){
        self.name = name
        self.age = age
    }
}
class Student:Person{
    var school:String

    convenience init(){
        self.init(name:"Tony", age:18, school:"四川师范大学")
    }
    init(name:String, age:Int, school:String){
        self.school = school
        super.init(name:name, age:age)
    }
    override func description() -> String {                //在子类中重写方法
        print("父类打印 \(super.description())")            //调用父类方法,super代指父类
        return "\(name) 年龄是: \(age), 所在学校: \(school)。"
    }
    override class func printClass() ->(){            //重写静态方法
        print("Student 打印...")
    }
}

let student1 = Student()
print("学生1: \(student1.description())")

Person.printClass()
Student.printClass()

//输出结果:
//父类打印 Tony 年龄是:18
//学生1:Tony 年龄是:18,所在学校:清华大学。
//Person 打印...
//Student 打印...

重写静态方法

静态方法使用class或static关键字,但是使用哪一个要看子类中是否重写该方法。class修饰的静态方法可以被重写,static关键字的就不能。

class Account{
    var owner:String = "Tony"       //账户名

    //class不能换成static
    class func interestBy(amount:Double) -> Double{    //定义静态方法
        return 0.08886 * amount
    }
}

class TermAccount:Account{     //定期账户
    //class可以换成static
    override class func interestBy(amount:Double) -> Double{    //重写静态方法 这里的class可以换成static 除非在TermAccount的子类重写interestBy
        return 0.09 * amount
    }
}
//调用静态方法
print(Account.interestBy(10_000.00))
print(TermAccount.interestBy(10_000.00))

下标重写

对下标的重写同子类属性重写一样也是重写下标的getter和setter访问器

class DoubleDimensionalArray{

    let rows:Int, columns:Int
    var grid:[Int]
    init(rows:Int, columns:Int){
        self.rows = rows
        self.columns = columns
        grid = Array(repeating:0, count:rows * columns)
    }
    subscript(row:Int , col:Int)->Int{         //定义下标
        get{
            return grid[(row * columns) + col]
        }
        set{
            grid[(row * columns) + col] = newValue
        }
    }
}

class SquareMatrix:DoubleDimensionalArray{  //类的继承
    override subscript(row:Int, col:Int)->Int{  //重写父类下标
        get{
            return super.grid[(row * columns) + col]
        }
        set{
            super.grid[(row * columns) + col] = newValue * newValue//给父类grid属性附值
        }
    }
}

var ary2 = SquareMatrix(rows: 5, columns: 5)

for var i in 0..<5{
    for var j in 0..<5{
        ary2[i, j] = i + j
    }
}

for var i in 0..<5{
    for var j in 0..<5{
        print("\t \(ary2[i, j])", terminator:" ")
    }
    print("\n")
}

使用final关键字

我们可以在类的定义中使用final关键字声明类、属性、方法和下标。final声明的类不能被继承,final声明的属性、方法、和下标不能被重写。

final class Person{ //声明final ,说明Person类不能被继承
    var name:String
    final var age:Int

    final func description() -> String{
        return "\(name) 年龄是: \(age)"
    }
    final class func printClass() -> (){
        print("Person 打印...")
    }
    init(name:String, age:Int){
        self.name = name
        self.age = age
    }
}
class Student:Person{            //报错
    var school:String

    convenience init(){
        self.init(name: "Tony", age:18, school:"清华大学")
    }

    init(name:String, age:Int, school:String){
        self.school = school
        super.init(name:name, age:age)
    }

    override func description() -> String {    //报错
        print("父类打印 \(super.description())")
        return "\(name) 年龄是: \(age), 所在学校: \(school)。"
    }

    override class func printClass() -> (){   //报错
        print("Student 打印...")
    }

    override var age:Int{  //报错
        get{
            return super.age
        }
        set{
            super.age = newValue < 8 ? 8: newValue
        }
    }
}

类型检查与转换

定义一个类的继承

class Person{
    var name:String
    var age:Int

    func description() -> String{
        return "\(name) 年龄是: \(age)"
    }
    convenience init(){//便利构造函数
        self.init(name: "Tony")//调用本类的第二个(其他)便利构造函数
        self.age = 19
    }
    convenience init(name:String){//便利构造函数
        self.init(name: name, age:8)//调用同一类(下面)的指定构造函数
    }
    init(name:String, age:Int){//指定构造函数
        self.name = name
        self.age = age
    }
}

class Student:Person{
    var school:String
    init (name:String, age:Int, school:String){//指定构造函数
        self.school = school
        super.init(name:name, age:age)//调用Person中的指定构造函数
    }
}

class Worker:Person{
    var factory:String
    init(name:String, age:Int, factory:String){
        self.factory = factory
        super.init(name:name, age:age)
    }
}

使用is进行类型检查,它可以判断一个实例是否是某个类的类型。如果实例是目标类型,结果返回true,否则返回false

let student1 = Student(name:"Tom", age:18, school:"清华大学")
let student2 = Student(name: "Ben", age: 28, school: "北京大学")
let student3 = Student(name: "Tony", age: 38, school: "香港大学")

let worker1 = Worker(name: "Tom", age: 18, factory: "钢厂")
let worker2 = Worker(name: "Ben", age: 20, factory: "电厂")

let people = [student1, student2, student3, worker1, worker2]//把实例放进数组集合中

var studentCount = 0
var workerCount = 0

for item in people{      //用循环判断其属于哪个子类
    if item is Worker{
        workerCount = workerCount + 1
    }else if item is Student{
        studentCount = studentCount + 1
    }
}
print("工人人数: \(workerCount), 学生人数: \(studentCount)。")
使用as、as!和as?进行类型转换

某类型的一个常量或变量可能在幕后实际上属于一个子类。当确定是这种情况时,你可以尝试向下转到它的子类型,用类型转换操作符(as? 或 as!)。
因为向下转型可能会失败,类型转型操作符带有两种不同形式。条件形式(conditional form)as? 返回一个你试图向下转成的类型的可选值(optional value)。强制形式 as! 把试图向下转型和强制解包(force-unwraps)转换结果结合为一个操作。
//当你不确定向下转型可以成功时,用类型转换的条件形式(as?)。条件形式的类型转换总是返回一个可选值(optional value),并且若下转是不可能的,可选值将是 nil。这使你能够检查向下转型是否成功。只有你可以确定向下转型一定会成功时,才使用强制形式(as!)。当你试图向下转型为一个不正确的类型时,强制形式的类型转换会触发一个运行时错误。

let p1:Person = Student(name: "Tom", age: 20, school: "清华大学")
let p2:Person = Worker(name: "Tom", age: 18, factory: "钢厂")
let p3:Person = Person(name: "Tom", age: 28)
let p4:Student = Student(name: "Ben", age: 40, school: "北京大学")
let p5:Worker = Worker(name: "Tony", age: 28, factory: "电厂")

创建了实例,p1、p4是Student实例,p2、p5是Work实例,p3是Person实例
类型转换有两个方向:向下转型——将父类类型转换为子类类型,向上转型——将子类类型转换为父类类型。通常情况下的类型转换都是向下转型
as操作符在类中仅仅只用于向上转型,很少用.还可以进行模式匹配

let p41:Person = p4 as Person//向上转型
let p41:Person = p4

将Student类型的p4转化为Person类型是向上转型,向上转型通常可以省略as Person部分。

as!操作符可以应用于三种情况:将非可选类型为非可选类型/将可选类型为非可选类型/将可选类型为可选类型

//1.将非可选类型为非可选类型
let p11 = p1 as! Student
//let p111 = p2 as! Student  //报错  在转换过程中不能转换为目标类型
//2.将可选类型为非可选类型
let p6 :Person? = Student(name: "Tom", age: 20, school: "清华大学")
let p12 = p6 as! Student//报错 p6为nil  as!在转换过程对可选址进行拆包 

//3.将可选类型为可选类型
let p13 = p6 as! Student?//可选类型转换为可选类型

as?操作符可以应用于两种情况:将非可选类型为可选类型, 将可选为可选

//向上转型,使用as?
//将非可选类型为可选类型
let p21 = p1 as? Student
let p211 = p2 as? Student
print(p21)
print(p211)
//将可选为可选
let p7 :Person? = Student(name: "Tom", age: 20, school: "清华大学")
let p22 = p7 as? Student?
print(p7)
print(p22)

var arr = [p1, p2, p3, p4, p5]
var i:Int = 1
for item in arr{
    if let m = item as? Worker{
        print("Worker factory: \(m.factory)")
    }else if let n = item as? Student{
        print("Student school: \(n.school)")
    }
    i += 1
}


let stud1 = arr[0] as? Student //它是Student可选类型,具体使用时往往还需要拆包
print(stud1)
print(stud1!.school)

let woker1 = arr[1] as! Worker
print(woker1)
print(woker1.name)

所以我们在使用as?操作符进行类型转换时你最好采用可选绑定方式,也就是将转换语句放到if或while语句中

两种不确定的类型:Any类型和AnyObject类型

AnyObject:任何类的类型, Any:任何类型

let people1:[Person] = [student1, student2, student3, worker1, worker2]
let people2:[AnyObject] = [student1, student2, student3, worker1, worker2]
let people3:[Any] = [student1,student2,student3, worker1, worker2]

for item in people2{
    if let Student = item as? Student{
        print("Student school: \(Student.school)")
    }else if let Worker = item as? Worker{
        print("Worker factory: \(Worker.factory)")
    }
}
let w1:AnyObject = arr[1] as! Worker

使用Any类型来和混合的不同类型一起工作,包括函数类型和非类类型

var things = [Any]()//创建了一个可以存储Any类型的数组
things.append(0)
things.append(0.0)
things.append(42)
things.append(3.14159)
things.append("hello")
things.append((3.0, 5.0))
things.append(Student(name: "Tina", age: 10, school: "四川师范大学"))
things.append({ (name: String) -> String in "Hello, \(name)" })

print("\n")

for thing in things {
    switch thing {
    case 0 as Int:
        print("zero as an Int")
    case 0 as Double:
        print("zero as a Double")
    case let someInt as Int:
        print("an integer value of \(someInt)")
    case let someDouble as Double where someDouble > 0:
        print("a positive double value of \(someDouble)")
    case is Double:
        print("some other double value that I don't want to print")
    case let someString as String:
        print("a string value of \"\(someString)\"")
    case let (x, y) as (Double, Double):
        print("an (x, y) point at \(x), \(y)")
    case let stu as Student:
        print("a student name: '\(stu.name)', age: \(stu.age), school: \(stu.school)")
    case let stringConverter as (String) -> String:
        print(stringConverter("Michael"))
    default:
        print("something else")
    }
}

原则上若能够使用具体的数据类型,则尽量不要使用AnyObject类型,更要少考虑使用Any类型。从集合取出这些实例时,请尽可能地将AnyObject或Any类型转换为特定类型,然后在进行接下来的操作

51单片机——LCD12864驱动函数深度解析与实战优化 本文深入解析了51单片机驱动LCD12864液晶屏的核心驱动函数,从底层时序、关键延时到地址计算进行逐行剖析,并针对常见显示问题提供系统性的调试技巧与实战优化方案。重点探讨了如何将基础代码优化为稳定高效的驱动,涵盖延时精准化、批量写入及显示缓冲区等高级技巧,旨在帮助开发者从“点亮”屏幕进阶到“精通”驱动,确保显示稳定可靠。 阅读详情

相关推荐

TPL5010硬件看门狗电路

在做一些采集频率很低的产品的时候,会考虑电池供电,比如表、电气表等,为了控制功耗,往往会在设备不需要工作的时候让它进入低功耗模式。为了设备的稳定性,避免死机后无法恢复,必须配置看门狗,一般的看门狗芯片,喂狗间隔时间是几秒钟。这样在喂狗和低功耗之间就产生了一个矛盾,频繁的喂狗就需要频繁的醒过来,这样功耗就很难做到很低。这颗看门狗芯片,特别适合上面的应用。2小时的间隔意味着主控芯片每2小时醒过来喂狗一次即可,而在2.5V供电的情况下,功耗仅仅35nA,几乎可以忽略不计。

zxm8513优快云博客 3314

swift5基本语法-方法/重写

一、方法 Swift中枚举、结构体、类都可以定义实例方法、类型方法。 实例方法(OC中的-减号方法): 通过实例调用 类型方法(OC中的+加号方法): 通过类型调用,用static或者class关键词定义。 实例方法实例: class Person { static var age = 0 init() { Person.age += 1 } ...

u010707262的博客 403

维护测试监控LLM应用

LangFuse: 开源 + SaaS(免费/付费),LangSmith 平替,可集成 LangChain 也可直接对接 OpenAI API;LangSmith: LangChain 的官方平台,SaaS 服务(免费/付费),非开源,企业版支持私有部署;调试 Prompt 的 Playground测试/验证系统的相关指标数据集管理各种指标监控与统计:访问量、响应时长、Token 费等等。

SunnyRivers 1785

scala基础5 —— 类的继承

scala基础,类的继承

星辰大海,脚踏实地 1963

Weaxor勒索病毒实战分析:从加密算法到防御策略(附检测工具清单)

本文对Weaxor勒索病毒进行了深度实战剖析,详细拆解了其采用ChaCha20与AES-CTR的混合加密算法、横向移动手法及数据回传行为。文章重点分析了其密钥生成机制的“漏洞修复”,并提供了从主机加固、网络监控到基于IOC威胁狩猎的立体化企业级防御策略与检测工具清单。

weixin_29233333的博客 264

目标检测——布匹缺陷检测数据集

结构瑕疵指的是布料本身的缺陷,包括嵌结、抽纱、错纱、断纱、预缩等问题,这些问题通常是在布料生产过程中出现的。而质量瑕疵则是指布料在使用过程中出现的问题,如污渍、断裂、鼓囊、针眼等,这些问题可能由生产过程中的结构瑕疵导致,也可能是在运输、存放和使用过程中引起的。布匹瑕疵如缺纬、断纬、粗纬、松纬、缺经、断经、粗经、筘痕、污点、破损等,若未得到及时有效的检测,这些瑕疵产品可能会流向市场,导致消费者的不满和退货,严重影响企业的声誉和品牌形象。织疵包括缺经、缺纬、跳花、弓纱、错纱、厚薄段、油污渍等;

zzjlhlcd的博客 612

1.a.txt 文本里面写有如下内容: age=25:name=张三 age=26:name=李四 。。。。 已知:age和name,是Person类的两个成员变量,请把这个文本里面的

package com.heima.test;import java.awt.List; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.util.ArrayList;publi

嘿啦啦与呼哈哈的童话 2830

从零开始安装 Windows 11 和 Ubuntu 22.04 双系统

本文详解Windows与Ubuntu 22.04双系统安装流程:需提前确认BIOS模式(UEFI/GPT或Legacy/MBR),关闭BitLocker加密、设备加密及快速启动;推荐Rufus/Ventoy制作启动盘。安装时需规划分区方案(建议单独划分EFI系统分区),注意引导器安装位置选择。双系统启动通过BIOS引导顺序管理,安装后需同步Windows与Linux系统时间。教程适配主流UEFI+GPT设备,强调操作前数据备份及Windows更新策略调整,避免兼容性问题。

萑澈的博客 3778

类C继承类B1和类B2,类B1和类B2继承自类A。在类C中给类A变量赋值的顺序,与类C的继承顺序有关系

类A,B1,B2,C在同一个cpp里写(Class.cpp)。分开麻烦的写一个里面省事。 上代码: #include&lt;iostream&gt; #include&lt;string&gt; class A { public:     std::string firstName; public:     A()     {         firstName = "NO FIRST NA...

qq_37171545的博客 754

YOLOv5_DeepSORT_Pytorch训练自己的多目标跟踪模型

1 准备 环境配置:https://blog.youkuaiyun.com/weixin_50008473/article/details/115250986?spm=1001.2014.3001.5501 YOLOv5_DeepSORT_Pytorch代码地址: https://github.com/mikel-brostrom/Yolov5_DeepSort_Pytorch DeepSORT论文:https://arxiv.org/pdf/1703.07402.pdf 2 训练目标检测模型 训练自己的目标检测模

weixin_50008473的博客 1万+

手把手完整实现STM32+ESP8266+机智云平台+手机APP应用——第一节-机智云平台搭建+所需硬件及接线说明+ESP8266烧录机智云固件

本节介绍如何在机智云平台创建自己的项目,介绍使用的硬件及接线说明,以及ESP8266烧录机智云固件过程。下一节进行机智云移植并编写STM32程序实现远程温湿度显示与控制灯照明,以及机智云APP配网。实现完整的物联网应用,STM32+ESP8266+机智云平台+手机APP应用。

嵌入式阿齐Archie 2万+

Struts2:Action类的写法,推荐使用继承ActionSupport类的方法

新建包,action类,模块化的struts_demo2.xml的文件。先写一个action类,再写配置文件,再在 项目 运行。先写一个action类,再写配置文件,再在 项目 运行。

m0_75257168的博客 905

成本中心(CO)和利润中心(PCA)是管理会计模块的核心组件

SAP中成本中心(CO)和利润中心(PCA)凭证处理存在差异:①外部交易(如费用支付、销售)会生成FI借贷凭证;②内部成本分摊和转移仅产生CO/PCA管理凭证,通过次级成本要素或利润中心转移科目记录,不涉及FI模块。核心区别在于是否涉及企业实际收支:实际收支触发FI凭证,内部核算仅生成管理会计凭证。系统通过这种机制实现财务会计与管理会计的集成与分离。

金牌架构师 1130

ros2中 对于类继承Node的一些小陷阱

如果创建的类节点继承Node父节点时未加入public,则该类并不是Node类型。接下来创建智能指针时,该指针指向的是HelloWorld类型,而非Node类型。解决方法是类继承时补足public,标明父类节点区域。

weixin_43982044的博客 312

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

Struts2如何继承ActionSupport类

今天木蓝小盆友告诉大家一种Struts2怎样继承ActionSupport类,在继承ActionSupport类前一定要把Struts2的项目搭建好。 第一步:先在webProject项目中建立一个Test.java,Test中的代码如下:   package com.hnpi.test; import com.opensymphony.xwork2.ActionSupport; pub...

mulanxiaopenyou的博客 201

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

python的两种继承模式_python2与python3的经典类与新式类的继承

python2与python3都有经典类和新式类这两种写法,在python2中经典类和新式类的继承方式不一样,在python3中都一样。python2的经典类采用 深度优先搜索 继承方式,新式类采用 广度优先搜索 的继承方式python3中经典类和新式类都采用 广度优先搜索 的继承方式经典类写法class class_name: # 经典类写法pass新式类写法class class_name(o...

weixin_39550410的博客 291

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

ROS2学习笔记 - 2、类的继承及使用

"""动物节点类,用于描述动物的基本属性和行为""""""初始化动物节点参数:species_name (str): 动物物种名称,如 'zebra', 'kangaroo'weight (int): 动物体重,单位为公斤(kg)age (int): 动物年龄,单位为岁"""self.species_name = species_name # 存储物种名称self.weight = weight # 存储体重self.age = age # 存储年龄"""

xuanwenchao的专栏 223

ros2的Node类-->python中的self及继承

继承 (Inheritance): 表示是一种Node。好处:子类自动获得父类的所有功能(方法),无需重复造轮子。你可以专注于扩展新功能。self参数代表类的当前实例对象。在 ROS2 节点中,就代表这个具体的节点本身。作用在__init__中:用于给这个新创建的节点对象添加属性(如在普通方法中(如):用于访问和修改这个特定节点对象的状态(如super()用于调用父类的方法。最关键的就是在子类的__init__中调用来完成基础的初始化工作。忘记调用是常见的错误!会导致节点无法正常初始化。

weixin_44525183的博客 616

C++实验八——类的继承(2)

实验报告题目1题目2 【实验名称】 实验八 类的继承(2) 【实验内容】 题目1 正确使用类的继承和组合进行类的设计,分别表示房间、休息室、教室、投影仪,沙发,为每个类设置适当的成员变量、成员函数和构造函数,在主程序中生成对象进行测试。 源代码: Room.cpp: #include<iostream> using namespace std; enum Color{ red,orange,yellow,green,cyan,blue,purple,white,black };

Onlyone_1314的博客 1481

面试题:python2类继承object和不继承object有什么区别

​python2中定义类时继承object和不继承object有什么区别? stackoverflow上也有人提出了这样的问题: https://stackoverflow.com/questions/332255/difference-between-class-foo-and-class-fooobject-in-python 首先说明,这个区别只存在于python2,pyt...

pipi的奇思妙想 751

Python2.7 学习笔记 (三)—— 类,继承,重载

16:56 2012-3-9 声明:以下代码都是在Python2.7+Winxp中执行通过 [面向对象] 1.类的定义 #-*-coding:utf-8-*- class student: name = ''   #定义类的公有属性,可直接访问 age =0 class human : sex ='' height=0 2.类的继承 class studen

飞翔之鹏的程序天空~~~ 4141

[struts2]继承ActionSupport类

这次来写个在struts2中继承ActionSupport例子: 注意:struts2配置就不多写了,可以在我之前发的文章中了解。 ActionSupport类本身实现了Action接口,所以继承ActionSupport类就相当于实现了Action接口。除此之外,ActionSupport类还实现了其它几个接口,来为程序员提供更多使用的功能,这些接口和Struts2的一些其他特性相结合,可以实现...

ZhanXiaoWang的博客 529

struts2继承ActionSupport类例子

struts2继承ActionSupport类例子 实现方法基于struts2框架 Struts2中,Action可以不实现任何特殊的接口或者继承特殊的类,仅仅是一个POJO就可以;也可以实现Xwork2中的Action接口;ActionSupport类本身实现了Action接口,所以继承ActionSupport类就相当于实现了Action接口。 基本数据验证 要实现数据验证的功能,只需要在Ac...

qq_41025096的博客 218

smartjs 0.2 OOP讲解 - Klass 类继承

SmartJS2.0加入OOP的功能。OOP包括klass与factory两个对象。 Klass 类继承 与其他的类继承相比,smartjs使用了执行指针的概念(后面例子中会介绍),另外提供base基类和初始化控制的扩展功能。 首先来看看接口: var _klass = st.klass(name, prop, parent, config); //new _klass(...

weixin_30302609的博客 170

Python2.7版本:定义类时为什么要继承object类?

继承 object 类的是新式类,不继承 object 类的是经典类 例子: 新式类: 经典类: B、C 是 A 的子类,D 多继承了 B、C 两个类,其中 C 重写了 A 中的 foo() 方法。 如果 A 是经典类,当调用 D 的实例的 foo() 方法时,Python 会按照深度优先的方法去搜索 foo() ,路径是 B-A-C ,执...

129

python定义类object_面试题:python2中定义类时继承object和不继承object有什么区别?...

面试python相关岗位时,被问到这样一个问题,python2中定义类时继承object和不继承object有什么区别?Stackoverflow上也有人提出了这样的问题首先说明,这个区别只存在于python2,python3中即使未继承object也会默认继承object 一、继承顺序不同让我们从一个比较简单的例子入手来解答这个问题,以下代码python版本为2.7例子1:D继承于B类和C类,B...

weixin_39664746的博客 272
上一篇: 类继承
下一篇: 【Swift】14.0扩展
Reflection_
博客等级 码龄10年 18粉丝 34原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值