面向对象(继承重写多态)以及异常处理

Posted zzzynx

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面向对象(继承重写多态)以及异常处理相关的知识,希望对你有一定的参考价值。

一.继承(单继承多继承继承:即可以继承多个父类)

 目标: 实现代码的重用,相同的代码不需要重复的编写。

class Human:          #创建一个类
    def eat(self):
        print(chi)
    def drink(self):
        print(he)
    def la(self):
        print(la)
    def sa(self):           #有吃喝拉撒四种方法
        print(sa)
class Man(Human):           #再创建一个类Man,以Human做父类,就继承了Human的四种方法
def ml(self):
print(‘fight‘)
man = Man()
man.eat()
man.drink()
... #实例化man继承了父类Human和Man的所有方法

二 :父类方法的重写和拓展

1).当父类方法不满足子类需求时,就需要重写。

2).
对父类的方法进行扩展
1.在子类中重写父类的方法
2.在需要的位置使用super().父类方法来调用父类方法的执行
3.代码其他的位置针对子类的需求,编写子类特有的代码实现
3)关于super
在python中super是一个特殊的类
super()就是使用super类创建出来的对象
最常使用的场景就是在重写父类方法时,调用在父类中封装的方法实现
class Human:          #创建一个类
    def eat(self):
        print(chi)
    def drink(self):
        print(he)
    def la(self):
        print(la)
    def sa(self):           #有吃喝拉撒四种方法
        print(sa)

class Man(Human):           #再创建一个类Man,以Human做父类,就继承了Human的四种方法
    def ml(self):
        print(fight)

class Daniu(Man):          #再创建一个类来继承Man,就继承了Man的方法
    def ml(self):           #此处重写父类的ml方法为peace
        print(peace)
        super().ml()         #此处用super().父类方法的格式来调用父类方法,这样就可以在重写的基础上再获得父类方法。
H = Daniu()           #实例化Daniu类
H.ml()
H.eat()
H.drink()
H.la()
H.sa()                 #调用方法查看结果

三:多态

  面向对象的三大特性:

  1.封装根据职责将属性和方法封装到一个抽象的类中
定义类的准则
  2.继承实现代码的重用,相同的代码不需要重复的编写
设计类的技巧
子类针对自己特有的需求,编写特定的代码
  3.多态不同的子类对象调用相同的父类方法,产生不同的执行结果
    1.多态可以增加代码的灵活度
    2.以继承和重写父类方法为前提
    3.是调用方法的技巧,不会影响到类的内部设计
class Dog:                                  #创建父类Dog
def __init__(self,name): #封装属性和方法
self.name =name
def game(self):
print(‘wan‘)

class Xiaotian(Dog):
def game(self): #覆盖父类的方法
print(‘fight‘)

class Human: #再创建一个类
def __init__(self,name):
self.name = name
def paly_with(self,who): #和别人玩的方法这里定义一个形参
print(‘%s和%s一起玩‘ %(self.name,who.name))

xt = Xiaotian(‘小天‘) #实例化Xiaotian类的对象
dt = Xiaotian(‘大天‘)
# xt.game() #查看重写结果
h = Human(‘大牛‘) #实例化Human
h.paly_with(xt) #让实例化对象小天和大天做传参对象,就能实现多态,即子类对象调用相同的父类方法,产生不同结果。
h.paly_with(dt)

四:异常处理

什么是异常?

异常即是一个事件,该事件会在程序执行过程中发生,影响了程序的正常执行。一般情况下,在Python无法正常处理程序时就会发生一个异常。

异常是Python对象,表示一个错误。当Python脚本发生异常时我们需要捕获处理它,否则程序会终止执行。
 
异常处理:
捕捉异常可以使用try
/except语句。try/except语句用来检测try语句块中的错误,从而让except语句捕获异常信息并处理。 如果你不想在异常发生时结束你的程序,只需在try里捕获它。 语法:以下为简单的try....except...else的语法:
try:
    print(mama)
except:
print(‘错误‘) #--》此处预测print(mama)会报错,使用try和except语法捕捉异常,输出错误,而不是报错停止程序

try:
print(mama)
except NameError: #根据预测报错,输出对应的错误
print(‘名字定义错误‘)


try:
print(mama)
except NameError as e: #---》name ‘mama‘ is not defined 将预测的报错信息写入e文件输出
print(e)

try:
print(mama)
except ValueError as e: #---》NameError: name ‘mama‘ is not defined 如果预测错误,except不会捕捉,而是终止程序报错
print(e)

try:
print(mama)
int(‘baba‘)
except NameError as e:
print(e) #----》name ‘mama‘ is not defined 执行完毕 ,因为print(mama)先报错,终止程序,int(’baba‘)没有执行。
# 但是finaly语法一定会输出结果
except ValueError as e:
print(e)
finally:
print(‘执行完毕‘)
 

 

以上是关于面向对象(继承重写多态)以及异常处理的主要内容,如果未能解决你的问题,请参考以下文章

面向对象的过程继承封装多态;抽象类访问修饰符的使用引用类型强制转换方法重写@override与重载空指针异常super关键字

java学习中,面向对象的三大特性:封装继承多态 以及 super关键字和方法的重写(java 学习中的小记录)

多态在面向对象中的意义以及带来的好处

面向对象多继承 异常处理

多态与抽象以及接口

Java面向对象编程三大特征 - 多态