多继承
子类拥有一个父类叫做单继承
子类可以拥有多个父类,并且具有所有父类的属性和方法
例如:孩子会继承自己父亲和母亲的特性
语法:
calss 子类名(父类名1,父类名2...)
pass
面向对象三大特性
1.封装:根据职责将属性和方法封装到一个抽象的类中
2.继承:实现代码的重用,相同的代码不需要重复的写
3.多态:不同的对象调用相同的方法,产生不同的结果,
增加代码的灵活度
单继承
1.继承的概念 语法和特点
继承的概念:子类拥有父类的所有方法和属性(子类只需封装自己特有的方法)
2.继承的语法
class 类名(父类)
def 子类特有的方法
继承的传递性:(爷爷 父亲 儿子)
1.C类从B类继承,B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
重写父类方法有两种情况:
1.覆盖父类的方法
2.对父类方法进行扩展
1.覆盖父类的方法
如果在开发中,父类的方法的实现和子类方法的实现,
完全不同,就可以使用覆盖的方式,
在子类中重新编写父类的方法
具体实现方式,就相当于在子类中定义了
一个和父类同名的方法并且实现
重写之后,在运行时,只会调用子类的重写方法,
而不会再调用父类封装的方法
"""
class Animal():
def eat(self):
print '吃'
def drink(self):
print '喝'
def run(self):
print '跑'
def sleep(self):
print '睡'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
def call(self):
print '喵喵~'
class Hellokitty(Cat):
def speak(self):
print '我可以说日语'
def call(self):
print '偶哈呦 空你起哇'
kt = Hellokitty()
# 如果子类中,重写了父类的方法
# 在运行中,只会调用子类中重写的方法,不会调用父类的方法
kt.call()
对父类的方法进行扩展
如果在开发中,子类的方法实现包含有父类的方法实现
(父类原本封装的方法实现是子类方法的一部分
就可以使用扩展方法)
1.在子类中重写父类的方法
2.在需要的位置使用 父类名.方法(self) 来调用父类方法的执行
(使用父类名称调用父类方法)
3.代码其他的位置针对子类的需求,编写子类特有的代码实现
"""
class Animal():
def eat(self):
print '吃'
def drink(self):
print '喝'
def run(self):
print '跑'
def sleep(self):
print '睡'
class Cat(Animal):
# 子类拥有父类的所有属性和方法
def call(self):
print '喵喵~'
class Hellokitty(Cat):
def speak(self):
print '我可以说日语'
def call(self):
print '偶哈呦 空你起哇'
# 调用原本在父类中封装的方法
Cat.call(self)
print '#@!#@!#@!'
kt = Hellokitty()
# 如果子类中,重写了父类的方法
# 在运行中,只会调用子类中重写的方法,不会调用父类
kt.call()
"""
file: __del__.py
date: 2018-07_21 11:03 AM
desc:__del__方法:
在python中
当使用类名()创建对象时,为对象分配完空间后,
自动调用__init__方法
当一个对象被从内存中销毁前(把这个对象从内存中删除掉),
会自动调用__del__方法
应用场景
__del__如果希望在对象被销毁前,再做一些事情,可以考虑一下__del__方法
"""
class Cat():
def __init__(self,new_name):
self.name = new_name
print '%s 创建' % self.name
def __del__(self):
print '%s 销毁' % self.name
tom = Cat('hello')
print tom.name
print '###############'
""" 在python中,使用python输出对象变量,默认情况下,
会输出这个变量引用的对象是由哪>一个类创建的对象,
以及在内存中的地址(十六进制表示)
如果在开发中,希望使用print输出对象变量时,
能够打印自定义的内容,就可以利用__str__这个内置方法了
file: __str__.py
date: 2018-07_21 11:09 AM
desc:
"""
class Cat():
def __init__(self,name):
self.name = name
def __str__(self):
return 'i am %s' % self.name
tom = Cat('tom')
print tom
"""
file: run.py
date: 2018-07_21 11:13 AM
desc:
"""
class People():
def __init__(self,name,weight):
self.name = name
self.weight = weight
def __str__(self):
return '我的名字是 %s 体重是 %.2f' % (self.name,self.weight)
def run(self):
print '%s 跑步了' % self.name
self.weight -= 0.5
def eat(self):
self.weight += 1
print '%s 吃东西了' % self.name
tom = People('tom',100.0)
tom.eat()
tom.run()
print tom
类的继承
面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过继承机制。
通过继承创建的新类称为子类或派生类,被继承的类称为基类、父类或超类。
继承语法
class 派生类名(基类名)
...
在python中继承中的一些特点:
1、如果在子类中需要父类的构造方法就需要显示的调用父类的构造方法,或者不重写父类的构造方法。详细说明可查看:python 子类继承父类构造函数说明。
2、在调用基类的方法时,需要加上基类的类名前缀,且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
3、Python 总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。(先在本类中查找调用的方法,找不到才去基类中找)。
如果在继承元组中列了一个以上的类,那么它就被称作"多重继承"
"""
file: 覆盖.py
date: 2018-07_21 4:41 PM
desc:
"""
"""
重写父类方法有两种情况:
1覆盖
2扩展
覆盖父类的方法
如果在开发中父类的方法的实现和子类的方法的实现完全不同
就可以用覆盖的方式
在子类中重新编写父类的方法
具体实现方式,就相当于在子类中定义了一个和父类同名的方法并且实现
重写之后,在运行时,只会调用子类的重写方法
而不会调用父类封装的方法
"""
class Animal():
def eat(self):
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
def call(self):
print 'miaomiao'
class HelloKitty(Cat):
def speak(self):
print '我可以说日语'
def call(self):
print 'hahahahha'
kt = HelloKitty()
kt.call()
kt.sleep()
kt.run()
kt.drink()
kt.eat()
kt.speak()
"""
file: 扩展.py
date: 2018-07_21 4:46 PM
desc:
"""
"""
对父类的方法进行扩展
如果在开发中,子类的方法实现包含有父类的方法实现
(父类原本的封装方法是子类方法的一部分
就可使用扩展方法)
1在子类中重写父类的方法
2在需要的位置使用 父类名,方法(self)来调用父类方法的执行
(使用父类名称调用父类方法)
3代码其他的位置针对子类的需求,编写子类特有的代码实现
"""
class Animal():
def eat(self):
print 'eat'
def drink(self):
print 'drink'
def run(self):
print 'run'
def sleep(self):
print 'sleep'
class Cat(Animal):
def call(self):
print 'miaomiao'
class HelloKitty(Cat):
def speak(self):
print '我可以说日语'
Cat.call(self)
print '我既会喵喵还会旺旺'
kt = HelloKitty()
kt.call()
kt.sleep()
kt.run()
kt.drink()
kt.eat()
kt.speak()