面向对象三大特征——封装、继承、多态
一、封装
面向对象的三大特征:封装 , 继承 , 多态
封装:把功能代码 ,数据封装到某个地方 , 需要的时候进行调用,提高程序的安全性。
即把属性以及方法放到类中,通过类来操作数据或者调用一些功能。
通过封装。可以将一些不想给用户看到的功能可以进行隐藏,用户只能访问我们公开的功能,这样提高了数据的安全性,也对后期的维护降低了维护成本。
进行封装的好处:便于分工,便于复用 , 可扩展性强。
class Dog:
'''
类文档
这个类的说明,这个类的用途 , 大体有什么方法
'''
# 类属性
name = '哈士奇'
sex = '女'
def __init__(self , name , age , weight):
self.name = name
self.age = age
self.weight = weight
def sleep(self):
print(f'{self.name}在大门口呼呼睡')
def eat(self):
print(f'{self.name}想要吃饭 , 体重{self.weight},过重不让吃')
erha = Dog('二哈',1.5 , 30)
print(erha.name)
print(erha.sex)
# erha.sleep()
# erha.eat()
# print(Dog.__dict__)
# 获取类的类文档内容
# print(Dog.__doc__)
1、属性、方法隐藏
在类中定义了一些数据或者功能不希望被外部访问或者操作的时候,可以将数据或者功能进行隐藏
将属性或者方法名前面加上两个下划线 , 隐藏属性只能在类内部访问
python中没有绝对的隐藏 , 改变一个访问方式就可以进行访问了
class People:
def __init__(self , name , age):
self.name = name
self.__age = age
def __eat(self):
print('狼吞虎咽')
cx = People('初雪',25)
# print(cx.name)
# # print(cx.__age)
#
# print(cx.__dict__)
#
# # 访问隐藏的属性或者方法
# # 对象名._类名__属性名/方法名
# print(cx._People__age)
# cx._People__eat()
class Bank:
def __get(self):
print('取钱')
def __set(self):
print('存钱')
# 通过另一个方法进行访问 , 而不直接访问功能方法
def money(self):
self.__get()
self.__set()
a = Bank()
a.money()
2、属性权限设置
class People:
def __init__(self , name):
self.__name = name
# 可以访问name属性的函数
def getname(self):
return self.__name
# 可以修改name属性的函数
def setname(self , name):
self.__name = name
cx = People('初雪')
print(cx._People__name)
print(cx.getname())
cx.setname('cx')
print(cx.getname())
property()函数
property可以设置、获取、删除对象属性,也可以限制用户对属性的获取(访问)与设置(修改)
property(fget = None , fset = None , fdel = None)
# fget 是获取属性值的方法
# fset 是设置属性值的方法
# fdel 是删除属性值的方法
class A:
def __init__(self):
self.name = '初雪'
self.__age = 18
# 获取age属性值的方法
def get_age(self):
return self.__age
# 设置(修改)age属性值
def set_age(self , value):
self.__age = value
# property属性代理
# 这里的变量名要跟隐藏的属性名一致 , 方便属性使用访问
age = property(fget=get_age , fset=set_age)
c = A()
print(c.name)
print(c.age)
c.age = 24
print(c.age)
property装饰器
@property是property提供的比较简洁的写法
@property 装饰的方法是获取属性值的方法,被装饰方法的名称会被作为属性名,跟隐藏的属性名一致 , 方便属性使用访问
@属性名.setter 装饰的方法是设置属性值的方法
@属性名.deleter 装饰的方法是删除属性值的方法
class A:
def __init__(self):
self.name = '初雪'
self.__age = 18
# 设置访问age属性值的方法
@property
def age(self):
return self.__age
@age.setter
def age(self , value):
self.__age = value
@age.deleter
def age(self):
del self.__age
c = A()
# print(c.age)
# c.age = 24
# print(c.age)
del c.age
二、继承
继承:生活中,儿子继承父亲的财产(我要回去继承皇位了),在python中是在多个类中一个所属关系,被继承的类称为父类 , 接收继承的类称为子类;在继承中子类是默认继承父类中的属性与方法。
继承可以解决类与类之间代码的冗余
在python中所有类都有一个父类就是object , object就是基类,超类
在python3中都是默认继承了object类
1.1 单继承
一个子类继承一个父类
父类中的隐藏属性或者方法 , 子类是无法继承的
class Father:
def __init__(self):
self.name = '雍正'
self.clothes = '龙袍'
def eat(self):
print('吃满汉全席')
class Son(Father):
pass
ql = Son()
print(ql.clothes)
ql.eat()
1.2 重写父类中的属性与方法
在子类中如果重新定义了init初始化方法的化 , 实例化对象会默认访问自身的属性不会访问父类中的实例属性;
class Father:
def __init__(self , name ):
self.name = name
self.__clothes = '龙袍'
def eat(self):
print('吃满汉全席')
class Son(Father):
def __init__(self,age , name):
self.age = age
# 指名道姓 , 类名.方法名(self)
# Father.__init__(self , name)
# 使用super
# 在super中会自动的定位与绑定对象
super(Son , self).__init__(name)
super().__init__(name)
def run(self):
print('游山玩水')
# Father.eat(self)
super().eat()
ql = Son(86 ,'乾隆')
# ql.eat()
ql.run()
# print(ql.age)
# print(ql.name)
1.3 属性查找
对象在寻找属性的时候,——> 自身属性查找 ——>所在的类中查找 ——> 父类中
对象在寻找方法 ——>所在的类中查找 ——> 父类中
1.4 多层继承
多层继承即子类继承父类 , 父类继承对应的父类(爷爷类)……
class A:
def __init__(self):
self.money = 10
def eat(self):
print('吃鲍鱼')
class B(A):
def __init__(self):
self.money = 100
class C(B):
def eat(self):
print('吃海参')
super().eat()
cx= B()
# print(cx.money)
ltl = C()
# print(ltl.money)
ltl.eat()
1.5 多继承
多继承:一个儿子有多个父亲(到处认爹),一个子类继承多个父类
当继承中出现相同的方法则继承顺序是从左到右
class Horse:
def body(self):
print('体型健壮')
class Donkey:
def body(self):
print('体型娇小')
class Mule(Horse , Donkey):
pass
class Mule_2(Donkey , Horse):
pass
m = Mule()
# m.body()
# 查看继承顺序的
print(Mule.__mro__)
print(Horse.__mro__)
# 查看父类 , 不会出现object , 以元组的形式放回,没有继承类返回object
print(Mule.__bases__)
print(Horse.__bases__)
# 返回得到一个父类,多个父类返回最左边的 , 没有继承类返回object
print(Mule.__base__)
print(Horse.__base__)
三、多态
不同的对象 , 调用同一个方法,表现出不同的形式
多态的实现:1、必须要有类的继承;2、子类重写父类的方法
class Bus:
def ticket(self):
print('票价单价5')
class Car(Bus):
def ticket(self):
print('票价单价50')
class Train(Car):
def ticket(self):
print('票价单价90')
class People:
def money(self , c):
c.ticket()
b = Bus()
c = Car()
t = Train()
b.ticket()
c.ticket()
t.ticket()
cx = People()
cx.money(b)
cx.money(t)
cx.money(c)