13-面向对象3
- 1、继承简介
- 继承是面向对象三大特性之一
- 通过继承我们可以使一个类获取到其他类中的属性和方法
- 在定义类时,可以在类名后面的括号中指定当前类的父类(超类、基类)
- 继承提高了类的复用性。让类与类之间产生了关系。有了这个关系,才有了多态的特性
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/9/17 0017 21:02
# @Author : Oliver
#继承是面向对象的三大特性之一
# 通过继承我们可以使一个类获取其他类的属性和方法
# class Person():
# name=''
# age=''
# class Doctor():
# name=''
# age=''
#
# def heal(self):
# print('治病救人!')
#
# class Student():
# name=''
# age=''
#
# def study(self):
# print('好好学习,天天向上!!!')
#
# object是所有类的父类
# issubclass()检查一个类是不是另一个类的子类
class Animal(object):
def run(self):
print('动物跑起来了.....')
def sleep(self):
print('动物睡觉...')
a=Animal()
# a.run()
# 需求:定义一个狗类
# 1.直接修改Animal这个类,在这个类中添加我们需要的功能
# 这种方式比较麻烦,并且会违反OCP原则
# 显然这个方式不推荐
# 2.直接创建一个新的类
# 创建一个新类是比较麻烦的,并且需要大量的赋值粘贴,会出现大量的重复代码
# class Dog():
# def run(self):
# print('狗跑起来了.....')
# def sleep(self):
# print('狗睡觉...')
# def speak(self):
# print('汪汪汪!')
#
# 3.直接从Animal类中继承他的属性和方法
# 在定义类的时候,可以在类名的后面加上一个括号,这个括号中可以指定当前类的父类(超类、基类)
class Dog(Animal):
def speak(self):
print('汪汪汪!')
def run(self):
print('狗再跑!!')#更新了狗的方法
d=Dog()
# Dog中没有sleep的方法,但是父类有,很明显d可以调用,这就是Dog继承了Animal这个父类的方法和属性
d.run()
d.sleep()
d.speak()
#判断d是不是Dog的实例
r=isinstance(d,Dog)
print(r)#最后发现是的
#判断d是不是Animal的实例
r=isinstance(d,Animal)
print(r)#最后发现是的
# 也就是d也是父类的实例
print()
print(issubclass(Dog,Animal))
print(issubclass(Animal,object))
结果显示:
狗再跑!!
动物睡觉...
汪汪汪!
True
True
True
True
Process finished with exit code 0
- 2、方法重写
- 如果在子类中有和父类同名的方法,则通过子类实例去调用方法时,会调用子类的方法而不是父类的方法,这个特点我们称之为方法的重写(覆盖)
- 当我们调用一个对象的方法时:
- 会优先去当前对象中寻找是否具有该方法,如果有则直接调用
- 如果没有,则去当前对象的父类中寻找,如果父类中有则直接调用父类中的方法
- 如果没有,则去父类中的父类寻找,以此类推,直到找到object,如果依然没有找到就报错了
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/9/17 0017 21:27
# @Author : Oliver
# 重写/覆盖(override)
class A(object):
def test(self):
print('A....')
class B(A):
def test(self):
print('B....')
class C(B):
pass
c=C()
c.test()
结果显示:
B....
Process finished with exit code 0
- 3、super()
- super()可以获取当前类的父类
- 并且通过super()返回对象调用父类方法时,不需要传递self
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/9/17 0017 21:37
# @Author : Oliver
# 父类中所有的方法都会被子类继承,包括特殊的方法
class Animal(object):
def __init__(self,name,sex):
self._name=name
self._sex=sex
@property
def sex(self):
return self._sex
@sex.setter
def sex(self, sex):
self._sex = sex
@property
def name(self):
return self._name
@name.setter
def name(self,name):
self._name=name
def run(self):
print('动物跑起来了.....')
def sleep(self):
print('动物睡觉...')
class Dog(Animal):
def __init__(self,name,age,sex):
# self._name=name
# self._age=age
# self._sex=sex
# Animal.__init__(self,name,sex)
super().__init__(name,sex)
@property
def age(self):
return self._age
@age.setter
def age(self,age):
self._age = age
def speak(self):
print('汪汪汪!!!')
def run(self):
print('狗在跑.....')
d=Dog('试试',4,'男')
print(d.name)
print(d.sex)
# super()可以获取当前类的父类
- 4、多重继承
- 在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类
- 可以在类名的()后边添加多个类,来实现多重继承
- 多重继承,会使子类同时拥有多个父类,并且会获取到所有父类中的方法
- 在开发中没有特殊情况,应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
- 如果多个父类中有同名的方法,则会先在第一个父类中寻找,如果该父类还有父类,则在该父类的父类中查找,没有的话,然后找第二个,找第三个…前面会覆盖后面的
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/9/18 0018 12:34
# @Author : Oliver
# 类名.__bases__这个属性可以用来获取当前类的父类
class A(object):
def test(self):
print('A....')
class B(object):
def test(self):
print('B....')
# 可以在类名的()后边添加多个类,来实现多重继承
class C(A,B):
pass
c=C()
print(C.__bases__)
# (<class '__main__.B'>,)元组还有逗号,说明可以有多个父类
print(B.__bases__)
c.test()
# 多个父类中有同名的方法,则会先在第一个父类中寻找,然后找第二个,找第三个...前面会覆盖后面的
结果显示:
(<class '__main__.A'>, <class '__main__.B'>)
(<class 'object'>,)
A....
Process finished with exit code 0
- 5、多态
- 多态是面向对象的三大特性之一。从字面理解就是多种形态
- 一个对象可以以不同形态去呈现
- 面向对象三大特性
- 封装 确保对象中数据的安全
- 继承 保证了对象的扩展性
- 多态 保证了程序的灵活性
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/9/18 0018 12:50
# @Author : Oliver
# 多态也是面向对象的三大特性之一
# 一个对象可以以不同的形态去呈现
class A:
def __init__(self,name):
self._name=name
@property
def name(self):
return self._name
@name.setter
def name(self,name):
self._name=name
class B:
def __init__(self, name):
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
class C:
pass
a=A('张三')
b=B('李四')
c=C()
# 定义一个函数 这种形式就是多态
def speak(obj):
print('你好%s'%obj.name)
# 只要对象有name就可以,不用对象是A,还是B
# 适应性更高
speak(a)
# speak(c)
# 这种形式就违反了一个多态的原则
def speak2(obj):
# 类型检查
if isinstance(obj,A):#只能处理一类对象
print('你好%s'%obj.name)
speak2(a)
# 举个例子好理解
lst=[1,2,3]
print(len(lst))
s='python'
print(len(s))
# len()可以处理不同对象,就相当于上述的speak()
# 这就是一个多态
# 列表字符串都封装了__len__,这是他们的共同点
- 6、属性和方法
- 属性
- 类属性,直接在类中定义的属性是类属性
- 类属性可以通过类或类的实例访问到。但是类属性只能通过类对象来修改,无法通过实例对象修改
- 实例属性 通过实例对象添加的属性属于实例属性
- 实例属性只能通过实例对象来访问和修改,类对象无法访问修改
- 方法
- 在类中定义,以self为第一个参数的方法都是实例方法
- 实例方法在调用时,Python会将调用对象以self传入
- 实例方法可以通过类实例和类去调用
- 当通过实例调用时,会自动将当前调用对象作为self传入
- 当通过类调用时,不会自动传递self,我们必须手动传递self
- 类方法 在类的内容以@classmethod 来修饰的方法属性类方法
- 类方法第一个参数是cls 也会自动被传递。cls就是当前的类对象
- 类方法和实例方法的区别,实例方法的第一个参数是self,类方法的第一个参数是cls
- 类方法可以通过类去调用,也可以通过实例调用
- 静态方法
- 在类中用@staticmethod来修饰的方法属于静态方法
- 静态方法不需要指定任何的默认参数,静态方法可以通过类和实例调用
- 静态方法,基本上是一个和当前类无关的方法,它只是一个保存到当前类中的函数
- 静态方法一般都是些工具方法,和当前类无关
- 属性
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/9/18 0018 13:24
# @Author : Oliver
class A:
# 类属性:直接在类中定义的属性就是类属性
# 类属性可以通过类对象和实例对象来访问
# 类属性只能通过类对象来修改,不能通过实例对象来修改
count=0
def __init__(self):
self.name='张三'
# 这其实是一个实例属性,因为self就是a,通过self将这个属性添加到了当前的实例对象中
# 这是实例方法
def test(self):
print('这是个test方法!!!')
# 类方法
#在类的内部使用@classmethod修饰的方式属于类方法
# 类方法的第一个参数cls,也会自动传递,cls表示的就是当前的类对象
@classmethod
def test2(cls):
print('这是个test2方法!!!')
print(cls.count)
# 静态方法
# 在类中被@staticmethod来修饰的方法属于静态方法
@staticmethod
def test3(self):
print('这是个test3方法!!!')
a=A()
# 实例属性:通过实例对象添加的属性是实例属性
# a.count=10
# A.count=10
# print('A',A.count)
# print('a',a.count)
#
# print('a',a.name)
# print('A',A.name)这个是会报错的
# 实例属性只能通过实例对象来访问、修改,类对象无法访问修改
a.test()
A.test(a)
# a.test()等价于A.test(a)
A.test2()
a.test2()
# A.test2()等价于a.test2()
A.test3()
a.test3()
结果显示:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2020/9/18 0018 13:24
# @Author : Oliver
class A:
# 类属性:直接在类中定义的属性就是类属性
# 类属性可以通过类对象和实例对象来访问
# 类属性只能通过类对象来修改,不能通过实例对象来修改
count=0
def __init__(self):
self.name='张三'
# 这其实是一个实例属性,因为self就是a,通过self将这个属性添加到了当前的实例对象中
# 这是实例方法
def test(self):
print('这是个test方法!!!')
# 类方法
#在类的内部使用@classmethod修饰的方式属于类方法
# 类方法的第一个参数cls,也会自动传递,cls表示的就是当前的类对象
@classmethod
def test2(cls):
print('这是个test2方法!!!')
print(cls.count)
# 静态方法
# 在类中被@staticmethod来修饰的方法属于静态方法
@staticmethod
def test3(self):
print('这是个test3方法!!!')
a=A()
# 实例属性:通过实例对象添加的属性是实例属性
# a.count=10
# A.count=10
# print('A',A.count)
# print('a',a.count)
#
# print('a',a.name)
# print('A',A.name)这个是会报错的
# 实例属性只能通过实例对象来访问、修改,类对象无法访问修改
a.test()
A.test(a)
# a.test()等价于A.test(a)
A.test2()
a.test2()
# A.test2()等价于a.test2()
A.test3()
a.test3()